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