src/netbase.cpp

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2012 The Bitcoin developers
   3 // Distributed under the MIT/X11 software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5
   6 #include "netbase.h"
   7 #include "util.h"
   8
   9 #ifndef WIN32
  10 #include <sys/fcntl.h>
  11 #endif
  12
  13 #include "strlcpy.h"
  14 #include <boost/algorithm/string/case_conv.hpp> // for to_lower()
  15
  16 using namespace std;
  17
  18 // Settings
  19 typedef std::pair<CService, int> proxyType;
  20 static proxyType proxyInfo[NET_MAX];
  21 static proxyType nameproxyInfo;
  22 int nConnectTimeout = 5000;
  23 bool fNameLookup = false;
  24
  25 static const unsigned char pchIPv4[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff };
  26
  27 enum Network ParseNetwork(std::string net) {
  28     boost::to_lower(net);
  29     if (net == "ipv4") return NET_IPV4;
  30     if (net == "ipv6") return NET_IPV6;
  31     if (net == "tor")  return NET_TOR;
  32     if (net == "i2p")  return NET_I2P;
  33     return NET_UNROUTABLE;
  34 }
  35
  36 void SplitHostPort(std::string in, int &portOut, std::string &hostOut) {
  37     size_t colon = in.find_last_of(':');
  38     // if a : is found, and it either follows a [...], or no other : is in the string, treat it as port separator
  39     bool fHaveColon = colon != in.npos;
  40     bool fBracketed = fHaveColon && (in[0]=='[' && in[colon-1]==']'); // if there is a colon, and in[0]=='[', colon is not 0, so in[colon-1] is safe
  41     bool fMultiColon = fHaveColon && (in.find_last_of(':',colon-1) != in.npos);
  42     if (fHaveColon && (colon==0 || fBracketed || !fMultiColon)) {
  43         char *endp = NULL;
  44         int n = strtol(in.c_str() + colon + 1, &endp, 10);
  45         if (endp && *endp == 0 && n >= 0) {
  46             in = in.substr(0, colon);
  47             if (n > 0 && n < 0x10000)
  48                 portOut = n;
  49         }
  50     }
  51     if (in.size()>0 && in[0] == '[' && in[in.size()-1] == ']')
  52         hostOut = in.substr(1, in.size()-2);
  53     else
  54         hostOut = in;
  55 }
  56
  57 bool static LookupIntern(const char *pszName, std::vector<CNetAddr>& vIP, unsigned int nMaxSolutions, bool fAllowLookup)
  58 {
  59     vIP.clear();
  60
  61     {
  62         CNetAddr addr;
  63         if (addr.SetSpecial(std::string(pszName))) {
  64             vIP.push_back(addr);
  65             return true;
  66         }
  67     }
  68
  69     struct addrinfo aiHint;
  70     memset(&aiHint, 0, sizeof(struct addrinfo));
  71
  72     aiHint.ai_socktype = SOCK_STREAM;
  73     aiHint.ai_protocol = IPPROTO_TCP;
  74 #ifdef WIN32
  75 #  ifdef USE_IPV6
  76     aiHint.ai_family = AF_UNSPEC;
  77 #  else
  78     aiHint.ai_family = AF_INET;
  79 #  endif
  80     aiHint.ai_flags = fAllowLookup ? 0 : AI_NUMERICHOST;
  81 #else
  82 #  ifdef USE_IPV6
  83     aiHint.ai_family = AF_UNSPEC;
  84 #  else
  85     aiHint.ai_family = AF_INET;
  86 #  endif
  87     aiHint.ai_flags = fAllowLookup ? AI_ADDRCONFIG : AI_NUMERICHOST;
  88 #endif
  89     struct addrinfo *aiRes = NULL;
  90     int nErr = getaddrinfo(pszName, NULL, &aiHint, &aiRes);
  91     if (nErr)
  92         return false;
  93
  94     struct addrinfo *aiTrav = aiRes;
  95     while (aiTrav != NULL && (nMaxSolutions == 0 || vIP.size() < nMaxSolutions))
  96     {
  97         if (aiTrav->ai_family == AF_INET)
  98         {
  99             assert(aiTrav->ai_addrlen >= sizeof(sockaddr_in));
 100             vIP.push_back(CNetAddr(((struct sockaddr_in*)(aiTrav->ai_addr))->sin_addr));
 101         }
 102
 103 #ifdef USE_IPV6
 104         if (aiTrav->ai_family == AF_INET6)
 105         {
 106             assert(aiTrav->ai_addrlen >= sizeof(sockaddr_in6));
 107             vIP.push_back(CNetAddr(((struct sockaddr_in6*)(aiTrav->ai_addr))->sin6_addr));
 108         }
 109 #endif
 110
 111         aiTrav = aiTrav->ai_next;
 112     }
 113
 114     freeaddrinfo(aiRes);
 115
 116     return (vIP.size() > 0);
 117 }
 118
 119 bool LookupHost(const char *pszName, std::vector<CNetAddr>& vIP, unsigned int nMaxSolutions, bool fAllowLookup)
 120 {
 121     if (pszName[0] == 0)
 122         return false;
 123     char psz[256];
 124     char *pszHost = psz;
 125     strlcpy(psz, pszName, sizeof(psz));
 126     if (psz[0] == '[' && psz[strlen(psz)-1] == ']')
 127     {
 128         pszHost = psz+1;
 129         psz[strlen(psz)-1] = 0;
 130     }
 131
 132     return LookupIntern(pszHost, vIP, nMaxSolutions, fAllowLookup);
 133 }
 134
 135 bool LookupHostNumeric(const char *pszName, std::vector<CNetAddr>& vIP, unsigned int nMaxSolutions)
 136 {
 137     return LookupHost(pszName, vIP, nMaxSolutions, false);
 138 }
 139
 140 bool Lookup(const char *pszName, std::vector<CService>& vAddr, int portDefault, bool fAllowLookup, unsigned int nMaxSolutions)
 141 {
 142     if (pszName[0] == 0)
 143         return false;
 144     int port = portDefault;
 145     std::string hostname = "";
 146     SplitHostPort(std::string(pszName), port, hostname);
 147
 148     std::vector<CNetAddr> vIP;
 149     bool fRet = LookupIntern(hostname.c_str(), vIP, nMaxSolutions, fAllowLookup);
 150     if (!fRet)
 151         return false;
 152     vAddr.resize(vIP.size());
 153     for (unsigned int i = 0; i < vIP.size(); i++)
 154         vAddr[i] = CService(vIP[i], port);
 155     return true;
 156 }
 157
 158 bool Lookup(const char *pszName, CService& addr, int portDefault, bool fAllowLookup)
 159 {
 160     std::vector<CService> vService;
 161     bool fRet = Lookup(pszName, vService, portDefault, fAllowLookup, 1);
 162     if (!fRet)
 163         return false;
 164     addr = vService[0];
 165     return true;
 166 }
 167
 168 bool LookupNumeric(const char *pszName, CService& addr, int portDefault)
 169 {
 170     return Lookup(pszName, addr, portDefault, false);
 171 }
 172
 173 bool static Socks4(const CService &addrDest, SOCKET& hSocket)
 174 {
 175     printf("SOCKS4 connecting %s\n", addrDest.ToString().c_str());
 176     if (!addrDest.IsIPv4())
 177     {
 178         closesocket(hSocket);
 179         return error("Proxy destination is not IPv4");
 180     }
 181     char pszSocks4IP[] = "\4\1\0\0\0\0\0\0user";
 182     struct sockaddr_in addr;
 183     socklen_t len = sizeof(addr);
 184     if (!addrDest.GetSockAddr((struct sockaddr*)&addr, &len) || addr.sin_family != AF_INET)
 185     {
 186         closesocket(hSocket);
 187         return error("Cannot get proxy destination address");
 188     }
 189     memcpy(pszSocks4IP + 2, &addr.sin_port, 2);
 190     memcpy(pszSocks4IP + 4, &addr.sin_addr, 4);
 191     char* pszSocks4 = pszSocks4IP;
 192     int nSize = sizeof(pszSocks4IP);
 193
 194     int ret = send(hSocket, pszSocks4, nSize, MSG_NOSIGNAL);
 195     if (ret != nSize)
 196     {
 197         closesocket(hSocket);
 198         return error("Error sending to proxy");
 199     }
 200     char pchRet[8];
 201     if (recv(hSocket, pchRet, 8, 0) != 8)
 202     {
 203         closesocket(hSocket);
 204         return error("Error reading proxy response");
 205     }
 206     if (pchRet[1] != 0x5a)
 207     {
 208         closesocket(hSocket);
 209         if (pchRet[1] != 0x5b)
 210             printf("ERROR: Proxy returned error %d\n", pchRet[1]);
 211         return false;
 212     }
 213     printf("SOCKS4 connected %s\n", addrDest.ToString().c_str());
 214     return true;
 215 }
 216
 217 bool static Socks5(string strDest, int port, SOCKET& hSocket)
 218 {
 219     printf("SOCKS5 connecting %s\n", strDest.c_str());
 220     if (strDest.size() > 255)
 221     {
 222         closesocket(hSocket);
 223         return error("Hostname too long");
 224     }
 225     char pszSocks5Init[] = "\5\1\0";
 226     char *pszSocks5 = pszSocks5Init;
 227     ssize_t nSize = sizeof(pszSocks5Init) - 1;
 228
 229     ssize_t ret = send(hSocket, pszSocks5, nSize, MSG_NOSIGNAL);
 230     if (ret != nSize)
 231     {
 232         closesocket(hSocket);
 233         return error("Error sending to proxy");
 234     }
 235     char pchRet1[2];
 236     if (recv(hSocket, pchRet1, 2, 0) != 2)
 237     {
 238         closesocket(hSocket);
 239         return error("Error reading proxy response");
 240     }
 241     if (pchRet1[0] != 0x05 || pchRet1[1] != 0x00)
 242     {
 243         closesocket(hSocket);
 244         return error("Proxy failed to initialize");
 245     }
 246     string strSocks5("\5\1");
 247     strSocks5 += '\000'; strSocks5 += '\003';
 248     strSocks5 += static_cast<char>(std::min((int)strDest.size(), 255));
 249     strSocks5 += strDest;
 250     strSocks5 += static_cast<char>((port >> 8) & 0xFF);
 251     strSocks5 += static_cast<char>((port >> 0) & 0xFF);
 252     ret = send(hSocket, strSocks5.c_str(), strSocks5.size(), MSG_NOSIGNAL);
 253     if (ret != (ssize_t)strSocks5.size())
 254     {
 255         closesocket(hSocket);
 256         return error("Error sending to proxy");
 257     }
 258     char pchRet2[4];
 259     if (recv(hSocket, pchRet2, 4, 0) != 4)
 260     {
 261         closesocket(hSocket);
 262         return error("Error reading proxy response");
 263     }
 264     if (pchRet2[0] != 0x05)
 265     {
 266         closesocket(hSocket);
 267         return error("Proxy failed to accept request");
 268     }
 269     if (pchRet2[1] != 0x00)
 270     {
 271         closesocket(hSocket);
 272         switch (pchRet2[1])
 273         {
 274             case 0x01: return error("Proxy error: general failure");
 275             case 0x02: return error("Proxy error: connection not allowed");
 276             case 0x03: return error("Proxy error: network unreachable");
 277             case 0x04: return error("Proxy error: host unreachable");
 278             case 0x05: return error("Proxy error: connection refused");
 279             case 0x06: return error("Proxy error: TTL expired");
 280             case 0x07: return error("Proxy error: protocol error");
 281             case 0x08: return error("Proxy error: address type not supported");
 282             default:   return error("Proxy error: unknown");
 283         }
 284     }
 285     if (pchRet2[2] != 0x00)
 286     {
 287         closesocket(hSocket);
 288         return error("Error: malformed proxy response");
 289     }
 290     char pchRet3[256];
 291     switch (pchRet2[3])
 292     {
 293         case 0x01: ret = recv(hSocket, pchRet3, 4, 0) != 4; break;
 294         case 0x04: ret = recv(hSocket, pchRet3, 16, 0) != 16; break;
 295         case 0x03:
 296         {
 297             ret = recv(hSocket, pchRet3, 1, 0) != 1;
 298             if (ret)
 299                 return error("Error reading from proxy");
 300             int nRecv = pchRet3[0];
 301             ret = recv(hSocket, pchRet3, nRecv, 0) != nRecv;
 302             break;
 303         }
 304         default: closesocket(hSocket); return error("Error: malformed proxy response");
 305     }
 306     if (ret)
 307     {
 308         closesocket(hSocket);
 309         return error("Error reading from proxy");
 310     }
 311     if (recv(hSocket, pchRet3, 2, 0) != 2)
 312     {
 313         closesocket(hSocket);
 314         return error("Error reading from proxy");
 315     }
 316     printf("SOCKS5 connected %s\n", strDest.c_str());
 317     return true;
 318 }
 319
 320 bool static ConnectSocketDirectly(const CService &addrConnect, SOCKET& hSocketRet, int nTimeout)
 321 {
 322     hSocketRet = INVALID_SOCKET;
 323
 324 #ifdef USE_IPV6
 325     struct sockaddr_storage sockaddr;
 326 #else
 327     struct sockaddr sockaddr;
 328 #endif
 329     socklen_t len = sizeof(sockaddr);
 330     if (!addrConnect.GetSockAddr((struct sockaddr*)&sockaddr, &len)) {
 331         printf("Cannot connect to %s: unsupported network\n", addrConnect.ToString().c_str());
 332         return false;
 333     }
 334
 335     SOCKET hSocket = socket(((struct sockaddr*)&sockaddr)->sa_family, SOCK_STREAM, IPPROTO_TCP);
 336     if (hSocket == INVALID_SOCKET)
 337         return false;
 338 #ifdef SO_NOSIGPIPE
 339     int set = 1;
 340     setsockopt(hSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&set, sizeof(int));
 341 #endif
 342
 343 #ifdef WIN32
 344     u_long fNonblock = 1;
 345     if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)
 346 #else
 347     int fFlags = fcntl(hSocket, F_GETFL, 0);
 348     if (fcntl(hSocket, F_SETFL, fFlags | O_NONBLOCK) == -1)
 349 #endif
 350     {
 351         closesocket(hSocket);
 352         return false;
 353     }
 354
 355     if (connect(hSocket, (struct sockaddr*)&sockaddr, len) == SOCKET_ERROR)
 356     {
 357         // WSAEINVAL is here because some legacy version of winsock uses it
 358         if (WSAGetLastError() == WSAEINPROGRESS || WSAGetLastError() == WSAEWOULDBLOCK || WSAGetLastError() == WSAEINVAL)
 359         {
 360             struct timeval timeout;
 361             timeout.tv_sec  = nTimeout / 1000;
 362             timeout.tv_usec = (nTimeout % 1000) * 1000;
 363
 364             fd_set fdset;
 365             FD_ZERO(&fdset);
 366             FD_SET(hSocket, &fdset);
 367             int nRet = select(hSocket + 1, NULL, &fdset, NULL, &timeout);
 368             if (nRet == 0)
 369             {
 370                 printf("connection timeout\n");
 371                 closesocket(hSocket);
 372                 return false;
 373             }
 374             if (nRet == SOCKET_ERROR)
 375             {
 376                 printf("select() for connection failed: %i\n",WSAGetLastError());
 377                 closesocket(hSocket);
 378                 return false;
 379             }
 380             socklen_t nRetSize = sizeof(nRet);
 381 #ifdef WIN32
 382             if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, (char*)(&nRet), &nRetSize) == SOCKET_ERROR)
 383 #else
 384             if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, &nRet, &nRetSize) == SOCKET_ERROR)
 385 #endif
 386             {
 387                 printf("getsockopt() for connection failed: %i\n",WSAGetLastError());
 388                 closesocket(hSocket);
 389                 return false;
 390             }
 391             if (nRet != 0)
 392             {
 393                 printf("connect() failed after select(): %s\n",strerror(nRet));
 394                 closesocket(hSocket);
 395                 return false;
 396             }
 397         }
 398 #ifdef WIN32
 399         else if (WSAGetLastError() != WSAEISCONN)
 400 #else
 401         else
 402 #endif
 403         {
 404             printf("connect() failed: %i\n",WSAGetLastError());
 405             closesocket(hSocket);
 406             return false;
 407         }
 408     }
 409
 410     // this isn't even strictly necessary
 411     // CNode::ConnectNode immediately turns the socket back to non-blocking
 412     // but we'll turn it back to blocking just in case
 413 #ifdef WIN32
 414     fNonblock = 0;
 415     if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)
 416 #else
 417     fFlags = fcntl(hSocket, F_GETFL, 0);
 418     if (fcntl(hSocket, F_SETFL, fFlags & !O_NONBLOCK) == SOCKET_ERROR)
 419 #endif
 420     {
 421         closesocket(hSocket);
 422         return false;
 423     }
 424
 425     hSocketRet = hSocket;
 426     return true;
 427 }
 428
 429 bool SetProxy(enum Network net, CService addrProxy, int nSocksVersion) {
 430     assert(net >= 0 && net < NET_MAX);
 431     if (nSocksVersion != 0 && nSocksVersion != 4 && nSocksVersion != 5)
 432         return false;
 433     if (nSocksVersion != 0 && !addrProxy.IsValid())
 434         return false;
 435     proxyInfo[net] = std::make_pair(addrProxy, nSocksVersion);
 436     return true;
 437 }
 438
 439 bool GetProxy(enum Network net, CService &addrProxy) {
 440     assert(net >= 0 && net < NET_MAX);
 441     if (!proxyInfo[net].second)
 442         return false;
 443     addrProxy = proxyInfo[net].first;
 444     return true;
 445 }
 446
 447 bool SetNameProxy(CService addrProxy, int nSocksVersion) {
 448     if (nSocksVersion != 0 && nSocksVersion != 5)
 449         return false;
 450     if (nSocksVersion != 0 && !addrProxy.IsValid())
 451         return false;
 452     nameproxyInfo = std::make_pair(addrProxy, nSocksVersion);
 453     return true;
 454 }
 455
 456 bool GetNameProxy() {
 457     return nameproxyInfo.second != 0;
 458 }
 459
 460 bool IsProxy(const CNetAddr &addr) {
 461     for (int i=0; i<NET_MAX; i++) {
 462         if (proxyInfo[i].second && (addr == (CNetAddr)proxyInfo[i].first))
 463             return true;
 464     }
 465     return false;
 466 }
 467
 468 bool ConnectSocket(const CService &addrDest, SOCKET& hSocketRet, int nTimeout)
 469 {
 470     const proxyType &proxy = proxyInfo[addrDest.GetNetwork()];
 471
 472     // no proxy needed
 473     if (!proxy.second)
 474         return ConnectSocketDirectly(addrDest, hSocketRet, nTimeout);
 475
 476     SOCKET hSocket = INVALID_SOCKET;
 477
 478     // first connect to proxy server
 479     if (!ConnectSocketDirectly(proxy.first, hSocket, nTimeout))
 480         return false;
 481
 482     // do socks negotiation
 483     switch (proxy.second) {
 484     case 4:
 485         if (!Socks4(addrDest, hSocket))
 486             return false;
 487         break;
 488     case 5:
 489         if (!Socks5(addrDest.ToStringIP(), addrDest.GetPort(), hSocket))
 490             return false;
 491         break;
 492     default:
 493         return false;
 494     }
 495
 496     hSocketRet = hSocket;
 497     return true;
 498 }
 499
 500 bool ConnectSocketByName(CService &addr, SOCKET& hSocketRet, const char *pszDest, int portDefault, int nTimeout)
 501 {
 502     string strDest;
 503     int port = portDefault;
 504     SplitHostPort(string(pszDest), port, strDest);
 505
 506     SOCKET hSocket = INVALID_SOCKET;
 507     CService addrResolved(CNetAddr(strDest, fNameLookup && !nameproxyInfo.second), port);
 508     if (addrResolved.IsValid()) {
 509         addr = addrResolved;
 510         return ConnectSocket(addr, hSocketRet, nTimeout);
 511     }
 512     addr = CService("0.0.0.0:0");
 513     if (!nameproxyInfo.second)
 514         return false;
 515     if (!ConnectSocketDirectly(nameproxyInfo.first, hSocket, nTimeout))
 516         return false;
 517
 518     switch(nameproxyInfo.second)
 519     {
 520         default:
 521         case 4: return false;
 522         case 5:
 523             if (!Socks5(strDest, port, hSocket))
 524                 return false;
 525             break;
 526     }
 527
 528     hSocketRet = hSocket;
 529     return true;
 530 }
 531
 532 void CNetAddr::Init()
 533 {
 534     memset(ip, 0, 16);
 535 }
 536
 537 void CNetAddr::SetIP(const CNetAddr& ipIn)
 538 {
 539     memcpy(ip, ipIn.ip, sizeof(ip));
 540 }
 541
 542 static const unsigned char pchOnionCat[] = {0xFD,0x87,0xD8,0x7E,0xEB,0x43};
 543 static const unsigned char pchGarliCat[] = {0xFD,0x60,0xDB,0x4D,0xDD,0xB5};
 544
 545 bool CNetAddr::SetSpecial(const std::string &strName)
 546 {
 547     if (strName.size()>6 && strName.substr(strName.size() - 6, 6) == ".onion") {
 548         std::vector<unsigned char> vchAddr = DecodeBase32(strName.substr(0, strName.size() - 6).c_str());
 549         if (vchAddr.size() != 16-sizeof(pchOnionCat))
 550             return false;
 551         memcpy(ip, pchOnionCat, sizeof(pchOnionCat));
 552         for (unsigned int i=0; i<16-sizeof(pchOnionCat); i++)
 553             ip[i + sizeof(pchOnionCat)] = vchAddr[i];
 554         return true;
 555     }
 556     if (strName.size()>11 && strName.substr(strName.size() - 11, 11) == ".oc.b32.i2p") {
 557         std::vector<unsigned char> vchAddr = DecodeBase32(strName.substr(0, strName.size() - 11).c_str());
 558         if (vchAddr.size() != 16-sizeof(pchGarliCat))
 559             return false;
 560         memcpy(ip, pchOnionCat, sizeof(pchGarliCat));
 561         for (unsigned int i=0; i<16-sizeof(pchGarliCat); i++)
 562             ip[i + sizeof(pchGarliCat)] = vchAddr[i];
 563         return true;
 564     }
 565     return false;
 566 }
 567
 568 CNetAddr::CNetAddr()
 569 {
 570     Init();
 571 }
 572
 573 CNetAddr::CNetAddr(const struct in_addr& ipv4Addr)
 574 {
 575     memcpy(ip,    pchIPv4, 12);
 576     memcpy(ip+12, &ipv4Addr, 4);
 577 }
 578
 579 #ifdef USE_IPV6
 580 CNetAddr::CNetAddr(const struct in6_addr& ipv6Addr)
 581 {
 582     memcpy(ip, &ipv6Addr, 16);
 583 }
 584 #endif
 585
 586 CNetAddr::CNetAddr(const char *pszIp, bool fAllowLookup)
 587 {
 588     Init();
 589     std::vector<CNetAddr> vIP;
 590     if (LookupHost(pszIp, vIP, 1, fAllowLookup))
 591         *this = vIP[0];
 592 }
 593
 594 CNetAddr::CNetAddr(const std::string &strIp, bool fAllowLookup)
 595 {
 596     Init();
 597     std::vector<CNetAddr> vIP;
 598     if (LookupHost(strIp.c_str(), vIP, 1, fAllowLookup))
 599         *this = vIP[0];
 600 }
 601
 602 int CNetAddr::GetByte(int n) const
 603 {
 604     return ip[15-n];
 605 }
 606
 607 bool CNetAddr::IsIPv4() const
 608 {
 609     return (memcmp(ip, pchIPv4, sizeof(pchIPv4)) == 0);
 610 }
 611
 612 bool CNetAddr::IsIPv6() const
 613 {
 614     return (!IsIPv4() && !IsTor() && !IsI2P());
 615 }
 616
 617 bool CNetAddr::IsRFC1918() const
 618 {
 619     return IsIPv4() && (
 620         GetByte(3) == 10 ||
 621         (GetByte(3) == 192 && GetByte(2) == 168) ||
 622         (GetByte(3) == 172 && (GetByte(2) >= 16 && GetByte(2) <= 31)));
 623 }
 624
 625 bool CNetAddr::IsRFC3927() const
 626 {
 627     return IsIPv4() && (GetByte(3) == 169 && GetByte(2) == 254);
 628 }
 629
 630 bool CNetAddr::IsRFC3849() const
 631 {
 632     return GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0x0D && GetByte(12) == 0xB8;
 633 }
 634
 635 bool CNetAddr::IsRFC3964() const
 636 {
 637     return (GetByte(15) == 0x20 && GetByte(14) == 0x02);
 638 }
 639
 640 bool CNetAddr::IsRFC6052() const
 641 {
 642     static const unsigned char pchRFC6052[] = {0,0x64,0xFF,0x9B,0,0,0,0,0,0,0,0};
 643     return (memcmp(ip, pchRFC6052, sizeof(pchRFC6052)) == 0);
 644 }
 645
 646 bool CNetAddr::IsRFC4380() const
 647 {
 648     return (GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0 && GetByte(12) == 0);
 649 }
 650
 651 bool CNetAddr::IsRFC4862() const
 652 {
 653     static const unsigned char pchRFC4862[] = {0xFE,0x80,0,0,0,0,0,0};
 654     return (memcmp(ip, pchRFC4862, sizeof(pchRFC4862)) == 0);
 655 }
 656
 657 bool CNetAddr::IsRFC4193() const
 658 {
 659     return ((GetByte(15) & 0xFE) == 0xFC);
 660 }
 661
 662 bool CNetAddr::IsRFC6145() const
 663 {
 664     static const unsigned char pchRFC6145[] = {0,0,0,0,0,0,0,0,0xFF,0xFF,0,0};
 665     return (memcmp(ip, pchRFC6145, sizeof(pchRFC6145)) == 0);
 666 }
 667
 668 bool CNetAddr::IsRFC4843() const
 669 {
 670     return (GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0x00 && (GetByte(12) & 0xF0) == 0x10);
 671 }
 672
 673 bool CNetAddr::IsTor() const
 674 {
 675     return (memcmp(ip, pchOnionCat, sizeof(pchOnionCat)) == 0);
 676 }
 677
 678 bool CNetAddr::IsI2P() const
 679 {
 680     return (memcmp(ip, pchGarliCat, sizeof(pchGarliCat)) == 0);
 681 }
 682
 683 bool CNetAddr::IsLocal() const
 684 {
 685     // IPv4 loopback
 686    if (IsIPv4() && (GetByte(3) == 127 || GetByte(3) == 0))
 687        return true;
 688
 689    // IPv6 loopback (::1/128)
 690    static const unsigned char pchLocal[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
 691    if (memcmp(ip, pchLocal, 16) == 0)
 692        return true;
 693
 694    return false;
 695 }
 696
 697 bool CNetAddr::IsMulticast() const
 698 {
 699     return    (IsIPv4() && (GetByte(3) & 0xF0) == 0xE0)
 700            || (GetByte(15) == 0xFF);
 701 }
 702
 703 bool CNetAddr::IsValid() const
 704 {
 705     // Clean up 3-byte shifted addresses caused by garbage in size field
 706     // of addr messages from versions before 0.2.9 checksum.
 707     // Two consecutive addr messages look like this:
 708     // header20 vectorlen3 addr26 addr26 addr26 header20 vectorlen3 addr26 addr26 addr26...
 709     // so if the first length field is garbled, it reads the second batch
 710     // of addr misaligned by 3 bytes.
 711     if (memcmp(ip, pchIPv4+3, sizeof(pchIPv4)-3) == 0)
 712         return false;
 713
 714     // unspecified IPv6 address (::/128)
 715     unsigned char ipNone[16] = {};
 716     if (memcmp(ip, ipNone, 16) == 0)
 717         return false;
 718
 719     // documentation IPv6 address
 720     if (IsRFC3849())
 721         return false;
 722
 723     if (IsIPv4())
 724     {
 725         // INADDR_NONE
 726         uint32_t ipNone = INADDR_NONE;
 727         if (memcmp(ip+12, &ipNone, 4) == 0)
 728             return false;
 729
 730         // 0
 731         ipNone = 0;
 732         if (memcmp(ip+12, &ipNone, 4) == 0)
 733             return false;
 734     }
 735
 736     return true;
 737 }
 738
 739 bool CNetAddr::IsRoutable() const
 740 {
 741     return IsValid() && !(IsRFC1918() || IsRFC3927() || IsRFC4862() || (IsRFC4193() && !IsTor() && !IsI2P()) || IsRFC4843() || IsLocal());
 742 }
 743
 744 enum Network CNetAddr::GetNetwork() const
 745 {
 746     if (!IsRoutable())
 747         return NET_UNROUTABLE;
 748
 749     if (IsIPv4())
 750         return NET_IPV4;
 751
 752     if (IsTor())
 753         return NET_TOR;
 754
 755     if (IsI2P())
 756         return NET_I2P;
 757
 758     return NET_IPV6;
 759 }
 760
 761 std::string CNetAddr::ToStringIP() const
 762 {
 763     if (IsTor())
 764         return EncodeBase32(&ip[6], 10) + ".onion";
 765     if (IsI2P())
 766         return EncodeBase32(&ip[6], 10) + ".oc.b32.i2p";
 767     CService serv(*this, 0);
 768 #ifdef USE_IPV6
 769     struct sockaddr_storage sockaddr;
 770 #else
 771     struct sockaddr sockaddr;
 772 #endif
 773     socklen_t socklen = sizeof(sockaddr);
 774     if (serv.GetSockAddr((struct sockaddr*)&sockaddr, &socklen)) {
 775         char name[1025] = "";
 776         if (!getnameinfo((const struct sockaddr*)&sockaddr, socklen, name, sizeof(name), NULL, 0, NI_NUMERICHOST))
 777             return std::string(name);
 778     }
 779     if (IsIPv4())
 780         return strprintf("%u.%u.%u.%u", GetByte(3), GetByte(2), GetByte(1), GetByte(0));
 781     else
 782         return strprintf("%x:%x:%x:%x:%x:%x:%x:%x",
 783                          GetByte(15) << 8 | GetByte(14), GetByte(13) << 8 | GetByte(12),
 784                          GetByte(11) << 8 | GetByte(10), GetByte(9) << 8 | GetByte(8),
 785                          GetByte(7) << 8 | GetByte(6), GetByte(5) << 8 | GetByte(4),
 786                          GetByte(3) << 8 | GetByte(2), GetByte(1) << 8 | GetByte(0));
 787 }
 788
 789 std::string CNetAddr::ToString() const
 790 {
 791     return ToStringIP();
 792 }
 793
 794 bool operator==(const CNetAddr& a, const CNetAddr& b)
 795 {
 796     return (memcmp(a.ip, b.ip, 16) == 0);
 797 }
 798
 799 bool operator!=(const CNetAddr& a, const CNetAddr& b)
 800 {
 801     return (memcmp(a.ip, b.ip, 16) != 0);
 802 }
 803
 804 bool operator<(const CNetAddr& a, const CNetAddr& b)
 805 {
 806     return (memcmp(a.ip, b.ip, 16) < 0);
 807 }
 808
 809 bool CNetAddr::GetInAddr(struct in_addr* pipv4Addr) const
 810 {
 811     if (!IsIPv4())
 812         return false;
 813     memcpy(pipv4Addr, ip+12, 4);
 814     return true;
 815 }
 816
 817 #ifdef USE_IPV6
 818 bool CNetAddr::GetIn6Addr(struct in6_addr* pipv6Addr) const
 819 {
 820     memcpy(pipv6Addr, ip, 16);
 821     return true;
 822 }
 823 #endif
 824
 825 // get canonical identifier of an address' group
 826 // no two connections will be attempted to addresses with the same group
 827 std::vector<unsigned char> CNetAddr::GetGroup() const
 828 {
 829     std::vector<unsigned char> vchRet;
 830     int nClass = NET_IPV6;
 831     int nStartByte = 0;
 832     int nBits = 16;
 833
 834     // all local addresses belong to the same group
 835     if (IsLocal())
 836     {
 837         nClass = 255;
 838         nBits = 0;
 839     }
 840
 841     // all unroutable addresses belong to the same group
 842     if (!IsRoutable())
 843     {
 844         nClass = NET_UNROUTABLE;
 845         nBits = 0;
 846     }
 847     // for IPv4 addresses, '1' + the 16 higher-order bits of the IP
 848     // includes mapped IPv4, SIIT translated IPv4, and the well-known prefix
 849     else if (IsIPv4() || IsRFC6145() || IsRFC6052())
 850     {
 851         nClass = NET_IPV4;
 852         nStartByte = 12;
 853     }
 854     // for 6to4 tunneled addresses, use the encapsulated IPv4 address
 855     else if (IsRFC3964())
 856     {
 857         nClass = NET_IPV4;
 858         nStartByte = 2;
 859     }
 860     // for Teredo-tunneled IPv6 addresses, use the encapsulated IPv4 address
 861     else if (IsRFC4380())
 862     {
 863         vchRet.push_back(NET_IPV4);
 864         vchRet.push_back(GetByte(3) ^ 0xFF);
 865         vchRet.push_back(GetByte(2) ^ 0xFF);
 866         return vchRet;
 867     }
 868     else if (IsTor())
 869     {
 870         nClass = NET_TOR;
 871         nStartByte = 6;
 872         nBits = 4;
 873     }
 874     else if (IsI2P())
 875     {
 876         nClass = NET_I2P;
 877         nStartByte = 6;
 878         nBits = 4;
 879     }
 880     // for he.net, use /36 groups
 881     else if (GetByte(15) == 0x20 && GetByte(14) == 0x11 && GetByte(13) == 0x04 && GetByte(12) == 0x70)
 882         nBits = 36;
 883     // for the rest of the IPv6 network, use /32 groups
 884     else
 885         nBits = 32;
 886
 887     vchRet.push_back(nClass);
 888     while (nBits >= 8)
 889     {
 890         vchRet.push_back(GetByte(15 - nStartByte));
 891         nStartByte++;
 892         nBits -= 8;
 893     }
 894     if (nBits > 0)
 895         vchRet.push_back(GetByte(15 - nStartByte) | ((1 << nBits) - 1));
 896
 897     return vchRet;
 898 }
 899
 900 uint64 CNetAddr::GetHash() const
 901 {
 902     uint256 hash = Hash(&ip[0], &ip[16]);
 903     uint64 nRet;
 904     memcpy(&nRet, &hash, sizeof(nRet));
 905     return nRet;
 906 }
 907
 908 void CNetAddr::print() const
 909 {
 910     printf("CNetAddr(%s)\n", ToString().c_str());
 911 }
 912
 913 // private extensions to enum Network, only returned by GetExtNetwork,
 914 // and only used in GetReachabilityFrom
 915 static const int NET_UNKNOWN = NET_MAX + 0;
 916 static const int NET_TEREDO  = NET_MAX + 1;
 917 int static GetExtNetwork(const CNetAddr *addr)
 918 {
 919     if (addr == NULL)
 920         return NET_UNKNOWN;
 921     if (addr->IsRFC4380())
 922         return NET_TEREDO;
 923     return addr->GetNetwork();
 924 }
 925
 926 /** Calculates a metric for how reachable (*this) is from a given partner */
 927 int CNetAddr::GetReachabilityFrom(const CNetAddr *paddrPartner) const
 928 {
 929     enum Reachability {
 930         REACH_UNREACHABLE,
 931         REACH_DEFAULT,
 932         REACH_TEREDO,
 933         REACH_IPV6_WEAK,
 934         REACH_IPV4,
 935         REACH_IPV6_STRONG,
 936         REACH_PRIVATE
 937     };
 938
 939     if (!IsRoutable())
 940         return REACH_UNREACHABLE;
 941
 942     int ourNet = GetExtNetwork(this);
 943     int theirNet = GetExtNetwork(paddrPartner);
 944     bool fTunnel = IsRFC3964() || IsRFC6052() || IsRFC6145();
 945
 946     switch(theirNet) {
 947     case NET_IPV4:
 948         switch(ourNet) {
 949         default:       return REACH_DEFAULT;
 950         case NET_IPV4: return REACH_IPV4;
 951         }
 952     case NET_IPV6:
 953         switch(ourNet) {
 954         default:         return REACH_DEFAULT;
 955         case NET_TEREDO: return REACH_TEREDO;
 956         case NET_IPV4:   return REACH_IPV4;
 957         case NET_IPV6:   return fTunnel ? REACH_IPV6_WEAK : REACH_IPV6_STRONG; // only prefer giving our IPv6 address if it's not tunneled
 958         }
 959     case NET_TOR:
 960         switch(ourNet) {
 961         default:         return REACH_DEFAULT;
 962         case NET_IPV4:   return REACH_IPV4; // Tor users can connect to IPv4 as well
 963         case NET_TOR:    return REACH_PRIVATE;
 964         }
 965     case NET_I2P:
 966         switch(ourNet) {
 967         default:         return REACH_DEFAULT;
 968         case NET_I2P:    return REACH_PRIVATE;
 969         }
 970     case NET_TEREDO:
 971         switch(ourNet) {
 972         default:          return REACH_DEFAULT;
 973         case NET_TEREDO:  return REACH_TEREDO;
 974         case NET_IPV6:    return REACH_IPV6_WEAK;
 975         case NET_IPV4:    return REACH_IPV4;
 976         }
 977     case NET_UNKNOWN:
 978     case NET_UNROUTABLE:
 979     default:
 980         switch(ourNet) {
 981         default:          return REACH_DEFAULT;
 982         case NET_TEREDO:  return REACH_TEREDO;
 983         case NET_IPV6:    return REACH_IPV6_WEAK;
 984         case NET_IPV4:    return REACH_IPV4;
 985         case NET_I2P:     return REACH_PRIVATE; // assume connections from unroutable addresses are
 986         case NET_TOR:     return REACH_PRIVATE; // either from Tor/I2P, or don't care about our address
 987         }
 988     }
 989 }
 990
 991 void CService::Init()
 992 {
 993     port = 0;
 994 }
 995
 996 CService::CService()
 997 {
 998     Init();
 999 }
1000
1001 CService::CService(const CNetAddr& cip, unsigned short portIn) : CNetAddr(cip), port(portIn)
1002 {
1003 }
1004
1005 CService::CService(const struct in_addr& ipv4Addr, unsigned short portIn) : CNetAddr(ipv4Addr), port(portIn)
1006 {
1007 }
1008
1009 #ifdef USE_IPV6
1010 CService::CService(const struct in6_addr& ipv6Addr, unsigned short portIn) : CNetAddr(ipv6Addr), port(portIn)
1011 {
1012 }
1013 #endif
1014
1015 CService::CService(const struct sockaddr_in& addr) : CNetAddr(addr.sin_addr), port(ntohs(addr.sin_port))
1016 {
1017     assert(addr.sin_family == AF_INET);
1018 }
1019
1020 #ifdef USE_IPV6
1021 CService::CService(const struct sockaddr_in6 &addr) : CNetAddr(addr.sin6_addr), port(ntohs(addr.sin6_port))
1022 {
1023    assert(addr.sin6_family == AF_INET6);
1024 }
1025 #endif
1026
1027 bool CService::SetSockAddr(const struct sockaddr *paddr)
1028 {
1029     switch (paddr->sa_family) {
1030     case AF_INET:
1031         *this = CService(*(const struct sockaddr_in*)paddr);
1032         return true;
1033 #ifdef USE_IPV6
1034     case AF_INET6:
1035         *this = CService(*(const struct sockaddr_in6*)paddr);
1036         return true;
1037 #endif
1038     default:
1039         return false;
1040     }
1041 }
1042
1043 CService::CService(const char *pszIpPort, bool fAllowLookup)
1044 {
1045     Init();
1046     CService ip;
1047     if (Lookup(pszIpPort, ip, 0, fAllowLookup))
1048         *this = ip;
1049 }
1050
1051 CService::CService(const char *pszIpPort, int portDefault, bool fAllowLookup)
1052 {
1053     Init();
1054     CService ip;
1055     if (Lookup(pszIpPort, ip, portDefault, fAllowLookup))
1056         *this = ip;
1057 }
1058
1059 CService::CService(const std::string &strIpPort, bool fAllowLookup)
1060 {
1061     Init();
1062     CService ip;
1063     if (Lookup(strIpPort.c_str(), ip, 0, fAllowLookup))
1064         *this = ip;
1065 }
1066
1067 CService::CService(const std::string &strIpPort, int portDefault, bool fAllowLookup)
1068 {
1069     Init();
1070     CService ip;
1071     if (Lookup(strIpPort.c_str(), ip, portDefault, fAllowLookup))
1072         *this = ip;
1073 }
1074
1075 unsigned short CService::GetPort() const
1076 {
1077     return port;
1078 }
1079
1080 bool operator==(const CService& a, const CService& b)
1081 {
1082     return (CNetAddr)a == (CNetAddr)b && a.port == b.port;
1083 }
1084
1085 bool operator!=(const CService& a, const CService& b)
1086 {
1087     return (CNetAddr)a != (CNetAddr)b || a.port != b.port;
1088 }
1089
1090 bool operator<(const CService& a, const CService& b)
1091 {
1092     return (CNetAddr)a < (CNetAddr)b || ((CNetAddr)a == (CNetAddr)b && a.port < b.port);
1093 }
1094
1095 bool CService::GetSockAddr(struct sockaddr* paddr, socklen_t *addrlen) const
1096 {
1097     if (IsIPv4()) {
1098         if (*addrlen < (socklen_t)sizeof(struct sockaddr_in))
1099             return false;
1100         *addrlen = sizeof(struct sockaddr_in);
1101         struct sockaddr_in *paddrin = (struct sockaddr_in*)paddr;
1102         memset(paddrin, 0, *addrlen);
1103         if (!GetInAddr(&paddrin->sin_addr))
1104             return false;
1105         paddrin->sin_family = AF_INET;
1106         paddrin->sin_port = htons(port);
1107         return true;
1108     }
1109 #ifdef USE_IPV6
1110     if (IsIPv6()) {
1111         if (*addrlen < (socklen_t)sizeof(struct sockaddr_in6))
1112             return false;
1113         *addrlen = sizeof(struct sockaddr_in6);
1114         struct sockaddr_in6 *paddrin6 = (struct sockaddr_in6*)paddr;
1115         memset(paddrin6, 0, *addrlen);
1116         if (!GetIn6Addr(&paddrin6->sin6_addr))
1117             return false;
1118         paddrin6->sin6_family = AF_INET6;
1119         paddrin6->sin6_port = htons(port);
1120         return true;
1121     }
1122 #endif
1123     return false;
1124 }
1125
1126 std::vector<unsigned char> CService::GetKey() const
1127 {
1128      std::vector<unsigned char> vKey;
1129      vKey.resize(18);
1130      memcpy(&vKey[0], ip, 16);
1131      vKey[16] = port / 0x100;
1132      vKey[17] = port & 0x0FF;
1133      return vKey;
1134 }
1135
1136 std::string CService::ToStringPort() const
1137 {
1138     return strprintf("%i", port);
1139 }
1140
1141 std::string CService::ToStringIPPort() const
1142 {
1143     if (IsIPv4() || IsTor() || IsI2P()) {
1144         return ToStringIP() + ":" + ToStringPort();
1145     } else {
1146         return "[" + ToStringIP() + "]:" + ToStringPort();
1147     }
1148 }
1149
1150 std::string CService::ToString() const
1151 {
1152     return ToStringIPPort();
1153 }
1154
1155 void CService::print() const
1156 {
1157     printf("CService(%s)\n", ToString().c_str());
1158 }
1159
1160 void CService::SetPort(unsigned short portIn)
1161 {
1162     port = portIn;
1163 }