From 309d8ee0ae77e617e8cd6cf2c30b0378b66498d3 Mon Sep 17 00:00:00 2001 From: Pieter Wuille Date: Fri, 25 May 2012 15:41:27 +0200 Subject: [PATCH] IPv6/AAAA record support --- Makefile | 6 +- bitcoin.cpp | 12 +- bitcoin.h | 2 +- db.cpp | 18 +- db.h | 35 ++- dns.c | 28 +- dns.h | 10 +- main.cpp | 62 +++- netbase.cpp | 827 ++++++++++++++++++++++++++++++++++++++++----------- netbase.h | 123 ++++---- protocol.cpp | 4 +- protocol.h | 6 +- test.pl | 6 +- util.h | 44 +-- 14 files changed, 859 insertions(+), 324 deletions(-) diff --git a/Makefile b/Makefile index 37e193b..35bfef8 100644 --- a/Makefile +++ b/Makefile @@ -1,8 +1,8 @@ -dnsseed: dns.o bitcoin.o netbase.o protocol.o db.o main.o - g++ -pthread -lcrypto -o dnsseed dns.o bitcoin.o netbase.o protocol.o db.o main.o +dnsseed: dns.o bitcoin.o netbase.o protocol.o db.o main.o util.o + g++ -pthread -o dnsseed dns.o bitcoin.o netbase.o protocol.o db.o main.o util.o -lcrypto %.o: %.cpp bitcoin.h netbase.h protocol.h db.h serialize.h uint256.h util.h - g++ -pthread -O2 -ggdb3 -march=nocona -Wno-invalid-offsetof -c -o $@ $< + g++ -DUSE_IPV6 -pthread -O2 -ggdb3 -march=nocona -Wno-invalid-offsetof -c -o $@ $< dns.o: dns.c gcc -pthread -std=c99 -O2 -ggdb3 -march=nocona dns.c -c -o dns.o diff --git a/bitcoin.cpp b/bitcoin.cpp index 4602d25..50b002d 100644 --- a/bitcoin.cpp +++ b/bitcoin.cpp @@ -72,7 +72,7 @@ class CNode { int64 nTime = time(NULL); uint64 nLocalNonce = BITCOIN_SEED_NONCE; int64 nLocalServices = 0; - CAddress me(CIPPort("0.0.0.0")); + CAddress me(CService("0.0.0.0")); BeginMessage("version"); int nBestHeight = REQUIRE_HEIGHT; string ver = "/bitcoin-seeder:0.01/"; @@ -132,8 +132,6 @@ class CNode { CAddress &addr = *it; // printf("%s: got address %s\n", ToString(you).c_str(), addr.ToString().c_str(), (int)(vAddr->size())); it++; - if (!addr.IsIPv4()) - continue; if (addr.nTime <= 100000000 || addr.nTime > now + 600) addr.nTime = now - 5 * 86400; vAddr->push_back(addr); @@ -192,7 +190,7 @@ class CNode { } public: - CNode(const CIPPort& ip, vector& vAddrIn) : you(ip), nHeaderStart(-1), nMessageStart(-1), vAddr(&vAddrIn), ban(0), doneAfter(0), nVersion(0) { + CNode(const CService& ip, vector& vAddrIn) : you(ip), nHeaderStart(-1), nMessageStart(-1), vAddr(&vAddrIn), ban(0), doneAfter(0), nVersion(0) { vSend.SetType(SER_NETWORK); vSend.SetVersion(0); vRecv.SetType(SER_NETWORK); @@ -204,7 +202,7 @@ public: } bool Run() { bool res = true; - if (!you.ConnectSocket(sock)) return false; + if (!ConnectSocket(you, sock)) return false; PushVersion(); Send(); int64 now; @@ -262,7 +260,7 @@ public: } }; -bool TestNode(const CIPPort &cip, int &ban, int &clientV, std::string &clientSV, vector& vAddr) { +bool TestNode(const CService &cip, int &ban, int &clientV, std::string &clientSV, vector& vAddr) { try { CNode node(cip, vAddr); bool ret = node.Run(); @@ -283,7 +281,7 @@ bool TestNode(const CIPPort &cip, int &ban, int &clientV, std::string &clientSV, /* int main(void) { - CIPPort ip("bitcoin.sipa.be", 8333, true); + CService ip("bitcoin.sipa.be", 8333, true); vector vAddr; vAddr.clear(); int ban = 0; diff --git a/bitcoin.h b/bitcoin.h index 1258b80..6db8543 100644 --- a/bitcoin.h +++ b/bitcoin.h @@ -3,6 +3,6 @@ #include "protocol.h" -bool TestNode(const CIPPort &cip, int &ban, int &client, std::string &clientSV, std::vector& vAddr); +bool TestNode(const CService &cip, int &ban, int &client, std::string &clientSV, std::vector& vAddr); #endif diff --git a/db.cpp b/db.cpp index 3284035..66023fb 100644 --- a/db.cpp +++ b/db.cpp @@ -26,7 +26,7 @@ void CAddrInfo::Update(bool good) { // 100.0 * stat1W.reliability, 100.0 * (stat1W.reliability + 1.0 - stat1W.weight), stat1W.count); } -bool CAddrDb::Get_(CIPPort &ip, int &wait) { +bool CAddrDb::Get_(CService &ip, int &wait) { int64 now = time(NULL); int cont = 0; int tot = unkId.size(); @@ -78,13 +78,13 @@ bool CAddrDb::Get_(CIPPort &ip, int &wait) { return true; } -int CAddrDb::Lookup_(const CIPPort &ip) { +int CAddrDb::Lookup_(const CService &ip) { if (ipToId.count(ip)) return ipToId[ip]; return -1; } -void CAddrDb::Good_(const CIPPort &addr, int clientV, std::string clientSV) { +void CAddrDb::Good_(const CService &addr, int clientV, std::string clientSV) { int id = Lookup_(addr); if (id == -1) return; unkId.erase(id); @@ -101,7 +101,7 @@ void CAddrDb::Good_(const CIPPort &addr, int clientV, std::string clientSV) { ourId.push_back(id); } -void CAddrDb::Bad_(const CIPPort &addr, int ban) +void CAddrDb::Bad_(const CService &addr, int ban) { int id = Lookup_(addr); if (id == -1) return; @@ -130,7 +130,7 @@ void CAddrDb::Bad_(const CIPPort &addr, int ban) nDirty++; } -void CAddrDb::Skipped_(const CIPPort &addr) +void CAddrDb::Skipped_(const CService &addr) { int id = Lookup_(addr); if (id == -1) return; @@ -144,7 +144,7 @@ void CAddrDb::Skipped_(const CIPPort &addr) void CAddrDb::Add_(const CAddress &addr, bool force) { if (!force && !addr.IsRoutable()) return; - CIPPort ipp(addr); + CService ipp(addr); if (banned.count(ipp)) { time_t bantime = banned[ipp]; if (force || (bantime < time(NULL) && addr.nTime > bantime)) @@ -180,7 +180,7 @@ void CAddrDb::Add_(const CAddress &addr, bool force) { nDirty++; } -void CAddrDb::GetIPs_(set& ips, int max, bool fOnlyIPv4) { +void CAddrDb::GetIPs_(set& ips, int max, const bool* nets) { if (goodId.size() == 0) { int id = -1; if (ourId.size() == 0) { @@ -208,8 +208,8 @@ void CAddrDb::GetIPs_(set& ips, int max, bool fOnlyIPv4) { ids.insert(id); } for (set::const_iterator it = ids.begin(); it != ids.end(); it++) { - CIPPort &ip = idToInfo[*it].ip; - if (ip.IsValid() && (!fOnlyIPv4 || ip.IsIPv4())) + CService &ip = idToInfo[*it].ip; + if (nets[ip.GetNetwork()]) ips.insert(ip); } } diff --git a/db.h b/db.h index 734ac5f..0e948d1 100644 --- a/db.h +++ b/db.h @@ -12,7 +12,7 @@ #define MIN_RETRY 1000 -std::string static inline ToString(const CIPPort &ip) { +std::string static inline ToString(const CService &ip) { std::string str = ip.ToString(); while (str.size() < 22) str += ' '; return str; @@ -44,7 +44,7 @@ public: class CAddrReport { public: - CIPPort ip; + CService ip; int clientVersion; double uptime[5]; std::string clientSubVersion; @@ -53,7 +53,7 @@ public: class CAddrInfo { private: - CIPPort ip; + CService ip; uint64_t services; int64 lastTry; int64 ourLastTry; @@ -87,7 +87,6 @@ public: if (ip.GetPort() != 8333) return false; if (!(services & NODE_NETWORK)) return false; if (!ip.IsRoutable()) return false; - if (!ip.IsIPv4()) return false; if (clientVersion && clientVersion < 32400) return false; if (total <= 3 && success * 2 >= total) return true; @@ -170,7 +169,7 @@ private: mutable CCriticalSection cs; int nId; // number of address id's std::map idToInfo; // map address id to address info (b,c,d,e) - std::map ipToId; // map ip to id (b,c,d,e) + std::map ipToId; // map ip to id (b,c,d,e) std::deque ourId; // sequence of tried nodes, in order we have tried connecting to them (c,d) std::set unkId; // set of nodes not yet tried (b) std::set goodId; // set of good nodes (d, good e) @@ -179,15 +178,15 @@ private: protected: // internal routines that assume proper locks are acquired void Add_(const CAddress &addr, bool force); // add an address - bool Get_(CIPPort &ip, int& wait); // get an IP to test (must call Good_, Bad_, or Skipped_ on result afterwards) - void Good_(const CIPPort &ip, int clientV, std::string clientSV); // mark an IP as good (must have been returned by Get_) - void Bad_(const CIPPort &ip, int ban); // mark an IP as bad (and optionally ban it) (must have been returned by Get_) - void Skipped_(const CIPPort &ip); // mark an IP as skipped (must have been returned by Get_) - int Lookup_(const CIPPort &ip); // look up id of an IP - void GetIPs_(std::set& ips, int max, bool fOnlyIPv4); // get a random set of IPs (shared lock only) + bool Get_(CService &ip, int& wait); // get an IP to test (must call Good_, Bad_, or Skipped_ on result afterwards) + void Good_(const CService &ip, int clientV, std::string clientSV); // mark an IP as good (must have been returned by Get_) + void Bad_(const CService &ip, int ban); // mark an IP as bad (and optionally ban it) (must have been returned by Get_) + void Skipped_(const CService &ip); // mark an IP as skipped (must have been returned by Get_) + int Lookup_(const CService &ip); // look up id of an IP + void GetIPs_(std::set& ips, int max, const bool* nets); // get a random set of IPs (shared lock only) public: - std::map banned; // nodes that are banned, with their unban time (a) + std::map banned; // nodes that are banned, with their unban time (a) void GetStats(CAddrDbStats &stats) { SHARED_CRITICAL_BLOCK(cs) { @@ -272,24 +271,24 @@ public: for (int i=0; i& ips, int max, bool fOnlyIPv4 = true) { + void GetIPs(std::set& ips, int max, const bool *nets) { SHARED_CRITICAL_BLOCK(cs) - GetIPs_(ips, max, fOnlyIPv4); + GetIPs_(ips, max, nets); } }; diff --git a/dns.c b/dns.c index d662c4c..8c02654 100644 --- a/dns.c +++ b/dns.c @@ -127,7 +127,9 @@ error: } -int static write_record_a(unsigned char** outpos, const unsigned char *outend, const char *name, int offset, dns_class cls, int ttl, const struct in_addr *ip) { +int static write_record_a(unsigned char** outpos, const unsigned char *outend, const char *name, int offset, dns_class cls, int ttl, const addr_t *ip) { + if (ip->v != 4) + return -6; unsigned char *oldpos = *outpos; int error = 0; int ret = write_record(outpos, outend, name, offset, TYPE_A, cls, ttl); @@ -136,16 +138,17 @@ int static write_record_a(unsigned char** outpos, const unsigned char *outend, c // rdlength *((*outpos)++) = 0; *((*outpos)++) = 4; // rdata - const unsigned char *pd = (const unsigned char*)ip; for (int i=0; i<4; i++) - *((*outpos)++) = pd[i]; + *((*outpos)++) = ip->data.v4[i]; return 0; error: *outpos = oldpos; return error; } -int static write_record_aaaa(unsigned char** outpos, const unsigned char *outend, const char *name, int offset, dns_class cls, int ttl, const struct in6_addr *ip) { +int static write_record_aaaa(unsigned char** outpos, const unsigned char *outend, const char *name, int offset, dns_class cls, int ttl, const addr_t *ip) { + if (ip->v != 6) + return -6; unsigned char *oldpos = *outpos; int error = 0; int ret = write_record(outpos, outend, name, offset, TYPE_AAAA, cls, ttl); @@ -154,9 +157,8 @@ int static write_record_aaaa(unsigned char** outpos, const unsigned char *outend // rdlength *((*outpos)++) = 0; *((*outpos)++) = 16; // rdata - const unsigned char *pd = (const unsigned char*)ip; for (int i=0; i<16; i++) - *((*outpos)++) = pd[i]; + *((*outpos)++) = ip->data.v6[i]; return 0; error: *outpos = oldpos; @@ -293,13 +295,17 @@ ssize_t static dnshandle(dns_opt_t *opt, const unsigned char *inbuf, size_t insi if (!ret2) { outbuf[7]++; } } - // A records - if ((typ == TYPE_A || typ == QTYPE_ANY) && (cls == CLASS_IN || cls == QCLASS_ANY)) { - struct in_addr addr[32]; - int naddr = opt->cb((void*)opt, addr, 32, 1); + // A/AAAA records + if ((typ == TYPE_A || typ == TYPE_AAAA || typ == QTYPE_ANY) && (cls == CLASS_IN || cls == QCLASS_ANY)) { + addr_t addr[32]; + int naddr = opt->cb((void*)opt, addr, 32, typ == TYPE_A || typ == QTYPE_ANY, typ == TYPE_AAAA || typ == QTYPE_ANY); int n = 0; while (n < naddr) { - int ret = write_record_a(&outpos, outend - auth_size, "", offset, CLASS_IN, opt->datattl, &addr[n]); + int ret = 1; + if (addr->v == 4) + ret = write_record_a(&outpos, outend - auth_size, "", offset, CLASS_IN, opt->datattl, &addr[n]); + else if (addr->v == 6) + ret = write_record_aaaa(&outpos, outend - auth_size, "", offset, CLASS_IN, opt->datattl, &addr[n]); // printf("wrote A record: %i\n", ret); if (!ret) { n++; diff --git a/dns.h b/dns.h index cfa36d2..97dd321 100644 --- a/dns.h +++ b/dns.h @@ -3,6 +3,14 @@ #include +typedef struct { + int v; + union { + unsigned char v4[4]; + unsigned char v6[16]; + } data; +} addr_t; + typedef struct { int port; int datattl; @@ -10,7 +18,7 @@ typedef struct { const char *host; const char *ns; const char *mbox; - int (*cb)(void *opt, struct in_addr *addr, int max, int ipv4only); + int (*cb)(void *opt, addr_t *addr, int max, int ipv4, int ipv6); // stats uint64_t nRequests; } dns_opt_t; diff --git a/main.cpp b/main.cpp index 206b748..a6e700a 100644 --- a/main.cpp +++ b/main.cpp @@ -105,7 +105,7 @@ CAddrDb db; extern "C" void* ThreadCrawler(void* data) { do { - CIPPort ip; + CService ip; int wait = 5; if (!db.Get(ip, wait)) { wait *= 1000; @@ -127,29 +127,50 @@ extern "C" void* ThreadCrawler(void* data) { } while(1); } -extern "C" int GetIPList(void *thread, struct in_addr *addr, int max, int ipv4only); +extern "C" int GetIPList(void *thread, addr_t *addr, int max, int ipv4, int ipv6); class CDnsThread { public: dns_opt_t dns_opt; - vector cache; + vector cache; + int nIPv4, nIPv6; time_t cacheTime; unsigned int cacheHits; uint64_t dbQueries; - void cacheHit(int ipv4only, bool force = false) { + void cacheHit(bool force = false) { + static bool nets[NET_MAX] = {}; + if (!nets[NET_IPV4]) { + nets[NET_IPV4] = true; + nets[NET_IPV6] = true; + } time_t now = time(NULL); cacheHits++; if (force || cacheHits > (cache.size()*cache.size()/400) || (cacheHits*cacheHits > cache.size() / 20 && (now - cacheTime > 5))) { - set ips; - db.GetIPs(ips, 1000, ipv4only); + set ips; + db.GetIPs(ips, 1000, nets); dbQueries++; cache.clear(); + nIPv4 = 0; + nIPv6 = 0; cache.reserve(ips.size()); - for (set::iterator it = ips.begin(); it != ips.end(); it++) { + for (set::iterator it = ips.begin(); it != ips.end(); it++) { struct in_addr addr; + struct in6_addr addr6; if ((*it).GetInAddr(&addr)) { - cache.push_back(addr); + addr_t a; + a.v = 4; + memcpy(&a.data.v4, &addr, 4); + cache.push_back(a); + nIPv4++; +#ifdef USE_IPV6 + } else if ((*it).GetIn6Addr(&addr6)) { + addr_t a; + a.v = 6; + memcpy(&a.data.v6, &addr6, 16); + cache.push_back(a); + nIPv6++; +#endif } } cacheHits = 0; @@ -171,7 +192,9 @@ public: cacheTime = 0; cacheHits = 0; dbQueries = 0; - cacheHit(true, true); + nIPv4 = 0; + nIPv6 = 0; + cacheHit(true); } void run() { @@ -179,14 +202,21 @@ public: } }; -extern "C" int GetIPList(void *data, struct in_addr *addr, int max, int ipv4only) { +extern "C" int GetIPList(void *data, addr_t* addr, int max, int ipv4, int ipv6) { CDnsThread *thread = (CDnsThread*)data; - thread->cacheHit(ipv4only); - unsigned int size = thread->cache.size(); + thread->cacheHit(); + unsigned int size = (ipv4 ? thread->nIPv4 : 0) + (ipv6 ? thread->nIPv6 : 0); if (max > size) max = size; - for (int i=0; icache[j].v == 4) || + (ipv6 && thread->cache[j].v == 6); + if (ok) break; + j = i + ((j - i + 1) % (size - i)); + } while(1); addr[i] = thread->cache[j]; thread->cache[j] = thread->cache[i]; thread->cache[i] = addr[i]; @@ -269,10 +299,10 @@ static const string seeds[] = {"dnsseed.bluematt.me", "bitseed.xf2.org", "dnssee extern "C" void* ThreadSeeder(void*) { do { for (int i=0; i ips; + vector ips; LookupHost(seeds[i].c_str(), ips); - for (vector::iterator it = ips.begin(); it != ips.end(); it++) { - db.Add(CIPPort(*it, 8333), true); + for (vector::iterator it = ips.begin(); it != ips.end(); it++) { + db.Add(CService(*it, 8333), true); } } Sleep(1800000); diff --git a/netbase.cpp b/netbase.cpp index 41caa0a..e91a252 100644 --- a/netbase.cpp +++ b/netbase.cpp @@ -1,13 +1,8 @@ // Copyright (c) 2009-2010 Satoshi Nakamoto -// Copyright (c) 2011 The Bitcoin developers +// Copyright (c) 2009-2012 The Bitcoin developers // Distributed under the MIT/X11 software license, see the accompanying -// file license.txt or http://www.opensource.org/licenses/mit-license.php. +// file COPYING or http://www.opensource.org/licenses/mit-license.php. -#define BSD_SOURCE - -#include -#include -#include #include "netbase.h" #include "util.h" @@ -15,44 +10,44 @@ #include #endif -using namespace std; - -string strprintf(const std::string &format, ...) -{ - char buffer[50000]; - char* p = buffer; - int limit = sizeof(buffer); - int ret; - loop - { - va_list arg_ptr; - va_start(arg_ptr, format); - ret = vsnprintf(p, limit, format.c_str(), arg_ptr); - va_end(arg_ptr); - if (ret >= 0 && ret < limit) - break; - if (p != buffer) - delete[] p; - limit *= 2; - p = new char[limit]; - if (p == NULL) - throw std::bad_alloc(); - } - string str(p, p+ret); - if (p != buffer) - delete[] p; - return str; -} +#include "strlcpy.h" +#include // for to_lower() +using namespace std; +// Settings +typedef std::pair proxyType; +static proxyType proxyInfo[NET_MAX]; +static proxyType nameproxyInfo; int nConnectTimeout = 5000; +bool fNameLookup = false; static const unsigned char pchIPv4[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff }; -bool static LookupIntern(const char *pszName, std::vector& vIP, int nMaxSolutions, bool fAllowLookup) +enum Network ParseNetwork(std::string net) { + boost::to_lower(net); + if (net == "ipv4") return NET_IPV4; + if (net == "ipv6") return NET_IPV6; + if (net == "tor") return NET_TOR; + if (net == "i2p") return NET_I2P; + return NET_UNROUTABLE; +} + +bool static LookupIntern(const char *pszName, std::vector& vIP, unsigned int nMaxSolutions, bool fAllowLookup) { vIP.clear(); - struct addrinfo aiHint = {}; + + { + CNetAddr addr; + if (addr.SetSpecial(std::string(pszName))) { + vIP.push_back(addr); + return true; + } + } + + struct addrinfo aiHint; + memset(&aiHint, 0, sizeof(struct addrinfo)); + aiHint.ai_socktype = SOCK_STREAM; aiHint.ai_protocol = IPPROTO_TCP; #ifdef WIN32 @@ -83,14 +78,14 @@ bool static LookupIntern(const char *pszName, std::vector& vIP, int nMaxSol if (aiTrav->ai_family == AF_INET) { assert(aiTrav->ai_addrlen >= sizeof(sockaddr_in)); - vIP.push_back(CIP(((struct sockaddr_in*)(aiTrav->ai_addr))->sin_addr)); + vIP.push_back(CNetAddr(((struct sockaddr_in*)(aiTrav->ai_addr))->sin_addr)); } #ifdef USE_IPV6 if (aiTrav->ai_family == AF_INET6) { assert(aiTrav->ai_addrlen >= sizeof(sockaddr_in6)); - vIP.push_back(CIP(((struct sockaddr_in6*)(aiTrav->ai_addr))->sin6_addr)); + vIP.push_back(CNetAddr(((struct sockaddr_in6*)(aiTrav->ai_addr))->sin6_addr)); } #endif @@ -102,14 +97,13 @@ bool static LookupIntern(const char *pszName, std::vector& vIP, int nMaxSol return (vIP.size() > 0); } -bool LookupHost(const char *pszName, std::vector& vIP, int nMaxSolutions, bool fAllowLookup) +bool LookupHost(const char *pszName, std::vector& vIP, unsigned int nMaxSolutions, bool fAllowLookup) { if (pszName[0] == 0) return false; char psz[256]; char *pszHost = psz; - strncpy(psz, pszName, sizeof(psz)-1); - psz[255] = 0; + strlcpy(psz, pszName, sizeof(psz)); if (psz[0] == '[' && psz[strlen(psz)-1] == ']') { pszHost = psz+1; @@ -119,20 +113,19 @@ bool LookupHost(const char *pszName, std::vector& vIP, int nMaxSolutions, b return LookupIntern(pszHost, vIP, nMaxSolutions, fAllowLookup); } -bool LookupHostNumeric(const char *pszName, std::vector& vIP, int nMaxSolutions) +bool LookupHostNumeric(const char *pszName, std::vector& vIP, unsigned int nMaxSolutions) { return LookupHost(pszName, vIP, nMaxSolutions, false); } -bool Lookup(const char *pszName, CIPPort& addr, int portDefault, bool fAllowLookup) +bool Lookup(const char *pszName, std::vector& vAddr, int portDefault, bool fAllowLookup, unsigned int nMaxSolutions) { if (pszName[0] == 0) return false; int port = portDefault; char psz[256]; char *pszHost = psz; - strncpy(psz, pszName, sizeof(psz)-1); - psz[255] = 0; + strlcpy(psz, pszName, sizeof(psz)); char* pszColon = strrchr(psz+1,':'); char *pszPortEnd = NULL; int portParsed = pszColon ? strtoul(pszColon+1, &pszPortEnd, 10) : 0; @@ -158,38 +151,201 @@ bool Lookup(const char *pszName, CIPPort& addr, int portDefault, bool fAllowLook } - std::vector vIP; - bool fRet = LookupIntern(pszHost, vIP, 1, fAllowLookup); + std::vector vIP; + bool fRet = LookupIntern(pszHost, vIP, nMaxSolutions, fAllowLookup); + if (!fRet) + return false; + vAddr.resize(vIP.size()); + for (unsigned int i = 0; i < vIP.size(); i++) + vAddr[i] = CService(vIP[i], port); + return true; +} + +bool Lookup(const char *pszName, CService& addr, int portDefault, bool fAllowLookup) +{ + std::vector vService; + bool fRet = Lookup(pszName, vService, portDefault, fAllowLookup, 1); if (!fRet) return false; - addr = CIPPort(vIP[0], port); + addr = vService[0]; return true; } -bool LookupNumeric(const char *pszName, CIPPort& addr, int portDefault) +bool LookupNumeric(const char *pszName, CService& addr, int portDefault) { return Lookup(pszName, addr, portDefault, false); } -bool CIPPort::ConnectSocket(SOCKET& hSocketRet, int nTimeout) const +bool static Socks4(const CService &addrDest, SOCKET& hSocket) { - hSocketRet = INVALID_SOCKET; + printf("SOCKS4 connecting %s\n", addrDest.ToString().c_str()); + if (!addrDest.IsIPv4()) + { + closesocket(hSocket); + return error("Proxy destination is not IPv4"); + } + char pszSocks4IP[] = "\4\1\0\0\0\0\0\0user"; + struct sockaddr_in addr; + socklen_t len = sizeof(addr); + if (!addrDest.GetSockAddr((struct sockaddr*)&addr, &len) || addr.sin_family != AF_INET) + { + closesocket(hSocket); + return error("Cannot get proxy destination address"); + } + memcpy(pszSocks4IP + 2, &addr.sin_port, 2); + memcpy(pszSocks4IP + 4, &addr.sin_addr, 4); + char* pszSocks4 = pszSocks4IP; + int nSize = sizeof(pszSocks4IP); - SOCKET hSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); - if (hSocket == INVALID_SOCKET) + int ret = send(hSocket, pszSocks4, nSize, MSG_NOSIGNAL); + if (ret != nSize) { - // printf("Failed to create socket: %s\n", strerror(errno)); + closesocket(hSocket); + return error("Error sending to proxy"); + } + char pchRet[8]; + if (recv(hSocket, pchRet, 8, 0) != 8) + { + closesocket(hSocket); + return error("Error reading proxy response"); + } + if (pchRet[1] != 0x5a) + { + closesocket(hSocket); + if (pchRet[1] != 0x5b) + printf("ERROR: Proxy returned error %d\n", pchRet[1]); return false; } + printf("SOCKS4 connected %s\n", addrDest.ToString().c_str()); + return true; +} + +bool static Socks5(string strDest, int port, SOCKET& hSocket) +{ + printf("SOCKS5 connecting %s\n", strDest.c_str()); + if (strDest.size() > 255) + { + closesocket(hSocket); + return error("Hostname too long"); + } + char pszSocks5Init[] = "\5\1\0"; + char *pszSocks5 = pszSocks5Init; + ssize_t nSize = sizeof(pszSocks5Init); + ssize_t ret = send(hSocket, pszSocks5, nSize, MSG_NOSIGNAL); + if (ret != nSize) + { + closesocket(hSocket); + return error("Error sending to proxy"); + } + char pchRet1[2]; + if (recv(hSocket, pchRet1, 2, 0) != 2) + { + closesocket(hSocket); + return error("Error reading proxy response"); + } + if (pchRet1[0] != 0x05 || pchRet1[1] != 0x00) + { + closesocket(hSocket); + return error("Proxy failed to initialize"); + } + string strSocks5("\5\1"); + strSocks5 += '\000'; strSocks5 += '\003'; + strSocks5 += static_cast(std::min((int)strDest.size(), 255)); + strSocks5 += strDest; + strSocks5 += static_cast((port >> 8) & 0xFF); + strSocks5 += static_cast((port >> 0) & 0xFF); + ret = send(hSocket, strSocks5.c_str(), strSocks5.size(), MSG_NOSIGNAL); + if (ret != (ssize_t)strSocks5.size()) + { + closesocket(hSocket); + return error("Error sending to proxy"); + } + char pchRet2[4]; + if (recv(hSocket, pchRet2, 4, 0) != 4) + { + closesocket(hSocket); + return error("Error reading proxy response"); + } + if (pchRet2[0] != 0x05) + { + closesocket(hSocket); + return error("Proxy failed to accept request"); + } + if (pchRet2[1] != 0x00) + { + closesocket(hSocket); + switch (pchRet2[1]) + { + case 0x01: return error("Proxy error: general failure"); + case 0x02: return error("Proxy error: connection not allowed"); + case 0x03: return error("Proxy error: network unreachable"); + case 0x04: return error("Proxy error: host unreachable"); + case 0x05: return error("Proxy error: connection refused"); + case 0x06: return error("Proxy error: TTL expired"); + case 0x07: return error("Proxy error: protocol error"); + case 0x08: return error("Proxy error: address type not supported"); + default: return error("Proxy error: unknown"); + } + } + if (pchRet2[2] != 0x00) + { + closesocket(hSocket); + return error("Error: malformed proxy response"); + } + char pchRet3[256]; + switch (pchRet2[3]) + { + case 0x01: ret = recv(hSocket, pchRet3, 4, 0) != 4; break; + case 0x04: ret = recv(hSocket, pchRet3, 16, 0) != 16; break; + case 0x03: + { + ret = recv(hSocket, pchRet3, 1, 0) != 1; + if (ret) + return error("Error reading from proxy"); + int nRecv = pchRet3[0]; + ret = recv(hSocket, pchRet3, nRecv, 0) != nRecv; + break; + } + default: closesocket(hSocket); return error("Error: malformed proxy response"); + } + if (ret) + { + closesocket(hSocket); + return error("Error reading from proxy"); + } + if (recv(hSocket, pchRet3, 2, 0) != 2) + { + closesocket(hSocket); + return error("Error reading from proxy"); + } + printf("SOCKS5 connected %s\n", strDest.c_str()); + return true; +} + +bool static ConnectSocketDirectly(const CService &addrConnect, SOCKET& hSocketRet, int nTimeout) +{ + hSocketRet = INVALID_SOCKET; + +#ifdef USE_IPV6 + struct sockaddr_storage sockaddr; +#else + struct sockaddr sockaddr; +#endif + socklen_t len = sizeof(sockaddr); + if (!addrConnect.GetSockAddr((struct sockaddr*)&sockaddr, &len)) { + printf("Cannot connect to %s: unsupported network\n", addrConnect.ToString().c_str()); + return false; + } + + SOCKET hSocket = socket(((struct sockaddr*)&sockaddr)->sa_family, SOCK_STREAM, IPPROTO_TCP); + if (hSocket == INVALID_SOCKET) + return false; #ifdef SO_NOSIGPIPE int set = 1; setsockopt(hSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&set, sizeof(int)); #endif - struct sockaddr_in sockaddr; - GetSockAddr(&sockaddr); - #ifdef WIN32 u_long fNonblock = 1; if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR) @@ -198,12 +354,11 @@ bool CIPPort::ConnectSocket(SOCKET& hSocketRet, int nTimeout) const if (fcntl(hSocket, F_SETFL, fFlags | O_NONBLOCK) == -1) #endif { - // printf("Failed to set socket NONBLOCK\n"); closesocket(hSocket); + return false; } - - if (connect(hSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR) + if (connect(hSocket, (struct sockaddr*)&sockaddr, len) == SOCKET_ERROR) { // WSAEINVAL is here because some legacy version of winsock uses it if (WSAGetLastError() == WSAEINPROGRESS || WSAGetLastError() == WSAEWOULDBLOCK || WSAGetLastError() == WSAEINVAL) @@ -218,13 +373,13 @@ bool CIPPort::ConnectSocket(SOCKET& hSocketRet, int nTimeout) const int nRet = select(hSocket + 1, NULL, &fdset, NULL, &timeout); if (nRet == 0) { - // printf("connection timeout\n"); + printf("connection timeout\n"); closesocket(hSocket); return false; } if (nRet == SOCKET_ERROR) { - // printf("select() for connection failed: %s\n",strerror(WSAGetLastError())); + printf("select() for connection failed: %i\n",WSAGetLastError()); closesocket(hSocket); return false; } @@ -235,13 +390,13 @@ bool CIPPort::ConnectSocket(SOCKET& hSocketRet, int nTimeout) const if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, &nRet, &nRetSize) == SOCKET_ERROR) #endif { - // printf("getsockopt() for connection failed: %s\n",strerror(WSAGetLastError())); + printf("getsockopt() for connection failed: %i\n",WSAGetLastError()); closesocket(hSocket); return false; } if (nRet != 0) { - // printf("connect() failed after select(): %s\n",strerror(nRet)); + printf("connect() failed after select(): %s\n",strerror(nRet)); closesocket(hSocket); return false; } @@ -252,7 +407,7 @@ bool CIPPort::ConnectSocket(SOCKET& hSocketRet, int nTimeout) const else #endif { - // printf("connect() failed: %i\n",WSAGetLastError()); + printf("connect() failed: %i\n",WSAGetLastError()); closesocket(hSocket); return false; } @@ -269,7 +424,6 @@ bool CIPPort::ConnectSocket(SOCKET& hSocketRet, int nTimeout) const if (fcntl(hSocket, F_SETFL, fFlags & !O_NONBLOCK) == SOCKET_ERROR) #endif { - // printf("Failed to set socket blocking\n"); closesocket(hSocket); return false; } @@ -278,61 +432,208 @@ bool CIPPort::ConnectSocket(SOCKET& hSocketRet, int nTimeout) const return true; } -void CIP::Init() +bool SetProxy(enum Network net, CService addrProxy, int nSocksVersion) { + assert(net >= 0 && net < NET_MAX); + if (nSocksVersion != 0 && nSocksVersion != 4 && nSocksVersion != 5) + return false; + if (nSocksVersion != 0 && !addrProxy.IsValid()) + return false; + proxyInfo[net] = std::make_pair(addrProxy, nSocksVersion); + return true; +} + +bool GetProxy(enum Network net, CService &addrProxy) { + assert(net >= 0 && net < NET_MAX); + if (!proxyInfo[net].second) + return false; + addrProxy = proxyInfo[net].first; + return true; +} + +bool SetNameProxy(CService addrProxy, int nSocksVersion) { + if (nSocksVersion != 0 && nSocksVersion != 5) + return false; + if (nSocksVersion != 0 && !addrProxy.IsValid()) + return false; + nameproxyInfo = std::make_pair(addrProxy, nSocksVersion); + return true; +} + +bool GetNameProxy() { + return nameproxyInfo.second != 0; +} + +bool IsProxy(const CNetAddr &addr) { + for (int i=0; i= 0) { + strDest = strDest.substr(0, colon); + if (n > 0 && n < 0x10000) + port = n; + } + } + if (strDest[0] == '[' && strDest[strDest.size()-1] == ']') + strDest = strDest.substr(1, strDest.size()-2); + + SOCKET hSocket = INVALID_SOCKET; + CService addrResolved(CNetAddr(strDest, fNameLookup && !nameproxyInfo.second), port); + if (addrResolved.IsValid()) { + addr = addrResolved; + return ConnectSocket(addr, hSocketRet, nTimeout); + } + addr = CService("0.0.0.0:0"); + if (!nameproxyInfo.second) + return false; + if (!ConnectSocketDirectly(nameproxyInfo.first, hSocket, nTimeout)) + return false; + + switch(nameproxyInfo.second) + { + default: + case 4: return false; + case 5: + if (!Socks5(strDest, port, hSocket)) + return false; + break; + } + + hSocketRet = hSocket; + return true; +} + +void CNetAddr::Init() { memset(ip, 0, 16); } -void CIP::SetIP(const CIP& ipIn) +void CNetAddr::SetIP(const CNetAddr& ipIn) { memcpy(ip, ipIn.ip, sizeof(ip)); } -CIP::CIP() +static const unsigned char pchOnionCat[] = {0xFD,0x87,0xD8,0x7E,0xEB,0x43}; +static const unsigned char pchGarliCat[] = {0xFD,0x60,0xDB,0x4D,0xDD,0xB5}; + +bool CNetAddr::SetSpecial(const std::string &strName) +{ + if (strName.size()>6 && strName.substr(strName.size() - 6, 6) == ".onion") { + std::vector vchAddr = DecodeBase32(strName.substr(0, strName.size() - 6).c_str()); + if (vchAddr.size() != 16-sizeof(pchOnionCat)) + return false; + memcpy(ip, pchOnionCat, sizeof(pchOnionCat)); + for (int i=0; i<16-sizeof(pchOnionCat); i++) + ip[i + sizeof(pchOnionCat)] = vchAddr[i]; + return true; + } + if (strName.size()>11 && strName.substr(strName.size() - 11, 11) == ".oc.b32.i2p") { + std::vector vchAddr = DecodeBase32(strName.substr(0, strName.size() - 11).c_str()); + if (vchAddr.size() != 16-sizeof(pchGarliCat)) + return false; + memcpy(ip, pchOnionCat, sizeof(pchGarliCat)); + for (int i=0; i<16-sizeof(pchGarliCat); i++) + ip[i + sizeof(pchGarliCat)] = vchAddr[i]; + return true; + } + return false; +} + +CNetAddr::CNetAddr() { Init(); } -CIP::CIP(const struct in_addr& ipv4Addr) +CNetAddr::CNetAddr(const struct in_addr& ipv4Addr) { memcpy(ip, pchIPv4, 12); memcpy(ip+12, &ipv4Addr, 4); } #ifdef USE_IPV6 -CIP::CIP(const struct in6_addr& ipv6Addr) +CNetAddr::CNetAddr(const struct in6_addr& ipv6Addr) { memcpy(ip, &ipv6Addr, 16); } #endif -CIP::CIP(const char *pszIp, bool fAllowLookup) +CNetAddr::CNetAddr(const char *pszIp, bool fAllowLookup) { Init(); - std::vector vIP; + std::vector vIP; if (LookupHost(pszIp, vIP, 1, fAllowLookup)) *this = vIP[0]; } -CIP::CIP(const std::string &strIp, bool fAllowLookup) +CNetAddr::CNetAddr(const std::string &strIp, bool fAllowLookup) { Init(); - std::vector vIP; + std::vector vIP; if (LookupHost(strIp.c_str(), vIP, 1, fAllowLookup)) *this = vIP[0]; } -int CIP::GetByte(int n) const +int CNetAddr::GetByte(int n) const { return ip[15-n]; } -bool CIP::IsIPv4() const +bool CNetAddr::IsIPv4() const { return (memcmp(ip, pchIPv4, sizeof(pchIPv4)) == 0); } -bool CIP::IsRFC1918() const +bool CNetAddr::IsIPv6() const +{ + return (!IsIPv4() && !IsTor() && !IsI2P()); +} + +bool CNetAddr::IsRFC1918() const { return IsIPv4() && ( GetByte(3) == 10 || @@ -340,55 +641,65 @@ bool CIP::IsRFC1918() const (GetByte(3) == 172 && (GetByte(2) >= 16 && GetByte(2) <= 31))); } -bool CIP::IsRFC3927() const +bool CNetAddr::IsRFC3927() const { return IsIPv4() && (GetByte(3) == 169 && GetByte(2) == 254); } -bool CIP::IsRFC3849() const +bool CNetAddr::IsRFC3849() const { return GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0x0D && GetByte(12) == 0xB8; } -bool CIP::IsRFC3964() const +bool CNetAddr::IsRFC3964() const { return (GetByte(15) == 0x20 && GetByte(14) == 0x02); } -bool CIP::IsRFC6052() const +bool CNetAddr::IsRFC6052() const { static const unsigned char pchRFC6052[] = {0,0x64,0xFF,0x9B,0,0,0,0,0,0,0,0}; return (memcmp(ip, pchRFC6052, sizeof(pchRFC6052)) == 0); } -bool CIP::IsRFC4380() const +bool CNetAddr::IsRFC4380() const { return (GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0 && GetByte(12) == 0); } -bool CIP::IsRFC4862() const +bool CNetAddr::IsRFC4862() const { static const unsigned char pchRFC4862[] = {0xFE,0x80,0,0,0,0,0,0}; return (memcmp(ip, pchRFC4862, sizeof(pchRFC4862)) == 0); } -bool CIP::IsRFC4193() const +bool CNetAddr::IsRFC4193() const { return ((GetByte(15) & 0xFE) == 0xFC); } -bool CIP::IsRFC6145() const +bool CNetAddr::IsRFC6145() const { static const unsigned char pchRFC6145[] = {0,0,0,0,0,0,0,0,0xFF,0xFF,0,0}; return (memcmp(ip, pchRFC6145, sizeof(pchRFC6145)) == 0); } -bool CIP::IsRFC4843() const +bool CNetAddr::IsRFC4843() const +{ + return (GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0x00 && (GetByte(12) & 0xF0) == 0x10); +} + +bool CNetAddr::IsTor() const +{ + return (memcmp(ip, pchOnionCat, sizeof(pchOnionCat)) == 0); +} + +bool CNetAddr::IsI2P() const { - return (GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0x00 && GetByte(12) & 0xF0 == 0x10); + return (memcmp(ip, pchGarliCat, sizeof(pchGarliCat)) == 0); } -bool CIP::IsLocal() const +bool CNetAddr::IsLocal() const { // IPv4 loopback if (IsIPv4() && (GetByte(3) == 127 || GetByte(3) == 0)) @@ -402,13 +713,13 @@ bool CIP::IsLocal() const return false; } -bool CIP::IsMulticast() const +bool CNetAddr::IsMulticast() const { return (IsIPv4() && (GetByte(3) & 0xF0) == 0xE0) || (GetByte(15) == 0xFF); } -bool CIP::IsValid() const +bool CNetAddr::IsValid() const { // Clean up 3-byte shifted addresses caused by garbage in size field // of addr messages from versions before 0.2.9 checksum. @@ -444,13 +755,46 @@ bool CIP::IsValid() const return true; } -bool CIP::IsRoutable() const +bool CNetAddr::IsRoutable() const { - return IsValid() && !(IsRFC1918() || IsRFC3927() || IsRFC4862() || IsRFC4193() || IsRFC4843() || IsLocal()); + return IsValid() && !(IsRFC1918() || IsRFC3927() || IsRFC4862() || (IsRFC4193() && !IsTor() && !IsI2P()) || IsRFC4843() || IsLocal()); } -std::string CIP::ToString() const +enum Network CNetAddr::GetNetwork() const { + if (!IsRoutable()) + return NET_UNROUTABLE; + + if (IsIPv4()) + return NET_IPV4; + + if (IsTor()) + return NET_TOR; + + if (IsI2P()) + return NET_I2P; + + return NET_IPV6; +} + +std::string CNetAddr::ToStringIP() const +{ + if (IsTor()) + return EncodeBase32(&ip[6], 10) + ".onion"; + if (IsI2P()) + return EncodeBase32(&ip[6], 10) + ".oc.b32.i2p"; + CService serv(*this, 0); +#ifdef USE_IPV6 + struct sockaddr_storage sockaddr; +#else + struct sockaddr sockaddr; +#endif + socklen_t socklen = sizeof(sockaddr); + if (serv.GetSockAddr((struct sockaddr*)&sockaddr, &socklen)) { + char name[1025] = ""; + if (!getnameinfo((const struct sockaddr*)&sockaddr, socklen, name, sizeof(name), NULL, 0, NI_NUMERICHOST)) + return std::string(name); + } if (IsIPv4()) return strprintf("%u.%u.%u.%u", GetByte(3), GetByte(2), GetByte(1), GetByte(0)); else @@ -461,22 +805,27 @@ std::string CIP::ToString() const GetByte(3) << 8 | GetByte(2), GetByte(1) << 8 | GetByte(0)); } -bool operator==(const CIP& a, const CIP& b) +std::string CNetAddr::ToString() const +{ + return ToStringIP(); +} + +bool operator==(const CNetAddr& a, const CNetAddr& b) { return (memcmp(a.ip, b.ip, 16) == 0); } -bool operator!=(const CIP& a, const CIP& b) +bool operator!=(const CNetAddr& a, const CNetAddr& b) { return (memcmp(a.ip, b.ip, 16) != 0); } -bool operator<(const CIP& a, const CIP& b) +bool operator<(const CNetAddr& a, const CNetAddr& b) { return (memcmp(a.ip, b.ip, 16) < 0); } -bool CIP::GetInAddr(struct in_addr* pipv4Addr) const +bool CNetAddr::GetInAddr(struct in_addr* pipv4Addr) const { if (!IsIPv4()) return false; @@ -485,7 +834,7 @@ bool CIP::GetInAddr(struct in_addr* pipv4Addr) const } #ifdef USE_IPV6 -bool CIP::GetIn6Addr(struct in6_addr* pipv6Addr) const +bool CNetAddr::GetIn6Addr(struct in6_addr* pipv6Addr) const { memcpy(pipv6Addr, ip, 16); return true; @@ -494,40 +843,59 @@ bool CIP::GetIn6Addr(struct in6_addr* pipv6Addr) const // get canonical identifier of an address' group // no two connections will be attempted to addresses with the same group -std::vector CIP::GetGroup() const +std::vector CNetAddr::GetGroup() const { std::vector vchRet; - int nClass = 0; // 0=IPv6, 1=IPv4, 255=unroutable + int nClass = NET_IPV6; int nStartByte = 0; int nBits = 16; - // for unroutable addresses, each address is considered different - if (!IsRoutable()) + // all local addresses belong to the same group + if (IsLocal()) { nClass = 255; - nBits = 128; + nBits = 0; + } + + // all unroutable addresses belong to the same group + if (!IsRoutable()) + { + nClass = NET_UNROUTABLE; + nBits = 0; } // for IPv4 addresses, '1' + the 16 higher-order bits of the IP // includes mapped IPv4, SIIT translated IPv4, and the well-known prefix else if (IsIPv4() || IsRFC6145() || IsRFC6052()) { - nClass = 1; + nClass = NET_IPV4; nStartByte = 12; } // for 6to4 tunneled addresses, use the encapsulated IPv4 address else if (IsRFC3964()) { - nClass = 1; + nClass = NET_IPV4; nStartByte = 2; } // for Teredo-tunneled IPv6 addresses, use the encapsulated IPv4 address else if (IsRFC4380()) { - vchRet.push_back(1); + vchRet.push_back(NET_IPV4); vchRet.push_back(GetByte(3) ^ 0xFF); vchRet.push_back(GetByte(2) ^ 0xFF); return vchRet; } + else if (IsTor()) + { + nClass = NET_TOR; + nStartByte = 6; + nBits = 4; + } + else if (IsI2P()) + { + nClass = NET_I2P; + nStartByte = 6; + nBits = 4; + } // for he.net, use /36 groups else if (GetByte(15) == 0x20 && GetByte(14) == 0x11 && GetByte(13) == 0x04 && GetByte(12) == 0x70) nBits = 36; @@ -548,141 +916,232 @@ std::vector CIP::GetGroup() const return vchRet; } -int64 CIP::GetHash() const +int64 CNetAddr::GetHash() const { - if (IsIPv4()) - { - // reconstruct ip in reversed-byte order - // (the original definition of the randomizer used network-order integers on little endian architecture) - int64 ip = GetByte(0) << 24 + GetByte(1) << 16 + GetByte(2) << 8 + GetByte(3); - return ip * 7789; - } - - // for IPv6 addresses, use separate multipliers for each byte - // these numbers are from the hexadecimal expansion of 3/Pi: - static const int64 nByteMult[16] = - {0xF4764525, 0x75661FBE, 0xFA3B03BA, 0xEFCF4CA1, 0x4913E065, 0xDA655862, 0xFD7A1581, 0xCE19A812, - 0x92B6A557, 0x6374BC50, 0x096DC65F, 0x0EBA5B2B, 0x7D2CE0AB, 0x09BE7ADE, 0x5CC350EF, 0xC618E6C7}; - int64 nRet = 0; - for (int n=0; n<16; n++) - nRet += nByteMult[n]*GetByte(n); + uint256 hash = Hash(&ip[0], &ip[16]); + int64 nRet; + memcpy(&nRet, &hash, sizeof(nRet)); return nRet; } -void CIP::print() const +void CNetAddr::print() const +{ + printf("CNetAddr(%s)\n", ToString().c_str()); +} + +// C++ doesn't allow us to inherit from enums +static const int NET_UNKNOWN = NET_MAX + 0; +static const int NET_TEREDO = NET_MAX + 1; +int GetExtNetwork(const CNetAddr *addr) { - // printf("CIP(%s)\n", ToString().c_str()); + if (addr == NULL) + return NET_UNKNOWN; + if (addr->IsRFC4380()) + return NET_TEREDO; + return addr->GetNetwork(); } -void CIPPort::Init() +/** Calculates a metric for how reachable (*this) is from a given partner */ +int CNetAddr::GetReachabilityFrom(const CNetAddr *paddrPartner) const +{ + enum Reachability { + REACH_UNREACHABLE, + REACH_DEFAULT, + REACH_TEREDO, + REACH_IPV6_WEAK, + REACH_IPV4, + REACH_IPV6_STRONG, + REACH_PRIVATE + }; + + if (!IsRoutable()) + return REACH_UNREACHABLE; + + int ourNet = GetExtNetwork(this); + int theirNet = GetExtNetwork(paddrPartner); + bool fTunnel = IsRFC3964() || IsRFC6052() || IsRFC6145(); + + switch(theirNet) { + case NET_IPV4: + switch(ourNet) { + default: return REACH_DEFAULT; + case NET_IPV4: return REACH_IPV4; + } + case NET_IPV6: + switch(ourNet) { + default: return REACH_DEFAULT; + case NET_TEREDO: return REACH_TEREDO; + case NET_IPV4: return REACH_IPV4; + case NET_IPV6: return fTunnel ? REACH_IPV6_WEAK : REACH_IPV6_STRONG; // only prefer giving our IPv6 address if it's not tunneled + } + case NET_TOR: + switch(ourNet) { + default: return REACH_DEFAULT; + case NET_IPV4: return REACH_IPV4; // Tor users can connect to IPv4 as well + case NET_TOR: return REACH_PRIVATE; + } + case NET_I2P: + switch(ourNet) { + default: return REACH_DEFAULT; + case NET_I2P: return REACH_PRIVATE; + } + case NET_TEREDO: + switch(ourNet) { + default: return REACH_DEFAULT; + case NET_TEREDO: return REACH_TEREDO; + case NET_IPV6: return REACH_IPV6_WEAK; + case NET_IPV4: return REACH_IPV4; + } + case NET_UNKNOWN: + case NET_UNROUTABLE: + default: + switch(ourNet) { + default: return REACH_DEFAULT; + case NET_TEREDO: return REACH_TEREDO; + case NET_IPV6: return REACH_IPV6_WEAK; + case NET_IPV4: return REACH_IPV4; + case NET_I2P: return REACH_PRIVATE; // assume connections from unroutable addresses are + case NET_TOR: return REACH_PRIVATE; // either from Tor/I2P, or don't care about our address + } + } +} + +void CService::Init() { port = 0; } -CIPPort::CIPPort() +CService::CService() { Init(); } -CIPPort::CIPPort(const CIP& cip, unsigned short portIn) : CIP(cip), port(portIn) +CService::CService(const CNetAddr& cip, unsigned short portIn) : CNetAddr(cip), port(portIn) { } -CIPPort::CIPPort(const struct in_addr& ipv4Addr, unsigned short portIn) : CIP(ipv4Addr), port(portIn) +CService::CService(const struct in_addr& ipv4Addr, unsigned short portIn) : CNetAddr(ipv4Addr), port(portIn) { } #ifdef USE_IPV6 -CIPPort::CIPPort(const struct in6_addr& ipv6Addr, unsigned short portIn) : CIP(ipv6Addr), port(portIn) +CService::CService(const struct in6_addr& ipv6Addr, unsigned short portIn) : CNetAddr(ipv6Addr), port(portIn) { } #endif -CIPPort::CIPPort(const struct sockaddr_in& addr) : CIP(addr.sin_addr), port(ntohs(addr.sin_port)) +CService::CService(const struct sockaddr_in& addr) : CNetAddr(addr.sin_addr), port(ntohs(addr.sin_port)) { assert(addr.sin_family == AF_INET); } #ifdef USE_IPV6 -CIPPort::CIPPort(const struct sockaddr_in6 &addr) : CIP(addr.sin6_addr), port(ntohs(addr.sin6_port)) +CService::CService(const struct sockaddr_in6 &addr) : CNetAddr(addr.sin6_addr), port(ntohs(addr.sin6_port)) { assert(addr.sin6_family == AF_INET6); } #endif -CIPPort::CIPPort(const char *pszIpPort, bool fAllowLookup) +bool CService::SetSockAddr(const struct sockaddr *paddr) +{ + switch (paddr->sa_family) { + case AF_INET: + *this = CService(*(const struct sockaddr_in*)paddr); + return true; +#ifdef USE_IPV6 + case AF_INET6: + *this = CService(*(const struct sockaddr_in6*)paddr); + return true; +#endif + default: + return false; + } +} + +CService::CService(const char *pszIpPort, bool fAllowLookup) { Init(); - CIPPort ip; + CService ip; if (Lookup(pszIpPort, ip, 0, fAllowLookup)) *this = ip; } -CIPPort::CIPPort(const char *pszIp, int portIn, bool fAllowLookup) +CService::CService(const char *pszIpPort, int portDefault, bool fAllowLookup) { - std::vector ip; - if (LookupHost(pszIp, ip, 1, fAllowLookup)) - *this = CIPPort(ip[0], portIn); + Init(); + CService ip; + if (Lookup(pszIpPort, ip, portDefault, fAllowLookup)) + *this = ip; } -CIPPort::CIPPort(const std::string &strIpPort, bool fAllowLookup) +CService::CService(const std::string &strIpPort, bool fAllowLookup) { Init(); - CIPPort ip; + CService ip; if (Lookup(strIpPort.c_str(), ip, 0, fAllowLookup)) *this = ip; } -CIPPort::CIPPort(const std::string &strIp, int portIn, bool fAllowLookup) +CService::CService(const std::string &strIpPort, int portDefault, bool fAllowLookup) { - std::vector ip; - if (LookupHost(strIp.c_str(), ip, 1, fAllowLookup)) - *this = CIPPort(ip[0], portIn); + Init(); + CService ip; + if (Lookup(strIpPort.c_str(), ip, portDefault, fAllowLookup)) + *this = ip; } -unsigned short CIPPort::GetPort() const +unsigned short CService::GetPort() const { return port; } -bool operator==(const CIPPort& a, const CIPPort& b) +bool operator==(const CService& a, const CService& b) { - return (operator==((CIP)a, (CIP)b) && a.port == b.port); + return (CNetAddr)a == (CNetAddr)b && a.port == b.port; } -bool operator!=(const CIPPort& a, const CIPPort& b) +bool operator!=(const CService& a, const CService& b) { - return (operator!=((CIP)a, (CIP)b) || a.port != b.port); + return (CNetAddr)a != (CNetAddr)b || a.port != b.port; } -bool operator<(const CIPPort& a, const CIPPort& b) +bool operator<(const CService& a, const CService& b) { - return (operator<((CIP)a, (CIP)b) || (operator==((CIP)a, (CIP)b) && (a.port < b.port))); + return (CNetAddr)a < (CNetAddr)b || ((CNetAddr)a == (CNetAddr)b && a.port < b.port); } -bool CIPPort::GetSockAddr(struct sockaddr_in* paddr) const +bool CService::GetSockAddr(struct sockaddr* paddr, socklen_t *addrlen) const { - if (!IsIPv4()) - return false; - memset(paddr, 0, sizeof(struct sockaddr_in)); - if (!GetInAddr(&paddr->sin_addr)) - return false; - paddr->sin_family = AF_INET; - paddr->sin_port = htons(port); -} - + if (IsIPv4()) { + if (*addrlen < sizeof(struct sockaddr_in)) + return false; + *addrlen = sizeof(struct sockaddr_in); + struct sockaddr_in *paddrin = (struct sockaddr_in*)paddr; + memset(paddrin, 0, *addrlen); + if (!GetInAddr(&paddrin->sin_addr)) + return false; + paddrin->sin_family = AF_INET; + paddrin->sin_port = htons(port); + return true; + } #ifdef USE_IPV6 -bool CIPPort::GetSockAddr6(struct sockaddr_in6* paddr) const -{ - memset(paddr, 0, sizeof(struct sockaddr_in6)); - if (!GetIn6Addr(&paddr->sin6_addr)) - return false; - paddr->sin6_family = AF_INET6; - paddr->sin6_port = htons(port); -} + if (IsIPv6()) { + if (*addrlen < sizeof(struct sockaddr_in6)) + return false; + *addrlen = sizeof(struct sockaddr_in6); + struct sockaddr_in6 *paddrin6 = (struct sockaddr_in6*)paddr; + memset(paddrin6, 0, *addrlen); + if (!GetIn6Addr(&paddrin6->sin6_addr)) + return false; + paddrin6->sin6_family = AF_INET6; + paddrin6->sin6_port = htons(port); + return true; + } #endif + return false; +} -std::vector CIPPort::GetKey() const +std::vector CService::GetKey() const { std::vector vKey; vKey.resize(18); @@ -692,17 +1151,31 @@ std::vector CIPPort::GetKey() const return vKey; } -std::string CIPPort::ToString() const +std::string CService::ToStringPort() const +{ + return strprintf("%i", port); +} + +std::string CService::ToStringIPPort() const +{ + if (IsIPv4() || IsTor() || IsI2P()) { + return ToStringIP() + ":" + ToStringPort(); + } else { + return "[" + ToStringIP() + "]:" + ToStringPort(); + } +} + +std::string CService::ToString() const { - return CIP::ToString() + strprintf(":%i", port); + return ToStringIPPort(); } -void CIPPort::print() const +void CService::print() const { - // printf("CIPPort(%s)\n", ToString().c_str()); + printf("CService(%s)\n", ToString().c_str()); } -void CIPPort::SetPort(unsigned short portIn) +void CService::SetPort(unsigned short portIn) { port = portIn; } diff --git a/netbase.h b/netbase.h index 2e052d8..57f53e9 100644 --- a/netbase.h +++ b/netbase.h @@ -1,49 +1,52 @@ -// Copyright (c) 2011 The Bitcoin developers +// Copyright (c) 2009-2012 The Bitcoin developers // Distributed under the MIT/X11 software license, see the accompanying -// file license.txt or http://www.opensource.org/licenses/mit-license.php. +// file COPYING or http://www.opensource.org/licenses/mit-license.php. #ifndef BITCOIN_NETBASE_H #define BITCOIN_NETBASE_H #include #include +#include "serialize.h" +#include "compat.h" + +extern int nConnectTimeout; #ifdef WIN32 -#include -#include -#include -#else -#include -#include -#include -#include -#include -#include -#endif -#ifdef BSD -#include +// In MSVC, this is defined as a macro, undefine it to prevent a compile and link error +#undef SetPort #endif -#include "serialize.h" +enum Network +{ + NET_UNROUTABLE, + NET_IPV4, + NET_IPV6, + NET_TOR, + NET_I2P, -typedef int SOCKET; + NET_MAX, +}; extern int nConnectTimeout; +extern bool fNameLookup; -// IP address (IPv6, or IPv4 using mapped IPv6 range (::FFFF:0:0/96)) -class CIP +/** IP address (IPv6, or IPv4 using mapped IPv6 range (::FFFF:0:0/96)) */ +class CNetAddr { protected: unsigned char ip[16]; // in network byte order public: - CIP(); - CIP(const struct in_addr& ipv4Addr); - CIP(const char *pszIp, bool fAllowLookup = false); - CIP(const std::string &strIp, bool fAllowLookup = false); + CNetAddr(); + CNetAddr(const struct in_addr& ipv4Addr); + explicit CNetAddr(const char *pszIp, bool fAllowLookup = false); + explicit CNetAddr(const std::string &strIp, bool fAllowLookup = false); void Init(); - void SetIP(const CIP& ip); + void SetIP(const CNetAddr& ip); + bool SetSpecial(const std::string &strName); // for Tor and I2P addresses bool IsIPv4() const; // IPv4 mapped address (::FFFF:0:0/96, 0.0.0.0/0) + bool IsIPv6() const; // IPv6 address (not mapped IPv4, not Tor/I2P) bool IsRFC1918() const; // IPv4 private networks (10.0.0.0/8, 192.168.0.0/16, 172.16.0.0/12) bool IsRFC3849() const; // IPv6 documentation address (2001:0DB8::/32) bool IsRFC3927() const; // IPv4 autoconfig (169.254.0.0/16) @@ -54,25 +57,30 @@ class CIP bool IsRFC4862() const; // IPv6 autoconfig (FE80::/64) bool IsRFC6052() const; // IPv6 well-known prefix (64:FF9B::/96) bool IsRFC6145() const; // IPv6 IPv4-translated address (::FFFF:0:0:0/96) + bool IsTor() const; + bool IsI2P() const; bool IsLocal() const; bool IsRoutable() const; bool IsValid() const; bool IsMulticast() const; + enum Network GetNetwork() const; std::string ToString() const; + std::string ToStringIP() const; int GetByte(int n) const; int64 GetHash() const; bool GetInAddr(struct in_addr* pipv4Addr) const; std::vector GetGroup() const; + int GetReachabilityFrom(const CNetAddr *paddrPartner = NULL) const; void print() const; #ifdef USE_IPV6 - CIP(const struct in6_addr& pipv6Addr); + CNetAddr(const struct in6_addr& pipv6Addr); bool GetIn6Addr(struct in6_addr* pipv6Addr) const; #endif - friend bool operator==(const CIP& a, const CIP& b); - friend bool operator!=(const CIP& a, const CIP& b); - friend bool operator<(const CIP& a, const CIP& b); + friend bool operator==(const CNetAddr& a, const CNetAddr& b); + friend bool operator!=(const CNetAddr& a, const CNetAddr& b); + friend bool operator<(const CNetAddr& a, const CNetAddr& b); IMPLEMENT_SERIALIZE ( @@ -80,41 +88,43 @@ class CIP ) }; -class CIPPort : public CIP +/** A combination of a network address (CNetAddr) and a (TCP) port */ +class CService : public CNetAddr { protected: unsigned short port; // host order public: - CIPPort(); - CIPPort(const CIP& ip, unsigned short port); - CIPPort(const struct in_addr& ipv4Addr, unsigned short port); - CIPPort(const struct sockaddr_in& addr); - CIPPort(const char *pszIp, int port, bool fAllowLookup = false); - CIPPort(const char *pszIpPort, bool fAllowLookup = false); - CIPPort(const std::string& strIp, int port, bool fAllowLookup = false); - CIPPort(const std::string& strIpPort, bool fAllowLookup = false); + CService(); + CService(const CNetAddr& ip, unsigned short port); + CService(const struct in_addr& ipv4Addr, unsigned short port); + CService(const struct sockaddr_in& addr); + explicit CService(const char *pszIpPort, int portDefault, bool fAllowLookup = false); + explicit CService(const char *pszIpPort, bool fAllowLookup = false); + explicit CService(const std::string& strIpPort, int portDefault, bool fAllowLookup = false); + explicit CService(const std::string& strIpPort, bool fAllowLookup = false); void Init(); void SetPort(unsigned short portIn); unsigned short GetPort() const; - bool GetSockAddr(struct sockaddr_in* paddr) const; - bool ConnectSocket(SOCKET& hSocketRet, int nTimeout = nConnectTimeout) const; - friend bool operator==(const CIPPort& a, const CIPPort& b); - friend bool operator!=(const CIPPort& a, const CIPPort& b); - friend bool operator<(const CIPPort& a, const CIPPort& b); + bool GetSockAddr(struct sockaddr* paddr, socklen_t *addrlen) const; + bool SetSockAddr(const struct sockaddr* paddr); + friend bool operator==(const CService& a, const CService& b); + friend bool operator!=(const CService& a, const CService& b); + friend bool operator<(const CService& a, const CService& b); std::vector GetKey() const; std::string ToString() const; + std::string ToStringPort() const; + std::string ToStringIPPort() const; void print() const; #ifdef USE_IPV6 - CIPPort(const struct in6_addr& ipv6Addr, unsigned short port); - bool GetSockAddr6(struct sockaddr_in6* paddr) const; - CIPPort(const struct sockaddr_in6& addr); + CService(const struct in6_addr& ipv6Addr, unsigned short port); + CService(const struct sockaddr_in6& addr); #endif IMPLEMENT_SERIALIZE ( - CIPPort* pthis = const_cast(this); + CService* pthis = const_cast(this); READWRITE(FLATDATA(ip)); unsigned short portN = htons(port); READWRITE(portN); @@ -123,13 +133,18 @@ class CIPPort : public CIP ) }; -bool LookupHost(const char *pszName, std::vector& vIP, int nMaxSolutions = 0, bool fAllowLookup = true); -bool LookupHostNumeric(const char *pszName, std::vector& vIP, int nMaxSolutions = 0); -bool Lookup(const char *pszName, CIPPort& addr, int portDefault = 0, bool fAllowLookup = true); -bool LookupNumeric(const char *pszName, CIPPort& addr, int portDefault = 0); - -// Settings -extern int fUseProxy; -extern CIPPort addrProxy; +enum Network ParseNetwork(std::string net); +bool SetProxy(enum Network net, CService addrProxy, int nSocksVersion = 5); +bool GetProxy(enum Network net, CService &addrProxy); +bool IsProxy(const CNetAddr &addr); +bool SetNameProxy(CService addrProxy, int nSocksVersion = 5); +bool GetNameProxy(); +bool LookupHost(const char *pszName, std::vector& vIP, unsigned int nMaxSolutions = 0, bool fAllowLookup = true); +bool LookupHostNumeric(const char *pszName, std::vector& vIP, unsigned int nMaxSolutions = 0); +bool Lookup(const char *pszName, CService& addr, int portDefault = 0, bool fAllowLookup = true); +bool Lookup(const char *pszName, std::vector& vAddr, int portDefault = 0, bool fAllowLookup = true, unsigned int nMaxSolutions = 0); +bool LookupNumeric(const char *pszName, CService& addr, int portDefault = 0); +bool ConnectSocket(const CService &addr, SOCKET& hSocketRet, int nTimeout = nConnectTimeout); +bool ConnectSocketByName(CService &addr, SOCKET& hSocketRet, const char *pszDest, int portDefault = 0, int nTimeout = nConnectTimeout); #endif diff --git a/protocol.cpp b/protocol.cpp index 928f2e6..3df8a18 100644 --- a/protocol.cpp +++ b/protocol.cpp @@ -81,12 +81,12 @@ bool CMessageHeader::IsValid() const -CAddress::CAddress() : CIPPort() +CAddress::CAddress() : CService() { Init(); } -CAddress::CAddress(CIPPort ipIn, uint64 nServicesIn) : CIPPort(ipIn) +CAddress::CAddress(CService ipIn, uint64 nServicesIn) : CService(ipIn) { Init(); nServices = nServicesIn; diff --git a/protocol.h b/protocol.h index 63c1e8b..e9be1c2 100644 --- a/protocol.h +++ b/protocol.h @@ -62,18 +62,18 @@ enum NODE_NETWORK = (1 << 0), }; -class CAddress : public CIPPort +class CAddress : public CService { public: CAddress(); - CAddress(CIPPort ipIn, uint64 nServicesIn=NODE_NETWORK); + CAddress(CService ipIn, uint64 nServicesIn=NODE_NETWORK); void Init(); IMPLEMENT_SERIALIZE ( CAddress* pthis = const_cast(this); - CIPPort* pip = (CIPPort*)pthis; + CService* pip = (CService*)pthis; if (fRead) pthis->Init(); if (nType & SER_DISK) diff --git a/test.pl b/test.pl index c425e33..1f34b9a 100644 --- a/test.pl +++ b/test.pl @@ -17,8 +17,8 @@ sub go { my $sock = IO::Socket::INET->new( Proto => 'udp', - PeerPort => 5353, - PeerAddr => "127.0.0.1", + PeerPort => 53, + PeerAddr => "vps.sipa.be", ) or die "Could not create socket: $!\n"; while($run) { @@ -52,7 +52,7 @@ sub go { my @threads; -for my $i (0..3) { +for my $i (0..500) { $threads[$i] = threads->create(\&go, $i); } diff --git a/util.h b/util.h index d403129..3eedd75 100644 --- a/util.h +++ b/util.h @@ -4,6 +4,7 @@ #include #include #include +#include #include "uint256.h" @@ -26,21 +27,6 @@ #define INVALID_SOCKET (SOCKET)(~0) #define SOCKET_ERROR -1 -inline int myclosesocket(SOCKET& hSocket) -{ - if (hSocket == INVALID_SOCKET) - return WSAENOTSOCK; -#ifdef WIN32 - int ret = closesocket(hSocket); -#else - int ret = close(hSocket); -#endif - hSocket = INVALID_SOCKET; - return ret; -} -#define closesocket(s) myclosesocket(s) - - // Wrapper to automatically initialize mutex class CCriticalSection { @@ -87,10 +73,30 @@ template inline uint256 Hash(const T1 pbegin, const T1 pend) } void static inline Sleep(int nMilliSec) { - struct timespec wa; - wa.tv_sec = nMilliSec/1000; - wa.tv_nsec = (nMilliSec % 1000) * 1000000; - nanosleep(&wa, NULL); + struct timespec wa; + wa.tv_sec = nMilliSec/1000; + wa.tv_nsec = (nMilliSec % 1000) * 1000000; + nanosleep(&wa, NULL); +} + + +std::string vstrprintf(const std::string &format, va_list ap); + +std::string static inline strprintf(const std::string &format, ...) { + va_list arg_ptr; + va_start(arg_ptr, format); + std::string ret = vstrprintf(format, arg_ptr); + va_end(arg_ptr); + return ret; } +bool static inline error(std::string err) { + return false; +} + +std::vector DecodeBase32(const char* p, bool* pfInvalid = NULL); +std::string DecodeBase32(const std::string& str); +std::string EncodeBase32(const unsigned char* pch, size_t len); +std::string EncodeBase32(const std::string& str); + #endif