src/net.cpp

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2017 The Bitcoin Core developers
   3 // Distributed under the MIT software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5
   6 #if defined(HAVE_CONFIG_H)
   7 #include <config/bitcoin-config.h>
   8 #endif
   9
  10 #include <net.h>
  11
  12 #include <chainparams.h>
  13 #include <clientversion.h>
  14 #include <consensus/consensus.h>
  15 #include <crypto/common.h>
  16 #include <crypto/sha256.h>
  17 #include <primitives/transaction.h>
  18 #include <netbase.h>
  19 #include <scheduler.h>
  20 #include <ui_interface.h>
  21 #include <utilstrencodings.h>
  22
  23 #ifdef WIN32
  24 #include <string.h>
  25 #else
  26 #include <fcntl.h>
  27 #endif
  28
  29 #ifdef USE_UPNP
  30 #include <miniupnpc/miniupnpc.h>
  31 #include <miniupnpc/miniwget.h>
  32 #include <miniupnpc/upnpcommands.h>
  33 #include <miniupnpc/upnperrors.h>
  34 #endif
  35
  36
  37 #include <math.h>
  38
  39 // Dump addresses to peers.dat and banlist.dat every 15 minutes (900s)
  40 #define DUMP_ADDRESSES_INTERVAL 900
  41
  42 // We add a random period time (0 to 1 seconds) to feeler connections to prevent synchronization.
  43 #define FEELER_SLEEP_WINDOW 1
  44
  45 #if !defined(HAVE_MSG_NOSIGNAL)
  46 #define MSG_NOSIGNAL 0
  47 #endif
  48
  49 // MSG_DONTWAIT is not available on some platforms, if it doesn't exist define it as 0
  50 #if !defined(HAVE_MSG_DONTWAIT)
  51 #define MSG_DONTWAIT 0
  52 #endif
  53
  54 // Fix for ancient MinGW versions, that don't have defined these in ws2tcpip.h.
  55 // Todo: Can be removed when our pull-tester is upgraded to a modern MinGW version.
  56 #ifdef WIN32
  57 #ifndef PROTECTION_LEVEL_UNRESTRICTED
  58 #define PROTECTION_LEVEL_UNRESTRICTED 10
  59 #endif
  60 #ifndef IPV6_PROTECTION_LEVEL
  61 #define IPV6_PROTECTION_LEVEL 23
  62 #endif
  63 #endif
  64
  65 /** Used to pass flags to the Bind() function */
  66 enum BindFlags {
  67     BF_NONE         = 0,
  68     BF_EXPLICIT     = (1U << 0),
  69     BF_REPORT_ERROR = (1U << 1),
  70     BF_WHITELIST    = (1U << 2),
  71 };
  72
  73 const static std::string NET_MESSAGE_COMMAND_OTHER = "*other*";
  74
  75 static const uint64_t RANDOMIZER_ID_NETGROUP = 0x6c0edd8036ef4036ULL; // SHA256("netgroup")[0:8]
  76 static const uint64_t RANDOMIZER_ID_LOCALHOSTNONCE = 0xd93e69e2bbfa5735ULL; // SHA256("localhostnonce")[0:8]
  77 //
  78 // Global state variables
  79 //
  80 bool fDiscover = true;
  81 bool fListen = true;
  82 bool fRelayTxes = true;
  83 CCriticalSection cs_mapLocalHost;
  84 std::map<CNetAddr, LocalServiceInfo> mapLocalHost;
  85 static bool vfLimited[NET_MAX] = {};
  86 std::string strSubVersion;
  87
  88 limitedmap<uint256, int64_t> mapAlreadyAskedFor(MAX_INV_SZ);
  89
  90 void CConnman::AddOneShot(const std::string& strDest)
  91 {
  92     LOCK(cs_vOneShots);
  93     vOneShots.push_back(strDest);
  94 }
  95
  96 unsigned short GetListenPort()
  97 {
  98     return (unsigned short)(gArgs.GetArg("-port", Params().GetDefaultPort()));
  99 }
 100
 101 // find 'best' local address for a particular peer
 102 bool GetLocal(CService& addr, const CNetAddr *paddrPeer)
 103 {
 104     if (!fListen)
 105         return false;
 106
 107     int nBestScore = -1;
 108     int nBestReachability = -1;
 109     {
 110         LOCK(cs_mapLocalHost);
 111         for (const auto& entry : mapLocalHost)
 112         {
 113             int nScore = entry.second.nScore;
 114             int nReachability = entry.first.GetReachabilityFrom(paddrPeer);
 115             if (nReachability > nBestReachability || (nReachability == nBestReachability && nScore > nBestScore))
 116             {
 117                 addr = CService(entry.first, entry.second.nPort);
 118                 nBestReachability = nReachability;
 119                 nBestScore = nScore;
 120             }
 121         }
 122     }
 123     return nBestScore >= 0;
 124 }
 125
 126 //! Convert the pnSeeds6 array into usable address objects.
 127 static std::vector<CAddress> convertSeed6(const std::vector<SeedSpec6> &vSeedsIn)
 128 {
 129     // It'll only connect to one or two seed nodes because once it connects,
 130     // it'll get a pile of addresses with newer timestamps.
 131     // Seed nodes are given a random 'last seen time' of between one and two
 132     // weeks ago.
 133     const int64_t nOneWeek = 7*24*60*60;
 134     std::vector<CAddress> vSeedsOut;
 135     vSeedsOut.reserve(vSeedsIn.size());
 136     for (const auto& seed_in : vSeedsIn) {
 137         struct in6_addr ip;
 138         memcpy(&ip, seed_in.addr, sizeof(ip));
 139         CAddress addr(CService(ip, seed_in.port), NODE_NETWORK);
 140         addr.nTime = GetTime() - GetRand(nOneWeek) - nOneWeek;
 141         vSeedsOut.push_back(addr);
 142     }
 143     return vSeedsOut;
 144 }
 145
 146 // get best local address for a particular peer as a CAddress
 147 // Otherwise, return the unroutable 0.0.0.0 but filled in with
 148 // the normal parameters, since the IP may be changed to a useful
 149 // one by discovery.
 150 CAddress GetLocalAddress(const CNetAddr *paddrPeer, ServiceFlags nLocalServices)
 151 {
 152     CAddress ret(CService(CNetAddr(),GetListenPort()), nLocalServices);
 153     CService addr;
 154     if (GetLocal(addr, paddrPeer))
 155     {
 156         ret = CAddress(addr, nLocalServices);
 157     }
 158     ret.nTime = GetAdjustedTime();
 159     return ret;
 160 }
 161
 162 int GetnScore(const CService& addr)
 163 {
 164     LOCK(cs_mapLocalHost);
 165     if (mapLocalHost.count(addr) == LOCAL_NONE)
 166         return 0;
 167     return mapLocalHost[addr].nScore;
 168 }
 169
 170 // Is our peer's addrLocal potentially useful as an external IP source?
 171 bool IsPeerAddrLocalGood(CNode *pnode)
 172 {
 173     CService addrLocal = pnode->GetAddrLocal();
 174     return fDiscover && pnode->addr.IsRoutable() && addrLocal.IsRoutable() &&
 175            !IsLimited(addrLocal.GetNetwork());
 176 }
 177
 178 // pushes our own address to a peer
 179 void AdvertiseLocal(CNode *pnode)
 180 {
 181     if (fListen && pnode->fSuccessfullyConnected)
 182     {
 183         CAddress addrLocal = GetLocalAddress(&pnode->addr, pnode->GetLocalServices());
 184         // If discovery is enabled, sometimes give our peer the address it
 185         // tells us that it sees us as in case it has a better idea of our
 186         // address than we do.
 187         if (IsPeerAddrLocalGood(pnode) && (!addrLocal.IsRoutable() ||
 188              GetRand((GetnScore(addrLocal) > LOCAL_MANUAL) ? 8:2) == 0))
 189         {
 190             addrLocal.SetIP(pnode->GetAddrLocal());
 191         }
 192         if (addrLocal.IsRoutable())
 193         {
 194             LogPrint(BCLog::NET, "AdvertiseLocal: advertising address %s\n", addrLocal.ToString());
 195             FastRandomContext insecure_rand;
 196             pnode->PushAddress(addrLocal, insecure_rand);
 197         }
 198     }
 199 }
 200
 201 // learn a new local address
 202 bool AddLocal(const CService& addr, int nScore)
 203 {
 204     if (!addr.IsRoutable())
 205         return false;
 206
 207     if (!fDiscover && nScore < LOCAL_MANUAL)
 208         return false;
 209
 210     if (IsLimited(addr))
 211         return false;
 212
 213     LogPrintf("AddLocal(%s,%i)\n", addr.ToString(), nScore);
 214
 215     {
 216         LOCK(cs_mapLocalHost);
 217         bool fAlready = mapLocalHost.count(addr) > 0;
 218         LocalServiceInfo &info = mapLocalHost[addr];
 219         if (!fAlready || nScore >= info.nScore) {
 220             info.nScore = nScore + (fAlready ? 1 : 0);
 221             info.nPort = addr.GetPort();
 222         }
 223     }
 224
 225     return true;
 226 }
 227
 228 bool AddLocal(const CNetAddr &addr, int nScore)
 229 {
 230     return AddLocal(CService(addr, GetListenPort()), nScore);
 231 }
 232
 233 bool RemoveLocal(const CService& addr)
 234 {
 235     LOCK(cs_mapLocalHost);
 236     LogPrintf("RemoveLocal(%s)\n", addr.ToString());
 237     mapLocalHost.erase(addr);
 238     return true;
 239 }
 240
 241 /** Make a particular network entirely off-limits (no automatic connects to it) */
 242 void SetLimited(enum Network net, bool fLimited)
 243 {
 244     if (net == NET_UNROUTABLE || net == NET_INTERNAL)
 245         return;
 246     LOCK(cs_mapLocalHost);
 247     vfLimited[net] = fLimited;
 248 }
 249
 250 bool IsLimited(enum Network net)
 251 {
 252     LOCK(cs_mapLocalHost);
 253     return vfLimited[net];
 254 }
 255
 256 bool IsLimited(const CNetAddr &addr)
 257 {
 258     return IsLimited(addr.GetNetwork());
 259 }
 260
 261 /** vote for a local address */
 262 bool SeenLocal(const CService& addr)
 263 {
 264     {
 265         LOCK(cs_mapLocalHost);
 266         if (mapLocalHost.count(addr) == 0)
 267             return false;
 268         mapLocalHost[addr].nScore++;
 269     }
 270     return true;
 271 }
 272
 273
 274 /** check whether a given address is potentially local */
 275 bool IsLocal(const CService& addr)
 276 {
 277     LOCK(cs_mapLocalHost);
 278     return mapLocalHost.count(addr) > 0;
 279 }
 280
 281 /** check whether a given network is one we can probably connect to */
 282 bool IsReachable(enum Network net)
 283 {
 284     LOCK(cs_mapLocalHost);
 285     return !vfLimited[net];
 286 }
 287
 288 /** check whether a given address is in a network we can probably connect to */
 289 bool IsReachable(const CNetAddr& addr)
 290 {
 291     enum Network net = addr.GetNetwork();
 292     return IsReachable(net);
 293 }
 294
 295
 296 CNode* CConnman::FindNode(const CNetAddr& ip)
 297 {
 298     LOCK(cs_vNodes);
 299     for (CNode* pnode : vNodes) {
 300         if ((CNetAddr)pnode->addr == ip) {
 301             return pnode;
 302         }
 303     }
 304     return nullptr;
 305 }
 306
 307 CNode* CConnman::FindNode(const CSubNet& subNet)
 308 {
 309     LOCK(cs_vNodes);
 310     for (CNode* pnode : vNodes) {
 311         if (subNet.Match((CNetAddr)pnode->addr)) {
 312             return pnode;
 313         }
 314     }
 315     return nullptr;
 316 }
 317
 318 CNode* CConnman::FindNode(const std::string& addrName)
 319 {
 320     LOCK(cs_vNodes);
 321     for (CNode* pnode : vNodes) {
 322         if (pnode->GetAddrName() == addrName) {
 323             return pnode;
 324         }
 325     }
 326     return nullptr;
 327 }
 328
 329 CNode* CConnman::FindNode(const CService& addr)
 330 {
 331     LOCK(cs_vNodes);
 332     for (CNode* pnode : vNodes) {
 333         if ((CService)pnode->addr == addr) {
 334             return pnode;
 335         }
 336     }
 337     return nullptr;
 338 }
 339
 340 bool CConnman::CheckIncomingNonce(uint64_t nonce)
 341 {
 342     LOCK(cs_vNodes);
 343     for (CNode* pnode : vNodes) {
 344         if (!pnode->fSuccessfullyConnected && !pnode->fInbound && pnode->GetLocalNonce() == nonce)
 345             return false;
 346     }
 347     return true;
 348 }
 349
 350 /** Get the bind address for a socket as CAddress */
 351 static CAddress GetBindAddress(SOCKET sock)
 352 {
 353     CAddress addr_bind;
 354     struct sockaddr_storage sockaddr_bind;
 355     socklen_t sockaddr_bind_len = sizeof(sockaddr_bind);
 356     if (sock != INVALID_SOCKET) {
 357         if (!getsockname(sock, (struct sockaddr*)&sockaddr_bind, &sockaddr_bind_len)) {
 358             addr_bind.SetSockAddr((const struct sockaddr*)&sockaddr_bind);
 359         } else {
 360             LogPrint(BCLog::NET, "Warning: getsockname failed\n");
 361         }
 362     }
 363     return addr_bind;
 364 }
 365
 366 CNode* CConnman::ConnectNode(CAddress addrConnect, const char *pszDest, bool fCountFailure)
 367 {
 368     if (pszDest == nullptr) {
 369         if (IsLocal(addrConnect))
 370             return nullptr;
 371
 372         // Look for an existing connection
 373         CNode* pnode = FindNode((CService)addrConnect);
 374         if (pnode)
 375         {
 376             LogPrintf("Failed to open new connection, already connected\n");
 377             return nullptr;
 378         }
 379     }
 380
 381     /// debug print
 382     LogPrint(BCLog::NET, "trying connection %s lastseen=%.1fhrs\n",
 383         pszDest ? pszDest : addrConnect.ToString(),
 384         pszDest ? 0.0 : (double)(GetAdjustedTime() - addrConnect.nTime)/3600.0);
 385
 386     // Resolve
 387     const int default_port = Params().GetDefaultPort();
 388     if (pszDest) {
 389         std::vector<CService> resolved;
 390         if (Lookup(pszDest, resolved,  default_port, fNameLookup && !HaveNameProxy(), 256) && !resolved.empty()) {
 391             addrConnect = CAddress(resolved[GetRand(resolved.size())], NODE_NONE);
 392             if (!addrConnect.IsValid()) {
 393                 LogPrint(BCLog::NET, "Resolver returned invalid address %s for %s", addrConnect.ToString(), pszDest);
 394                 return nullptr;
 395             }
 396             // It is possible that we already have a connection to the IP/port pszDest resolved to.
 397             // In that case, drop the connection that was just created, and return the existing CNode instead.
 398             // Also store the name we used to connect in that CNode, so that future FindNode() calls to that
 399             // name catch this early.
 400             LOCK(cs_vNodes);
 401             CNode* pnode = FindNode((CService)addrConnect);
 402             if (pnode)
 403             {
 404                 pnode->MaybeSetAddrName(std::string(pszDest));
 405                 LogPrintf("Failed to open new connection, already connected\n");
 406                 return nullptr;
 407             }
 408         }
 409     }
 410
 411     // Connect
 412     bool connected = false;
 413     SOCKET hSocket;
 414     proxyType proxy;
 415     if (addrConnect.IsValid()) {
 416         bool proxyConnectionFailed = false;
 417
 418         if (GetProxy(addrConnect.GetNetwork(), proxy)) {
 419             hSocket = CreateSocket(proxy.proxy);
 420             if (hSocket == INVALID_SOCKET) {
 421                 return nullptr;
 422             }
 423             connected = ConnectThroughProxy(proxy, addrConnect.ToStringIP(), addrConnect.GetPort(), hSocket, nConnectTimeout, &proxyConnectionFailed);
 424         } else {
 425             // no proxy needed (none set for target network)
 426             hSocket = CreateSocket(addrConnect);
 427             if (hSocket == INVALID_SOCKET) {
 428                 return nullptr;
 429             }
 430             connected = ConnectSocketDirectly(addrConnect, hSocket, nConnectTimeout);
 431         }
 432         if (!proxyConnectionFailed) {
 433             // If a connection to the node was attempted, and failure (if any) is not caused by a problem connecting to
 434             // the proxy, mark this as an attempt.
 435             addrman.Attempt(addrConnect, fCountFailure);
 436         }
 437     } else if (pszDest && GetNameProxy(proxy)) {
 438         hSocket = CreateSocket(proxy.proxy);
 439         if (hSocket == INVALID_SOCKET) {
 440             return nullptr;
 441         }
 442         std::string host;
 443         int port = default_port;
 444         SplitHostPort(std::string(pszDest), port, host);
 445         connected = ConnectThroughProxy(proxy, host, port, hSocket, nConnectTimeout, nullptr);
 446     }
 447     if (!connected) {
 448         CloseSocket(hSocket);
 449         return nullptr;
 450     }
 451
 452     // Add node
 453     NodeId id = GetNewNodeId();
 454     uint64_t nonce = GetDeterministicRandomizer(RANDOMIZER_ID_LOCALHOSTNONCE).Write(id).Finalize();
 455     CAddress addr_bind = GetBindAddress(hSocket);
 456     CNode* pnode = new CNode(id, nLocalServices, GetBestHeight(), hSocket, addrConnect, CalculateKeyedNetGroup(addrConnect), nonce, addr_bind, pszDest ? pszDest : "", false);
 457     pnode->AddRef();
 458
 459     return pnode;
 460 }
 461
 462 void CConnman::DumpBanlist()
 463 {
 464     SweepBanned(); // clean unused entries (if bantime has expired)
 465
 466     if (!BannedSetIsDirty())
 467         return;
 468
 469     int64_t nStart = GetTimeMillis();
 470
 471     CBanDB bandb;
 472     banmap_t banmap;
 473     GetBanned(banmap);
 474     if (bandb.Write(banmap)) {
 475         SetBannedSetDirty(false);
 476     }
 477
 478     LogPrint(BCLog::NET, "Flushed %d banned node ips/subnets to banlist.dat  %dms\n",
 479         banmap.size(), GetTimeMillis() - nStart);
 480 }
 481
 482 void CNode::CloseSocketDisconnect()
 483 {
 484     fDisconnect = true;
 485     LOCK(cs_hSocket);
 486     if (hSocket != INVALID_SOCKET)
 487     {
 488         LogPrint(BCLog::NET, "disconnecting peer=%d\n", id);
 489         CloseSocket(hSocket);
 490     }
 491 }
 492
 493 void CConnman::ClearBanned()
 494 {
 495     {
 496         LOCK(cs_setBanned);
 497         setBanned.clear();
 498         setBannedIsDirty = true;
 499     }
 500     DumpBanlist(); //store banlist to disk
 501     if(clientInterface)
 502         clientInterface->BannedListChanged();
 503 }
 504
 505 bool CConnman::IsBanned(CNetAddr ip)
 506 {
 507     LOCK(cs_setBanned);
 508     for (const auto& it : setBanned) {
 509         CSubNet subNet = it.first;
 510         CBanEntry banEntry = it.second;
 511
 512         if (subNet.Match(ip) && GetTime() < banEntry.nBanUntil) {
 513             return true;
 514         }
 515     }
 516     return false;
 517 }
 518
 519 bool CConnman::IsBanned(CSubNet subnet)
 520 {
 521     LOCK(cs_setBanned);
 522     banmap_t::iterator i = setBanned.find(subnet);
 523     if (i != setBanned.end())
 524     {
 525         CBanEntry banEntry = (*i).second;
 526         if (GetTime() < banEntry.nBanUntil) {
 527             return true;
 528         }
 529     }
 530     return false;
 531 }
 532
 533 void CConnman::Ban(const CNetAddr& addr, const BanReason &banReason, int64_t bantimeoffset, bool sinceUnixEpoch) {
 534     CSubNet subNet(addr);
 535     Ban(subNet, banReason, bantimeoffset, sinceUnixEpoch);
 536 }
 537
 538 void CConnman::Ban(const CSubNet& subNet, const BanReason &banReason, int64_t bantimeoffset, bool sinceUnixEpoch) {
 539     CBanEntry banEntry(GetTime());
 540     banEntry.banReason = banReason;
 541     if (bantimeoffset <= 0)
 542     {
 543         bantimeoffset = gArgs.GetArg("-bantime", DEFAULT_MISBEHAVING_BANTIME);
 544         sinceUnixEpoch = false;
 545     }
 546     banEntry.nBanUntil = (sinceUnixEpoch ? 0 : GetTime() )+bantimeoffset;
 547
 548     {
 549         LOCK(cs_setBanned);
 550         if (setBanned[subNet].nBanUntil < banEntry.nBanUntil) {
 551             setBanned[subNet] = banEntry;
 552             setBannedIsDirty = true;
 553         }
 554         else
 555             return;
 556     }
 557     if(clientInterface)
 558         clientInterface->BannedListChanged();
 559     {
 560         LOCK(cs_vNodes);
 561         for (CNode* pnode : vNodes) {
 562             if (subNet.Match((CNetAddr)pnode->addr))
 563                 pnode->fDisconnect = true;
 564         }
 565     }
 566     if(banReason == BanReasonManuallyAdded)
 567         DumpBanlist(); //store banlist to disk immediately if user requested ban
 568 }
 569
 570 bool CConnman::Unban(const CNetAddr &addr) {
 571     CSubNet subNet(addr);
 572     return Unban(subNet);
 573 }
 574
 575 bool CConnman::Unban(const CSubNet &subNet) {
 576     {
 577         LOCK(cs_setBanned);
 578         if (!setBanned.erase(subNet))
 579             return false;
 580         setBannedIsDirty = true;
 581     }
 582     if(clientInterface)
 583         clientInterface->BannedListChanged();
 584     DumpBanlist(); //store banlist to disk immediately
 585     return true;
 586 }
 587
 588 void CConnman::GetBanned(banmap_t &banMap)
 589 {
 590     LOCK(cs_setBanned);
 591     // Sweep the banlist so expired bans are not returned
 592     SweepBanned();
 593     banMap = setBanned; //create a thread safe copy
 594 }
 595
 596 void CConnman::SetBanned(const banmap_t &banMap)
 597 {
 598     LOCK(cs_setBanned);
 599     setBanned = banMap;
 600     setBannedIsDirty = true;
 601 }
 602
 603 void CConnman::SweepBanned()
 604 {
 605     int64_t now = GetTime();
 606     bool notifyUI = false;
 607     {
 608         LOCK(cs_setBanned);
 609         banmap_t::iterator it = setBanned.begin();
 610         while(it != setBanned.end())
 611         {
 612             CSubNet subNet = (*it).first;
 613             CBanEntry banEntry = (*it).second;
 614             if(now > banEntry.nBanUntil)
 615             {
 616                 setBanned.erase(it++);
 617                 setBannedIsDirty = true;
 618                 notifyUI = true;
 619                 LogPrint(BCLog::NET, "%s: Removed banned node ip/subnet from banlist.dat: %s\n", __func__, subNet.ToString());
 620             }
 621             else
 622                 ++it;
 623         }
 624     }
 625     // update UI
 626     if(notifyUI && clientInterface) {
 627         clientInterface->BannedListChanged();
 628     }
 629 }
 630
 631 bool CConnman::BannedSetIsDirty()
 632 {
 633     LOCK(cs_setBanned);
 634     return setBannedIsDirty;
 635 }
 636
 637 void CConnman::SetBannedSetDirty(bool dirty)
 638 {
 639     LOCK(cs_setBanned); //reuse setBanned lock for the isDirty flag
 640     setBannedIsDirty = dirty;
 641 }
 642
 643
 644 bool CConnman::IsWhitelistedRange(const CNetAddr &addr) {
 645     for (const CSubNet& subnet : vWhitelistedRange) {
 646         if (subnet.Match(addr))
 647             return true;
 648     }
 649     return false;
 650 }
 651
 652 std::string CNode::GetAddrName() const {
 653     LOCK(cs_addrName);
 654     return addrName;
 655 }
 656
 657 void CNode::MaybeSetAddrName(const std::string& addrNameIn) {
 658     LOCK(cs_addrName);
 659     if (addrName.empty()) {
 660         addrName = addrNameIn;
 661     }
 662 }
 663
 664 CService CNode::GetAddrLocal() const {
 665     LOCK(cs_addrLocal);
 666     return addrLocal;
 667 }
 668
 669 void CNode::SetAddrLocal(const CService& addrLocalIn) {
 670     LOCK(cs_addrLocal);
 671     if (addrLocal.IsValid()) {
 672         error("Addr local already set for node: %i. Refusing to change from %s to %s", id, addrLocal.ToString(), addrLocalIn.ToString());
 673     } else {
 674         addrLocal = addrLocalIn;
 675     }
 676 }
 677
 678 #undef X
 679 #define X(name) stats.name = name
 680 void CNode::copyStats(CNodeStats &stats)
 681 {
 682     stats.nodeid = this->GetId();
 683     X(nServices);
 684     X(addr);
 685     X(addrBind);
 686     {
 687         LOCK(cs_filter);
 688         X(fRelayTxes);
 689     }
 690     X(nLastSend);
 691     X(nLastRecv);
 692     X(nTimeConnected);
 693     X(nTimeOffset);
 694     stats.addrName = GetAddrName();
 695     X(nVersion);
 696     {
 697         LOCK(cs_SubVer);
 698         X(cleanSubVer);
 699     }
 700     X(fInbound);
 701     X(m_manual_connection);
 702     X(nStartingHeight);
 703     {
 704         LOCK(cs_vSend);
 705         X(mapSendBytesPerMsgCmd);
 706         X(nSendBytes);
 707     }
 708     {
 709         LOCK(cs_vRecv);
 710         X(mapRecvBytesPerMsgCmd);
 711         X(nRecvBytes);
 712     }
 713     X(fWhitelisted);
 714
 715     // It is common for nodes with good ping times to suddenly become lagged,
 716     // due to a new block arriving or other large transfer.
 717     // Merely reporting pingtime might fool the caller into thinking the node was still responsive,
 718     // since pingtime does not update until the ping is complete, which might take a while.
 719     // So, if a ping is taking an unusually long time in flight,
 720     // the caller can immediately detect that this is happening.
 721     int64_t nPingUsecWait = 0;
 722     if ((0 != nPingNonceSent) && (0 != nPingUsecStart)) {
 723         nPingUsecWait = GetTimeMicros() - nPingUsecStart;
 724     }
 725
 726     // Raw ping time is in microseconds, but show it to user as whole seconds (Bitcoin users should be well used to small numbers with many decimal places by now :)
 727     stats.dPingTime = (((double)nPingUsecTime) / 1e6);
 728     stats.dMinPing  = (((double)nMinPingUsecTime) / 1e6);
 729     stats.dPingWait = (((double)nPingUsecWait) / 1e6);
 730
 731     // Leave string empty if addrLocal invalid (not filled in yet)
 732     CService addrLocalUnlocked = GetAddrLocal();
 733     stats.addrLocal = addrLocalUnlocked.IsValid() ? addrLocalUnlocked.ToString() : "";
 734 }
 735 #undef X
 736
 737 bool CNode::ReceiveMsgBytes(const char *pch, unsigned int nBytes, bool& complete)
 738 {
 739     complete = false;
 740     int64_t nTimeMicros = GetTimeMicros();
 741     LOCK(cs_vRecv);
 742     nLastRecv = nTimeMicros / 1000000;
 743     nRecvBytes += nBytes;
 744     while (nBytes > 0) {
 745
 746         // get current incomplete message, or create a new one
 747         if (vRecvMsg.empty() ||
 748             vRecvMsg.back().complete())
 749             vRecvMsg.push_back(CNetMessage(Params().MessageStart(), SER_NETWORK, INIT_PROTO_VERSION));
 750
 751         CNetMessage& msg = vRecvMsg.back();
 752
 753         // absorb network data
 754         int handled;
 755         if (!msg.in_data)
 756             handled = msg.readHeader(pch, nBytes);
 757         else
 758             handled = msg.readData(pch, nBytes);
 759
 760         if (handled < 0)
 761             return false;
 762
 763         if (msg.in_data && msg.hdr.nMessageSize > MAX_PROTOCOL_MESSAGE_LENGTH) {
 764             LogPrint(BCLog::NET, "Oversized message from peer=%i, disconnecting\n", GetId());
 765             return false;
 766         }
 767
 768         pch += handled;
 769         nBytes -= handled;
 770
 771         if (msg.complete()) {
 772
 773             //store received bytes per message command
 774             //to prevent a memory DOS, only allow valid commands
 775             mapMsgCmdSize::iterator i = mapRecvBytesPerMsgCmd.find(msg.hdr.pchCommand);
 776             if (i == mapRecvBytesPerMsgCmd.end())
 777                 i = mapRecvBytesPerMsgCmd.find(NET_MESSAGE_COMMAND_OTHER);
 778             assert(i != mapRecvBytesPerMsgCmd.end());
 779             i->second += msg.hdr.nMessageSize + CMessageHeader::HEADER_SIZE;
 780
 781             msg.nTime = nTimeMicros;
 782             complete = true;
 783         }
 784     }
 785
 786     return true;
 787 }
 788
 789 void CNode::SetSendVersion(int nVersionIn)
 790 {
 791     // Send version may only be changed in the version message, and
 792     // only one version message is allowed per session. We can therefore
 793     // treat this value as const and even atomic as long as it's only used
 794     // once a version message has been successfully processed. Any attempt to
 795     // set this twice is an error.
 796     if (nSendVersion != 0) {
 797         error("Send version already set for node: %i. Refusing to change from %i to %i", id, nSendVersion, nVersionIn);
 798     } else {
 799         nSendVersion = nVersionIn;
 800     }
 801 }
 802
 803 int CNode::GetSendVersion() const
 804 {
 805     // The send version should always be explicitly set to
 806     // INIT_PROTO_VERSION rather than using this value until SetSendVersion
 807     // has been called.
 808     if (nSendVersion == 0) {
 809         error("Requesting unset send version for node: %i. Using %i", id, INIT_PROTO_VERSION);
 810         return INIT_PROTO_VERSION;
 811     }
 812     return nSendVersion;
 813 }
 814
 815
 816 int CNetMessage::readHeader(const char *pch, unsigned int nBytes)
 817 {
 818     // copy data to temporary parsing buffer
 819     unsigned int nRemaining = 24 - nHdrPos;
 820     unsigned int nCopy = std::min(nRemaining, nBytes);
 821
 822     memcpy(&hdrbuf[nHdrPos], pch, nCopy);
 823     nHdrPos += nCopy;
 824
 825     // if header incomplete, exit
 826     if (nHdrPos < 24)
 827         return nCopy;
 828
 829     // deserialize to CMessageHeader
 830     try {
 831         hdrbuf >> hdr;
 832     }
 833     catch (const std::exception&) {
 834         return -1;
 835     }
 836
 837     // reject messages larger than MAX_SIZE
 838     if (hdr.nMessageSize > MAX_SIZE)
 839         return -1;
 840
 841     // switch state to reading message data
 842     in_data = true;
 843
 844     return nCopy;
 845 }
 846
 847 int CNetMessage::readData(const char *pch, unsigned int nBytes)
 848 {
 849     unsigned int nRemaining = hdr.nMessageSize - nDataPos;
 850     unsigned int nCopy = std::min(nRemaining, nBytes);
 851
 852     if (vRecv.size() < nDataPos + nCopy) {
 853         // Allocate up to 256 KiB ahead, but never more than the total message size.
 854         vRecv.resize(std::min(hdr.nMessageSize, nDataPos + nCopy + 256 * 1024));
 855     }
 856
 857     hasher.Write((const unsigned char*)pch, nCopy);
 858     memcpy(&vRecv[nDataPos], pch, nCopy);
 859     nDataPos += nCopy;
 860
 861     return nCopy;
 862 }
 863
 864 const uint256& CNetMessage::GetMessageHash() const
 865 {
 866     assert(complete());
 867     if (data_hash.IsNull())
 868         hasher.Finalize(data_hash.begin());
 869     return data_hash;
 870 }
 871
 872
 873
 874
 875
 876
 877
 878
 879
 880 // requires LOCK(cs_vSend)
 881 size_t CConnman::SocketSendData(CNode *pnode) const
 882 {
 883     auto it = pnode->vSendMsg.begin();
 884     size_t nSentSize = 0;
 885
 886     while (it != pnode->vSendMsg.end()) {
 887         const auto &data = *it;
 888         assert(data.size() > pnode->nSendOffset);
 889         int nBytes = 0;
 890         {
 891             LOCK(pnode->cs_hSocket);
 892             if (pnode->hSocket == INVALID_SOCKET)
 893                 break;
 894             nBytes = send(pnode->hSocket, reinterpret_cast<const char*>(data.data()) + pnode->nSendOffset, data.size() - pnode->nSendOffset, MSG_NOSIGNAL | MSG_DONTWAIT);
 895         }
 896         if (nBytes > 0) {
 897             pnode->nLastSend = GetSystemTimeInSeconds();
 898             pnode->nSendBytes += nBytes;
 899             pnode->nSendOffset += nBytes;
 900             nSentSize += nBytes;
 901             if (pnode->nSendOffset == data.size()) {
 902                 pnode->nSendOffset = 0;
 903                 pnode->nSendSize -= data.size();
 904                 pnode->fPauseSend = pnode->nSendSize > nSendBufferMaxSize;
 905                 it++;
 906             } else {
 907                 // could not send full message; stop sending more
 908                 break;
 909             }
 910         } else {
 911             if (nBytes < 0) {
 912                 // error
 913                 int nErr = WSAGetLastError();
 914                 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
 915                 {
 916                     LogPrintf("socket send error %s\n", NetworkErrorString(nErr));
 917                     pnode->CloseSocketDisconnect();
 918                 }
 919             }
 920             // couldn't send anything at all
 921             break;
 922         }
 923     }
 924
 925     if (it == pnode->vSendMsg.end()) {
 926         assert(pnode->nSendOffset == 0);
 927         assert(pnode->nSendSize == 0);
 928     }
 929     pnode->vSendMsg.erase(pnode->vSendMsg.begin(), it);
 930     return nSentSize;
 931 }
 932
 933 struct NodeEvictionCandidate
 934 {
 935     NodeId id;
 936     int64_t nTimeConnected;
 937     int64_t nMinPingUsecTime;
 938     int64_t nLastBlockTime;
 939     int64_t nLastTXTime;
 940     bool fRelevantServices;
 941     bool fRelayTxes;
 942     bool fBloomFilter;
 943     CAddress addr;
 944     uint64_t nKeyedNetGroup;
 945 };
 946
 947 static bool ReverseCompareNodeMinPingTime(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b)
 948 {
 949     return a.nMinPingUsecTime > b.nMinPingUsecTime;
 950 }
 951
 952 static bool ReverseCompareNodeTimeConnected(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b)
 953 {
 954     return a.nTimeConnected > b.nTimeConnected;
 955 }
 956
 957 static bool CompareNetGroupKeyed(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b) {
 958     return a.nKeyedNetGroup < b.nKeyedNetGroup;
 959 }
 960
 961 static bool CompareNodeBlockTime(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b)
 962 {
 963     // There is a fall-through here because it is common for a node to have many peers which have not yet relayed a block.
 964     if (a.nLastBlockTime != b.nLastBlockTime) return a.nLastBlockTime < b.nLastBlockTime;
 965     if (a.fRelevantServices != b.fRelevantServices) return b.fRelevantServices;
 966     return a.nTimeConnected > b.nTimeConnected;
 967 }
 968
 969 static bool CompareNodeTXTime(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b)
 970 {
 971     // There is a fall-through here because it is common for a node to have more than a few peers that have not yet relayed txn.
 972     if (a.nLastTXTime != b.nLastTXTime) return a.nLastTXTime < b.nLastTXTime;
 973     if (a.fRelayTxes != b.fRelayTxes) return b.fRelayTxes;
 974     if (a.fBloomFilter != b.fBloomFilter) return a.fBloomFilter;
 975     return a.nTimeConnected > b.nTimeConnected;
 976 }
 977
 978
 979 //! Sort an array by the specified comparator, then erase the last K elements.
 980 template<typename T, typename Comparator>
 981 static void EraseLastKElements(std::vector<T> &elements, Comparator comparator, size_t k)
 982 {
 983     std::sort(elements.begin(), elements.end(), comparator);
 984     size_t eraseSize = std::min(k, elements.size());
 985     elements.erase(elements.end() - eraseSize, elements.end());
 986 }
 987
 988 /** Try to find a connection to evict when the node is full.
 989  *  Extreme care must be taken to avoid opening the node to attacker
 990  *   triggered network partitioning.
 991  *  The strategy used here is to protect a small number of peers
 992  *   for each of several distinct characteristics which are difficult
 993  *   to forge.  In order to partition a node the attacker must be
 994  *   simultaneously better at all of them than honest peers.
 995  */
 996 bool CConnman::AttemptToEvictConnection()
 997 {
 998     std::vector<NodeEvictionCandidate> vEvictionCandidates;
 999     {
1000         LOCK(cs_vNodes);
1001
1002         for (const CNode* node : vNodes) {
1003             if (node->fWhitelisted)
1004                 continue;
1005             if (!node->fInbound)
1006                 continue;
1007             if (node->fDisconnect)
1008                 continue;
1009             NodeEvictionCandidate candidate = {node->GetId(), node->nTimeConnected, node->nMinPingUsecTime,
1010                                                node->nLastBlockTime, node->nLastTXTime,
1011                                                HasAllDesirableServiceFlags(node->nServices),
1012                                                node->fRelayTxes, node->pfilter != nullptr, node->addr, node->nKeyedNetGroup};
1013             vEvictionCandidates.push_back(candidate);
1014         }
1015     }
1016
1017     // Protect connections with certain characteristics
1018
1019     // Deterministically select 4 peers to protect by netgroup.
1020     // An attacker cannot predict which netgroups will be protected
1021     EraseLastKElements(vEvictionCandidates, CompareNetGroupKeyed, 4);
1022     // Protect the 8 nodes with the lowest minimum ping time.
1023     // An attacker cannot manipulate this metric without physically moving nodes closer to the target.
1024     EraseLastKElements(vEvictionCandidates, ReverseCompareNodeMinPingTime, 8);
1025     // Protect 4 nodes that most recently sent us transactions.
1026     // An attacker cannot manipulate this metric without performing useful work.
1027     EraseLastKElements(vEvictionCandidates, CompareNodeTXTime, 4);
1028     // Protect 4 nodes that most recently sent us blocks.
1029     // An attacker cannot manipulate this metric without performing useful work.
1030     EraseLastKElements(vEvictionCandidates, CompareNodeBlockTime, 4);
1031     // Protect the half of the remaining nodes which have been connected the longest.
1032     // This replicates the non-eviction implicit behavior, and precludes attacks that start later.
1033     EraseLastKElements(vEvictionCandidates, ReverseCompareNodeTimeConnected, vEvictionCandidates.size() / 2);
1034
1035     if (vEvictionCandidates.empty()) return false;
1036
1037     // Identify the network group with the most connections and youngest member.
1038     // (vEvictionCandidates is already sorted by reverse connect time)
1039     uint64_t naMostConnections;
1040     unsigned int nMostConnections = 0;
1041     int64_t nMostConnectionsTime = 0;
1042     std::map<uint64_t, std::vector<NodeEvictionCandidate> > mapNetGroupNodes;
1043     for (const NodeEvictionCandidate &node : vEvictionCandidates) {
1044         std::vector<NodeEvictionCandidate> &group = mapNetGroupNodes[node.nKeyedNetGroup];
1045         group.push_back(node);
1046         int64_t grouptime = group[0].nTimeConnected;
1047
1048         if (group.size() > nMostConnections || (group.size() == nMostConnections && grouptime > nMostConnectionsTime)) {
1049             nMostConnections = group.size();
1050             nMostConnectionsTime = grouptime;
1051             naMostConnections = node.nKeyedNetGroup;
1052         }
1053     }
1054
1055     // Reduce to the network group with the most connections
1056     vEvictionCandidates = std::move(mapNetGroupNodes[naMostConnections]);
1057
1058     // Disconnect from the network group with the most connections
1059     NodeId evicted = vEvictionCandidates.front().id;
1060     LOCK(cs_vNodes);
1061     for (CNode* pnode : vNodes) {
1062         if (pnode->GetId() == evicted) {
1063             pnode->fDisconnect = true;
1064             return true;
1065         }
1066     }
1067     return false;
1068 }
1069
1070 void CConnman::AcceptConnection(const ListenSocket& hListenSocket) {
1071     struct sockaddr_storage sockaddr;
1072     socklen_t len = sizeof(sockaddr);
1073     SOCKET hSocket = accept(hListenSocket.socket, (struct sockaddr*)&sockaddr, &len);
1074     CAddress addr;
1075     int nInbound = 0;
1076     int nMaxInbound = nMaxConnections - (nMaxOutbound + nMaxFeeler);
1077
1078     if (hSocket != INVALID_SOCKET) {
1079         if (!addr.SetSockAddr((const struct sockaddr*)&sockaddr)) {
1080             LogPrintf("Warning: Unknown socket family\n");
1081         }
1082     }
1083
1084     bool whitelisted = hListenSocket.whitelisted || IsWhitelistedRange(addr);
1085     {
1086         LOCK(cs_vNodes);
1087         for (const CNode* pnode : vNodes) {
1088             if (pnode->fInbound) nInbound++;
1089         }
1090     }
1091
1092     if (hSocket == INVALID_SOCKET)
1093     {
1094         int nErr = WSAGetLastError();
1095         if (nErr != WSAEWOULDBLOCK)
1096             LogPrintf("socket error accept failed: %s\n", NetworkErrorString(nErr));
1097         return;
1098     }
1099
1100     if (!fNetworkActive) {
1101         LogPrintf("connection from %s dropped: not accepting new connections\n", addr.ToString());
1102         CloseSocket(hSocket);
1103         return;
1104     }
1105
1106     if (!IsSelectableSocket(hSocket))
1107     {
1108         LogPrintf("connection from %s dropped: non-selectable socket\n", addr.ToString());
1109         CloseSocket(hSocket);
1110         return;
1111     }
1112
1113     // According to the internet TCP_NODELAY is not carried into accepted sockets
1114     // on all platforms.  Set it again here just to be sure.
1115     SetSocketNoDelay(hSocket);
1116
1117     if (IsBanned(addr) && !whitelisted)
1118     {
1119         LogPrint(BCLog::NET, "connection from %s dropped (banned)\n", addr.ToString());
1120         CloseSocket(hSocket);
1121         return;
1122     }
1123
1124     if (nInbound >= nMaxInbound)
1125     {
1126         if (!AttemptToEvictConnection()) {
1127             // No connection to evict, disconnect the new connection
1128             LogPrint(BCLog::NET, "failed to find an eviction candidate - connection dropped (full)\n");
1129             CloseSocket(hSocket);
1130             return;
1131         }
1132     }
1133
1134     NodeId id = GetNewNodeId();
1135     uint64_t nonce = GetDeterministicRandomizer(RANDOMIZER_ID_LOCALHOSTNONCE).Write(id).Finalize();
1136     CAddress addr_bind = GetBindAddress(hSocket);
1137
1138     CNode* pnode = new CNode(id, nLocalServices, GetBestHeight(), hSocket, addr, CalculateKeyedNetGroup(addr), nonce, addr_bind, "", true);
1139     pnode->AddRef();
1140     pnode->fWhitelisted = whitelisted;
1141     m_msgproc->InitializeNode(pnode);
1142
1143     LogPrint(BCLog::NET, "connection from %s accepted\n", addr.ToString());
1144
1145     {
1146         LOCK(cs_vNodes);
1147         vNodes.push_back(pnode);
1148     }
1149 }
1150
1151 void CConnman::ThreadSocketHandler()
1152 {
1153     unsigned int nPrevNodeCount = 0;
1154     while (!interruptNet)
1155     {
1156         //
1157         // Disconnect nodes
1158         //
1159         {
1160             LOCK(cs_vNodes);
1161             // Disconnect unused nodes
1162             std::vector<CNode*> vNodesCopy = vNodes;
1163             for (CNode* pnode : vNodesCopy)
1164             {
1165                 if (pnode->fDisconnect)
1166                 {
1167                     // remove from vNodes
1168                     vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end());
1169
1170                     // release outbound grant (if any)
1171                     pnode->grantOutbound.Release();
1172
1173                     // close socket and cleanup
1174                     pnode->CloseSocketDisconnect();
1175
1176                     // hold in disconnected pool until all refs are released
1177                     pnode->Release();
1178                     vNodesDisconnected.push_back(pnode);
1179                 }
1180             }
1181         }
1182         {
1183             // Delete disconnected nodes
1184             std::list<CNode*> vNodesDisconnectedCopy = vNodesDisconnected;
1185             for (CNode* pnode : vNodesDisconnectedCopy)
1186             {
1187                 // wait until threads are done using it
1188                 if (pnode->GetRefCount() <= 0) {
1189                     bool fDelete = false;
1190                     {
1191                         TRY_LOCK(pnode->cs_inventory, lockInv);
1192                         if (lockInv) {
1193                             TRY_LOCK(pnode->cs_vSend, lockSend);
1194                             if (lockSend) {
1195                                 fDelete = true;
1196                             }
1197                         }
1198                     }
1199                     if (fDelete) {
1200                         vNodesDisconnected.remove(pnode);
1201                         DeleteNode(pnode);
1202                     }
1203                 }
1204             }
1205         }
1206         size_t vNodesSize;
1207         {
1208             LOCK(cs_vNodes);
1209             vNodesSize = vNodes.size();
1210         }
1211         if(vNodesSize != nPrevNodeCount) {
1212             nPrevNodeCount = vNodesSize;
1213             if(clientInterface)
1214                 clientInterface->NotifyNumConnectionsChanged(nPrevNodeCount);
1215         }
1216
1217         //
1218         // Find which sockets have data to receive
1219         //
1220         struct timeval timeout;
1221         timeout.tv_sec  = 0;
1222         timeout.tv_usec = 50000; // frequency to poll pnode->vSend
1223
1224         fd_set fdsetRecv;
1225         fd_set fdsetSend;
1226         fd_set fdsetError;
1227         FD_ZERO(&fdsetRecv);
1228         FD_ZERO(&fdsetSend);
1229         FD_ZERO(&fdsetError);
1230         SOCKET hSocketMax = 0;
1231         bool have_fds = false;
1232
1233         for (const ListenSocket& hListenSocket : vhListenSocket) {
1234             FD_SET(hListenSocket.socket, &fdsetRecv);
1235             hSocketMax = std::max(hSocketMax, hListenSocket.socket);
1236             have_fds = true;
1237         }
1238
1239         {
1240             LOCK(cs_vNodes);
1241             for (CNode* pnode : vNodes)
1242             {
1243                 // Implement the following logic:
1244                 // * If there is data to send, select() for sending data. As this only
1245                 //   happens when optimistic write failed, we choose to first drain the
1246                 //   write buffer in this case before receiving more. This avoids
1247                 //   needlessly queueing received data, if the remote peer is not themselves
1248                 //   receiving data. This means properly utilizing TCP flow control signalling.
1249                 // * Otherwise, if there is space left in the receive buffer, select() for
1250                 //   receiving data.
1251                 // * Hand off all complete messages to the processor, to be handled without
1252                 //   blocking here.
1253
1254                 bool select_recv = !pnode->fPauseRecv;
1255                 bool select_send;
1256                 {
1257                     LOCK(pnode->cs_vSend);
1258                     select_send = !pnode->vSendMsg.empty();
1259                 }
1260
1261                 LOCK(pnode->cs_hSocket);
1262                 if (pnode->hSocket == INVALID_SOCKET)
1263                     continue;
1264
1265                 FD_SET(pnode->hSocket, &fdsetError);
1266                 hSocketMax = std::max(hSocketMax, pnode->hSocket);
1267                 have_fds = true;
1268
1269                 if (select_send) {
1270                     FD_SET(pnode->hSocket, &fdsetSend);
1271                     continue;
1272                 }
1273                 if (select_recv) {
1274                     FD_SET(pnode->hSocket, &fdsetRecv);
1275                 }
1276             }
1277         }
1278
1279         int nSelect = select(have_fds ? hSocketMax + 1 : 0,
1280                              &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
1281         if (interruptNet)
1282             return;
1283
1284         if (nSelect == SOCKET_ERROR)
1285         {
1286             if (have_fds)
1287             {
1288                 int nErr = WSAGetLastError();
1289                 LogPrintf("socket select error %s\n", NetworkErrorString(nErr));
1290                 for (unsigned int i = 0; i <= hSocketMax; i++)
1291                     FD_SET(i, &fdsetRecv);
1292             }
1293             FD_ZERO(&fdsetSend);
1294             FD_ZERO(&fdsetError);
1295             if (!interruptNet.sleep_for(std::chrono::milliseconds(timeout.tv_usec/1000)))
1296                 return;
1297         }
1298
1299         //
1300         // Accept new connections
1301         //
1302         for (const ListenSocket& hListenSocket : vhListenSocket)
1303         {
1304             if (hListenSocket.socket != INVALID_SOCKET && FD_ISSET(hListenSocket.socket, &fdsetRecv))
1305             {
1306                 AcceptConnection(hListenSocket);
1307             }
1308         }
1309
1310         //
1311         // Service each socket
1312         //
1313         std::vector<CNode*> vNodesCopy;
1314         {
1315             LOCK(cs_vNodes);
1316             vNodesCopy = vNodes;
1317             for (CNode* pnode : vNodesCopy)
1318                 pnode->AddRef();
1319         }
1320         for (CNode* pnode : vNodesCopy)
1321         {
1322             if (interruptNet)
1323                 return;
1324
1325             //
1326             // Receive
1327             //
1328             bool recvSet = false;
1329             bool sendSet = false;
1330             bool errorSet = false;
1331             {
1332                 LOCK(pnode->cs_hSocket);
1333                 if (pnode->hSocket == INVALID_SOCKET)
1334                     continue;
1335                 recvSet = FD_ISSET(pnode->hSocket, &fdsetRecv);
1336                 sendSet = FD_ISSET(pnode->hSocket, &fdsetSend);
1337                 errorSet = FD_ISSET(pnode->hSocket, &fdsetError);
1338             }
1339             if (recvSet || errorSet)
1340             {
1341                 // typical socket buffer is 8K-64K
1342                 char pchBuf[0x10000];
1343                 int nBytes = 0;
1344                 {
1345                     LOCK(pnode->cs_hSocket);
1346                     if (pnode->hSocket == INVALID_SOCKET)
1347                         continue;
1348                     nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
1349                 }
1350                 if (nBytes > 0)
1351                 {
1352                     bool notify = false;
1353                     if (!pnode->ReceiveMsgBytes(pchBuf, nBytes, notify))
1354                         pnode->CloseSocketDisconnect();
1355                     RecordBytesRecv(nBytes);
1356                     if (notify) {
1357                         size_t nSizeAdded = 0;
1358                         auto it(pnode->vRecvMsg.begin());
1359                         for (; it != pnode->vRecvMsg.end(); ++it) {
1360                             if (!it->complete())
1361                                 break;
1362                             nSizeAdded += it->vRecv.size() + CMessageHeader::HEADER_SIZE;
1363                         }
1364                         {
1365                             LOCK(pnode->cs_vProcessMsg);
1366                             pnode->vProcessMsg.splice(pnode->vProcessMsg.end(), pnode->vRecvMsg, pnode->vRecvMsg.begin(), it);
1367                             pnode->nProcessQueueSize += nSizeAdded;
1368                             pnode->fPauseRecv = pnode->nProcessQueueSize > nReceiveFloodSize;
1369                         }
1370                         WakeMessageHandler();
1371                     }
1372                 }
1373                 else if (nBytes == 0)
1374                 {
1375                     // socket closed gracefully
1376                     if (!pnode->fDisconnect) {
1377                         LogPrint(BCLog::NET, "socket closed\n");
1378                     }
1379                     pnode->CloseSocketDisconnect();
1380                 }
1381                 else if (nBytes < 0)
1382                 {
1383                     // error
1384                     int nErr = WSAGetLastError();
1385                     if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
1386                     {
1387                         if (!pnode->fDisconnect)
1388                             LogPrintf("socket recv error %s\n", NetworkErrorString(nErr));
1389                         pnode->CloseSocketDisconnect();
1390                     }
1391                 }
1392             }
1393
1394             //
1395             // Send
1396             //
1397             if (sendSet)
1398             {
1399                 LOCK(pnode->cs_vSend);
1400                 size_t nBytes = SocketSendData(pnode);
1401                 if (nBytes) {
1402                     RecordBytesSent(nBytes);
1403                 }
1404             }
1405
1406             //
1407             // Inactivity checking
1408             //
1409             int64_t nTime = GetSystemTimeInSeconds();
1410             if (nTime - pnode->nTimeConnected > 60)
1411             {
1412                 if (pnode->nLastRecv == 0 || pnode->nLastSend == 0)
1413                 {
1414                     LogPrint(BCLog::NET, "socket no message in first 60 seconds, %d %d from %d\n", pnode->nLastRecv != 0, pnode->nLastSend != 0, pnode->GetId());
1415                     pnode->fDisconnect = true;
1416                 }
1417                 else if (nTime - pnode->nLastSend > TIMEOUT_INTERVAL)
1418                 {
1419                     LogPrintf("socket sending timeout: %is\n", nTime - pnode->nLastSend);
1420                     pnode->fDisconnect = true;
1421                 }
1422                 else if (nTime - pnode->nLastRecv > (pnode->nVersion > BIP0031_VERSION ? TIMEOUT_INTERVAL : 90*60))
1423                 {
1424                     LogPrintf("socket receive timeout: %is\n", nTime - pnode->nLastRecv);
1425                     pnode->fDisconnect = true;
1426                 }
1427                 else if (pnode->nPingNonceSent && pnode->nPingUsecStart + TIMEOUT_INTERVAL * 1000000 < GetTimeMicros())
1428                 {
1429                     LogPrintf("ping timeout: %fs\n", 0.000001 * (GetTimeMicros() - pnode->nPingUsecStart));
1430                     pnode->fDisconnect = true;
1431                 }
1432                 else if (!pnode->fSuccessfullyConnected)
1433                 {
1434                     LogPrintf("version handshake timeout from %d\n", pnode->GetId());
1435                     pnode->fDisconnect = true;
1436                 }
1437             }
1438         }
1439         {
1440             LOCK(cs_vNodes);
1441             for (CNode* pnode : vNodesCopy)
1442                 pnode->Release();
1443         }
1444     }
1445 }
1446
1447 void CConnman::WakeMessageHandler()
1448 {
1449     {
1450         std::lock_guard<std::mutex> lock(mutexMsgProc);
1451         fMsgProcWake = true;
1452     }
1453     condMsgProc.notify_one();
1454 }
1455
1456
1457
1458
1459
1460
1461 #ifdef USE_UPNP
1462 void ThreadMapPort()
1463 {
1464     std::string port = strprintf("%u", GetListenPort());
1465     const char * multicastif = nullptr;
1466     const char * minissdpdpath = nullptr;
1467     struct UPNPDev * devlist = nullptr;
1468     char lanaddr[64];
1469
1470 #ifndef UPNPDISCOVER_SUCCESS
1471     /* miniupnpc 1.5 */
1472     devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0);
1473 #elif MINIUPNPC_API_VERSION < 14
1474     /* miniupnpc 1.6 */
1475     int error = 0;
1476     devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, &error);
1477 #else
1478     /* miniupnpc 1.9.20150730 */
1479     int error = 0;
1480     devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, 2, &error);
1481 #endif
1482
1483     struct UPNPUrls urls;
1484     struct IGDdatas data;
1485     int r;
1486
1487     r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
1488     if (r == 1)
1489     {
1490         if (fDiscover) {
1491             char externalIPAddress[40];
1492             r = UPNP_GetExternalIPAddress(urls.controlURL, data.first.servicetype, externalIPAddress);
1493             if(r != UPNPCOMMAND_SUCCESS)
1494                 LogPrintf("UPnP: GetExternalIPAddress() returned %d\n", r);
1495             else
1496             {
1497                 if(externalIPAddress[0])
1498                 {
1499                     CNetAddr resolved;
1500                     if(LookupHost(externalIPAddress, resolved, false)) {
1501                         LogPrintf("UPnP: ExternalIPAddress = %s\n", resolved.ToString().c_str());
1502                         AddLocal(resolved, LOCAL_UPNP);
1503                     }
1504                 }
1505                 else
1506                     LogPrintf("UPnP: GetExternalIPAddress failed.\n");
1507             }
1508         }
1509
1510         std::string strDesc = "Bitcoin " + FormatFullVersion();
1511
1512         try {
1513             while (true) {
1514 #ifndef UPNPDISCOVER_SUCCESS
1515                 /* miniupnpc 1.5 */
1516                 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1517                                     port.c_str(), port.c_str(), lanaddr, strDesc.c_str(), "TCP", 0);
1518 #else
1519                 /* miniupnpc 1.6 */
1520                 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1521                                     port.c_str(), port.c_str(), lanaddr, strDesc.c_str(), "TCP", 0, "0");
1522 #endif
1523
1524                 if(r!=UPNPCOMMAND_SUCCESS)
1525                     LogPrintf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
1526                         port, port, lanaddr, r, strupnperror(r));
1527                 else
1528                     LogPrintf("UPnP Port Mapping successful.\n");
1529
1530                 MilliSleep(20*60*1000); // Refresh every 20 minutes
1531             }
1532         }
1533         catch (const boost::thread_interrupted&)
1534         {
1535             r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port.c_str(), "TCP", 0);
1536             LogPrintf("UPNP_DeletePortMapping() returned: %d\n", r);
1537             freeUPNPDevlist(devlist); devlist = nullptr;
1538             FreeUPNPUrls(&urls);
1539             throw;
1540         }
1541     } else {
1542         LogPrintf("No valid UPnP IGDs found\n");
1543         freeUPNPDevlist(devlist); devlist = nullptr;
1544         if (r != 0)
1545             FreeUPNPUrls(&urls);
1546     }
1547 }
1548
1549 void MapPort(bool fUseUPnP)
1550 {
1551     static std::unique_ptr<boost::thread> upnp_thread;
1552
1553     if (fUseUPnP)
1554     {
1555         if (upnp_thread) {
1556             upnp_thread->interrupt();
1557             upnp_thread->join();
1558         }
1559         upnp_thread.reset(new boost::thread(boost::bind(&TraceThread<void (*)()>, "upnp", &ThreadMapPort)));
1560     }
1561     else if (upnp_thread) {
1562         upnp_thread->interrupt();
1563         upnp_thread->join();
1564         upnp_thread.reset();
1565     }
1566 }
1567
1568 #else
1569 void MapPort(bool)
1570 {
1571     // Intentionally left blank.
1572 }
1573 #endif
1574
1575
1576
1577
1578
1579
1580 static std::string GetDNSHost(const CDNSSeedData& data, ServiceFlags* requiredServiceBits)
1581 {
1582     //use default host for non-filter-capable seeds or if we use the default service bits (NODE_NETWORK)
1583     if (!data.supportsServiceBitsFiltering || *requiredServiceBits == NODE_NETWORK) {
1584         *requiredServiceBits = NODE_NETWORK;
1585         return data.host;
1586     }
1587
1588     // See chainparams.cpp, most dnsseeds only support one or two possible servicebits hostnames
1589     return strprintf("x%x.%s", *requiredServiceBits, data.host);
1590 }
1591
1592
1593 void CConnman::ThreadDNSAddressSeed()
1594 {
1595     // goal: only query DNS seeds if address need is acute
1596     // Avoiding DNS seeds when we don't need them improves user privacy by
1597     //  creating fewer identifying DNS requests, reduces trust by giving seeds
1598     //  less influence on the network topology, and reduces traffic to the seeds.
1599     if ((addrman.size() > 0) &&
1600         (!gArgs.GetBoolArg("-forcednsseed", DEFAULT_FORCEDNSSEED))) {
1601         if (!interruptNet.sleep_for(std::chrono::seconds(11)))
1602             return;
1603
1604         LOCK(cs_vNodes);
1605         int nRelevant = 0;
1606         for (auto pnode : vNodes) {
1607             nRelevant += pnode->fSuccessfullyConnected && !pnode->fFeeler && !pnode->fOneShot && !pnode->m_manual_connection && !pnode->fInbound;
1608         }
1609         if (nRelevant >= 2) {
1610             LogPrintf("P2P peers available. Skipped DNS seeding.\n");
1611             return;
1612         }
1613     }
1614
1615     const std::vector<CDNSSeedData> &vSeeds = Params().DNSSeeds();
1616     int found = 0;
1617
1618     LogPrintf("Loading addresses from DNS seeds (could take a while)\n");
1619
1620     for (const CDNSSeedData &seed : vSeeds) {
1621         if (interruptNet) {
1622             return;
1623         }
1624         if (HaveNameProxy()) {
1625             AddOneShot(seed.host);
1626         } else {
1627             std::vector<CNetAddr> vIPs;
1628             std::vector<CAddress> vAdd;
1629             ServiceFlags requiredServiceBits = GetDesirableServiceFlags(NODE_NONE);
1630             std::string host = GetDNSHost(seed, &requiredServiceBits);
1631             CNetAddr resolveSource;
1632             if (!resolveSource.SetInternal(host)) {
1633                 continue;
1634             }
1635             if (LookupHost(host.c_str(), vIPs, 0, true))
1636             {
1637                 for (const CNetAddr& ip : vIPs)
1638                 {
1639                     int nOneDay = 24*3600;
1640                     CAddress addr = CAddress(CService(ip, Params().GetDefaultPort()), requiredServiceBits);
1641                     addr.nTime = GetTime() - 3*nOneDay - GetRand(4*nOneDay); // use a random age between 3 and 7 days old
1642                     vAdd.push_back(addr);
1643                     found++;
1644                 }
1645                 addrman.Add(vAdd, resolveSource);
1646             }
1647         }
1648     }
1649
1650     LogPrintf("%d addresses found from DNS seeds\n", found);
1651 }
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664 void CConnman::DumpAddresses()
1665 {
1666     int64_t nStart = GetTimeMillis();
1667
1668     CAddrDB adb;
1669     adb.Write(addrman);
1670
1671     LogPrint(BCLog::NET, "Flushed %d addresses to peers.dat  %dms\n",
1672            addrman.size(), GetTimeMillis() - nStart);
1673 }
1674
1675 void CConnman::DumpData()
1676 {
1677     DumpAddresses();
1678     DumpBanlist();
1679 }
1680
1681 void CConnman::ProcessOneShot()
1682 {
1683     std::string strDest;
1684     {
1685         LOCK(cs_vOneShots);
1686         if (vOneShots.empty())
1687             return;
1688         strDest = vOneShots.front();
1689         vOneShots.pop_front();
1690     }
1691     CAddress addr;
1692     CSemaphoreGrant grant(*semOutbound, true);
1693     if (grant) {
1694         if (!OpenNetworkConnection(addr, false, &grant, strDest.c_str(), true))
1695             AddOneShot(strDest);
1696     }
1697 }
1698
1699 bool CConnman::GetTryNewOutboundPeer()
1700 {
1701     return m_try_another_outbound_peer;
1702 }
1703
1704 void CConnman::SetTryNewOutboundPeer(bool flag)
1705 {
1706     m_try_another_outbound_peer = flag;
1707     LogPrint(BCLog::NET, "net: setting try another outbound peer=%s\n", flag ? "true" : "false");
1708 }
1709
1710 // Return the number of peers we have over our outbound connection limit
1711 // Exclude peers that are marked for disconnect, or are going to be
1712 // disconnected soon (eg one-shots and feelers)
1713 // Also exclude peers that haven't finished initial connection handshake yet
1714 // (so that we don't decide we're over our desired connection limit, and then
1715 // evict some peer that has finished the handshake)
1716 int CConnman::GetExtraOutboundCount()
1717 {
1718     int nOutbound = 0;
1719     {
1720         LOCK(cs_vNodes);
1721         for (CNode* pnode : vNodes) {
1722             if (!pnode->fInbound && !pnode->m_manual_connection && !pnode->fFeeler && !pnode->fDisconnect && !pnode->fOneShot && pnode->fSuccessfullyConnected) {
1723                 ++nOutbound;
1724             }
1725         }
1726     }
1727     return std::max(nOutbound - nMaxOutbound, 0);
1728 }
1729
1730 void CConnman::ThreadOpenConnections(const std::vector<std::string> connect)
1731 {
1732     // Connect to specific addresses
1733     if (!connect.empty())
1734     {
1735         for (int64_t nLoop = 0;; nLoop++)
1736         {
1737             ProcessOneShot();
1738             for (const std::string& strAddr : connect)
1739             {
1740                 CAddress addr(CService(), NODE_NONE);
1741                 OpenNetworkConnection(addr, false, nullptr, strAddr.c_str(), false, false, true);
1742                 for (int i = 0; i < 10 && i < nLoop; i++)
1743                 {
1744                     if (!interruptNet.sleep_for(std::chrono::milliseconds(500)))
1745                         return;
1746                 }
1747             }
1748             if (!interruptNet.sleep_for(std::chrono::milliseconds(500)))
1749                 return;
1750         }
1751     }
1752
1753     // Initiate network connections
1754     int64_t nStart = GetTime();
1755
1756     // Minimum time before next feeler connection (in microseconds).
1757     int64_t nNextFeeler = PoissonNextSend(nStart*1000*1000, FEELER_INTERVAL);
1758     while (!interruptNet)
1759     {
1760         ProcessOneShot();
1761
1762         if (!interruptNet.sleep_for(std::chrono::milliseconds(500)))
1763             return;
1764
1765         CSemaphoreGrant grant(*semOutbound);
1766         if (interruptNet)
1767             return;
1768
1769         // Add seed nodes if DNS seeds are all down (an infrastructure attack?).
1770         if (addrman.size() == 0 && (GetTime() - nStart > 60)) {
1771             static bool done = false;
1772             if (!done) {
1773                 LogPrintf("Adding fixed seed nodes as DNS doesn't seem to be available.\n");
1774                 CNetAddr local;
1775                 local.SetInternal("fixedseeds");
1776                 addrman.Add(convertSeed6(Params().FixedSeeds()), local);
1777                 done = true;
1778             }
1779         }
1780
1781         //
1782         // Choose an address to connect to based on most recently seen
1783         //
1784         CAddress addrConnect;
1785
1786         // Only connect out to one peer per network group (/16 for IPv4).
1787         // Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
1788         int nOutbound = 0;
1789         std::set<std::vector<unsigned char> > setConnected;
1790         {
1791             LOCK(cs_vNodes);
1792             for (CNode* pnode : vNodes) {
1793                 if (!pnode->fInbound && !pnode->m_manual_connection) {
1794                     // Netgroups for inbound and addnode peers are not excluded because our goal here
1795                     // is to not use multiple of our limited outbound slots on a single netgroup
1796                     // but inbound and addnode peers do not use our outbound slots.  Inbound peers
1797                     // also have the added issue that they're attacker controlled and could be used
1798                     // to prevent us from connecting to particular hosts if we used them here.
1799                     setConnected.insert(pnode->addr.GetGroup());
1800                     nOutbound++;
1801                 }
1802             }
1803         }
1804
1805         // Feeler Connections
1806         //
1807         // Design goals:
1808         //  * Increase the number of connectable addresses in the tried table.
1809         //
1810         // Method:
1811         //  * Choose a random address from new and attempt to connect to it if we can connect
1812         //    successfully it is added to tried.
1813         //  * Start attempting feeler connections only after node finishes making outbound
1814         //    connections.
1815         //  * Only make a feeler connection once every few minutes.
1816         //
1817         bool fFeeler = false;
1818
1819         if (nOutbound >= nMaxOutbound && !GetTryNewOutboundPeer()) {
1820             int64_t nTime = GetTimeMicros(); // The current time right now (in microseconds).
1821             if (nTime > nNextFeeler) {
1822                 nNextFeeler = PoissonNextSend(nTime, FEELER_INTERVAL);
1823                 fFeeler = true;
1824             } else {
1825                 continue;
1826             }
1827         }
1828
1829         int64_t nANow = GetAdjustedTime();
1830         int nTries = 0;
1831         while (!interruptNet)
1832         {
1833             CAddrInfo addr = addrman.Select(fFeeler);
1834
1835             // if we selected an invalid address, restart
1836             if (!addr.IsValid() || setConnected.count(addr.GetGroup()) || IsLocal(addr))
1837                 break;
1838
1839             // If we didn't find an appropriate destination after trying 100 addresses fetched from addrman,
1840             // stop this loop, and let the outer loop run again (which sleeps, adds seed nodes, recalculates
1841             // already-connected network ranges, ...) before trying new addrman addresses.
1842             nTries++;
1843             if (nTries > 100)
1844                 break;
1845
1846             if (IsLimited(addr))
1847                 continue;
1848
1849             // only consider very recently tried nodes after 30 failed attempts
1850             if (nANow - addr.nLastTry < 600 && nTries < 30)
1851                 continue;
1852
1853             // for non-feelers, require all the services we'll want,
1854             // for feelers, only require they be a full node (only because most
1855             // SPV clients don't have a good address DB available)
1856             if (!fFeeler && !HasAllDesirableServiceFlags(addr.nServices)) {
1857                 continue;
1858             } else if (fFeeler && !MayHaveUsefulAddressDB(addr.nServices)) {
1859                 continue;
1860             }
1861
1862             // do not allow non-default ports, unless after 50 invalid addresses selected already
1863             if (addr.GetPort() != Params().GetDefaultPort() && nTries < 50)
1864                 continue;
1865
1866             addrConnect = addr;
1867             break;
1868         }
1869
1870         if (addrConnect.IsValid()) {
1871
1872             if (fFeeler) {
1873                 // Add small amount of random noise before connection to avoid synchronization.
1874                 int randsleep = GetRandInt(FEELER_SLEEP_WINDOW * 1000);
1875                 if (!interruptNet.sleep_for(std::chrono::milliseconds(randsleep)))
1876                     return;
1877                 LogPrint(BCLog::NET, "Making feeler connection to %s\n", addrConnect.ToString());
1878             }
1879
1880             OpenNetworkConnection(addrConnect, (int)setConnected.size() >= std::min(nMaxConnections - 1, 2), &grant, nullptr, false, fFeeler);
1881         }
1882     }
1883 }
1884
1885 std::vector<AddedNodeInfo> CConnman::GetAddedNodeInfo()
1886 {
1887     std::vector<AddedNodeInfo> ret;
1888
1889     std::list<std::string> lAddresses(0);
1890     {
1891         LOCK(cs_vAddedNodes);
1892         ret.reserve(vAddedNodes.size());
1893         std::copy(vAddedNodes.cbegin(), vAddedNodes.cend(), std::back_inserter(lAddresses));
1894     }
1895
1896
1897     // Build a map of all already connected addresses (by IP:port and by name) to inbound/outbound and resolved CService
1898     std::map<CService, bool> mapConnected;
1899     std::map<std::string, std::pair<bool, CService>> mapConnectedByName;
1900     {
1901         LOCK(cs_vNodes);
1902         for (const CNode* pnode : vNodes) {
1903             if (pnode->addr.IsValid()) {
1904                 mapConnected[pnode->addr] = pnode->fInbound;
1905             }
1906             std::string addrName = pnode->GetAddrName();
1907             if (!addrName.empty()) {
1908                 mapConnectedByName[std::move(addrName)] = std::make_pair(pnode->fInbound, static_cast<const CService&>(pnode->addr));
1909             }
1910         }
1911     }
1912
1913     for (const std::string& strAddNode : lAddresses) {
1914         CService service(LookupNumeric(strAddNode.c_str(), Params().GetDefaultPort()));
1915         if (service.IsValid()) {
1916             // strAddNode is an IP:port
1917             auto it = mapConnected.find(service);
1918             if (it != mapConnected.end()) {
1919                 ret.push_back(AddedNodeInfo{strAddNode, service, true, it->second});
1920             } else {
1921                 ret.push_back(AddedNodeInfo{strAddNode, CService(), false, false});
1922             }
1923         } else {
1924             // strAddNode is a name
1925             auto it = mapConnectedByName.find(strAddNode);
1926             if (it != mapConnectedByName.end()) {
1927                 ret.push_back(AddedNodeInfo{strAddNode, it->second.second, true, it->second.first});
1928             } else {
1929                 ret.push_back(AddedNodeInfo{strAddNode, CService(), false, false});
1930             }
1931         }
1932     }
1933
1934     return ret;
1935 }
1936
1937 void CConnman::ThreadOpenAddedConnections()
1938 {
1939     while (true)
1940     {
1941         CSemaphoreGrant grant(*semAddnode);
1942         std::vector<AddedNodeInfo> vInfo = GetAddedNodeInfo();
1943         bool tried = false;
1944         for (const AddedNodeInfo& info : vInfo) {
1945             if (!info.fConnected) {
1946                 if (!grant.TryAcquire()) {
1947                     // If we've used up our semaphore and need a new one, lets not wait here since while we are waiting
1948                     // the addednodeinfo state might change.
1949                     break;
1950                 }
1951                 tried = true;
1952                 CAddress addr(CService(), NODE_NONE);
1953                 OpenNetworkConnection(addr, false, &grant, info.strAddedNode.c_str(), false, false, true);
1954                 if (!interruptNet.sleep_for(std::chrono::milliseconds(500)))
1955                     return;
1956             }
1957         }
1958         // Retry every 60 seconds if a connection was attempted, otherwise two seconds
1959         if (!interruptNet.sleep_for(std::chrono::seconds(tried ? 60 : 2)))
1960             return;
1961     }
1962 }
1963
1964 // if successful, this moves the passed grant to the constructed node
1965 bool CConnman::OpenNetworkConnection(const CAddress& addrConnect, bool fCountFailure, CSemaphoreGrant *grantOutbound, const char *pszDest, bool fOneShot, bool fFeeler, bool manual_connection)
1966 {
1967     //
1968     // Initiate outbound network connection
1969     //
1970     if (interruptNet) {
1971         return false;
1972     }
1973     if (!fNetworkActive) {
1974         return false;
1975     }
1976     if (!pszDest) {
1977         if (IsLocal(addrConnect) ||
1978             FindNode((CNetAddr)addrConnect) || IsBanned(addrConnect) ||
1979             FindNode(addrConnect.ToStringIPPort()))
1980             return false;
1981     } else if (FindNode(std::string(pszDest)))
1982         return false;
1983
1984     CNode* pnode = ConnectNode(addrConnect, pszDest, fCountFailure);
1985
1986     if (!pnode)
1987         return false;
1988     if (grantOutbound)
1989         grantOutbound->MoveTo(pnode->grantOutbound);
1990     if (fOneShot)
1991         pnode->fOneShot = true;
1992     if (fFeeler)
1993         pnode->fFeeler = true;
1994     if (manual_connection)
1995         pnode->m_manual_connection = true;
1996
1997     m_msgproc->InitializeNode(pnode);
1998     {
1999         LOCK(cs_vNodes);
2000         vNodes.push_back(pnode);
2001     }
2002
2003     return true;
2004 }
2005
2006 void CConnman::ThreadMessageHandler()
2007 {
2008     while (!flagInterruptMsgProc)
2009     {
2010         std::vector<CNode*> vNodesCopy;
2011         {
2012             LOCK(cs_vNodes);
2013             vNodesCopy = vNodes;
2014             for (CNode* pnode : vNodesCopy) {
2015                 pnode->AddRef();
2016             }
2017         }
2018
2019         bool fMoreWork = false;
2020
2021         for (CNode* pnode : vNodesCopy)
2022         {
2023             if (pnode->fDisconnect)
2024                 continue;
2025
2026             // Receive messages
2027             bool fMoreNodeWork = m_msgproc->ProcessMessages(pnode, flagInterruptMsgProc);
2028             fMoreWork |= (fMoreNodeWork && !pnode->fPauseSend);
2029             if (flagInterruptMsgProc)
2030                 return;
2031             // Send messages
2032             {
2033                 LOCK(pnode->cs_sendProcessing);
2034                 m_msgproc->SendMessages(pnode, flagInterruptMsgProc);
2035             }
2036
2037             if (flagInterruptMsgProc)
2038                 return;
2039         }
2040
2041         {
2042             LOCK(cs_vNodes);
2043             for (CNode* pnode : vNodesCopy)
2044                 pnode->Release();
2045         }
2046
2047         std::unique_lock<std::mutex> lock(mutexMsgProc);
2048         if (!fMoreWork) {
2049             condMsgProc.wait_until(lock, std::chrono::steady_clock::now() + std::chrono::milliseconds(100), [this] { return fMsgProcWake; });
2050         }
2051         fMsgProcWake = false;
2052     }
2053 }
2054
2055
2056
2057
2058
2059
2060 bool CConnman::BindListenPort(const CService &addrBind, std::string& strError, bool fWhitelisted)
2061 {
2062     strError = "";
2063     int nOne = 1;
2064
2065     // Create socket for listening for incoming connections
2066     struct sockaddr_storage sockaddr;
2067     socklen_t len = sizeof(sockaddr);
2068     if (!addrBind.GetSockAddr((struct sockaddr*)&sockaddr, &len))
2069     {
2070         strError = strprintf("Error: Bind address family for %s not supported", addrBind.ToString());
2071         LogPrintf("%s\n", strError);
2072         return false;
2073     }
2074
2075     SOCKET hListenSocket = CreateSocket(addrBind);
2076     if (hListenSocket == INVALID_SOCKET)
2077     {
2078         strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %s)", NetworkErrorString(WSAGetLastError()));
2079         LogPrintf("%s\n", strError);
2080         return false;
2081     }
2082 #ifndef WIN32
2083     // Allow binding if the port is still in TIME_WAIT state after
2084     // the program was closed and restarted.
2085     setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (void*)&nOne, sizeof(int));
2086 #else
2087     setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (const char*)&nOne, sizeof(int));
2088 #endif
2089
2090     // some systems don't have IPV6_V6ONLY but are always v6only; others do have the option
2091     // and enable it by default or not. Try to enable it, if possible.
2092     if (addrBind.IsIPv6()) {
2093 #ifdef IPV6_V6ONLY
2094 #ifdef WIN32
2095         setsockopt(hListenSocket, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&nOne, sizeof(int));
2096 #else
2097         setsockopt(hListenSocket, IPPROTO_IPV6, IPV6_V6ONLY, (void*)&nOne, sizeof(int));
2098 #endif
2099 #endif
2100 #ifdef WIN32
2101         int nProtLevel = PROTECTION_LEVEL_UNRESTRICTED;
2102         setsockopt(hListenSocket, IPPROTO_IPV6, IPV6_PROTECTION_LEVEL, (const char*)&nProtLevel, sizeof(int));
2103 #endif
2104     }
2105
2106     if (::bind(hListenSocket, (struct sockaddr*)&sockaddr, len) == SOCKET_ERROR)
2107     {
2108         int nErr = WSAGetLastError();
2109         if (nErr == WSAEADDRINUSE)
2110             strError = strprintf(_("Unable to bind to %s on this computer. %s is probably already running."), addrBind.ToString(), _(PACKAGE_NAME));
2111         else
2112             strError = strprintf(_("Unable to bind to %s on this computer (bind returned error %s)"), addrBind.ToString(), NetworkErrorString(nErr));
2113         LogPrintf("%s\n", strError);
2114         CloseSocket(hListenSocket);
2115         return false;
2116     }
2117     LogPrintf("Bound to %s\n", addrBind.ToString());
2118
2119     // Listen for incoming connections
2120     if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR)
2121     {
2122         strError = strprintf(_("Error: Listening for incoming connections failed (listen returned error %s)"), NetworkErrorString(WSAGetLastError()));
2123         LogPrintf("%s\n", strError);
2124         CloseSocket(hListenSocket);
2125         return false;
2126     }
2127
2128     vhListenSocket.push_back(ListenSocket(hListenSocket, fWhitelisted));
2129
2130     if (addrBind.IsRoutable() && fDiscover && !fWhitelisted)
2131         AddLocal(addrBind, LOCAL_BIND);
2132
2133     return true;
2134 }
2135
2136 void Discover(boost::thread_group& threadGroup)
2137 {
2138     if (!fDiscover)
2139         return;
2140
2141 #ifdef WIN32
2142     // Get local host IP
2143     char pszHostName[256] = "";
2144     if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR)
2145     {
2146         std::vector<CNetAddr> vaddr;
2147         if (LookupHost(pszHostName, vaddr, 0, true))
2148         {
2149             for (const CNetAddr &addr : vaddr)
2150             {
2151                 if (AddLocal(addr, LOCAL_IF))
2152                     LogPrintf("%s: %s - %s\n", __func__, pszHostName, addr.ToString());
2153             }
2154         }
2155     }
2156 #else
2157     // Get local host ip
2158     struct ifaddrs* myaddrs;
2159     if (getifaddrs(&myaddrs) == 0)
2160     {
2161         for (struct ifaddrs* ifa = myaddrs; ifa != nullptr; ifa = ifa->ifa_next)
2162         {
2163             if (ifa->ifa_addr == nullptr) continue;
2164             if ((ifa->ifa_flags & IFF_UP) == 0) continue;
2165             if (strcmp(ifa->ifa_name, "lo") == 0) continue;
2166             if (strcmp(ifa->ifa_name, "lo0") == 0) continue;
2167             if (ifa->ifa_addr->sa_family == AF_INET)
2168             {
2169                 struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
2170                 CNetAddr addr(s4->sin_addr);
2171                 if (AddLocal(addr, LOCAL_IF))
2172                     LogPrintf("%s: IPv4 %s: %s\n", __func__, ifa->ifa_name, addr.ToString());
2173             }
2174             else if (ifa->ifa_addr->sa_family == AF_INET6)
2175             {
2176                 struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
2177                 CNetAddr addr(s6->sin6_addr);
2178                 if (AddLocal(addr, LOCAL_IF))
2179                     LogPrintf("%s: IPv6 %s: %s\n", __func__, ifa->ifa_name, addr.ToString());
2180             }
2181         }
2182         freeifaddrs(myaddrs);
2183     }
2184 #endif
2185 }
2186
2187 void CConnman::SetNetworkActive(bool active)
2188 {
2189     LogPrint(BCLog::NET, "SetNetworkActive: %s\n", active);
2190
2191     if (fNetworkActive == active) {
2192         return;
2193     }
2194
2195     fNetworkActive = active;
2196
2197     if (!fNetworkActive) {
2198         LOCK(cs_vNodes);
2199         // Close sockets to all nodes
2200         for (CNode* pnode : vNodes) {
2201             pnode->CloseSocketDisconnect();
2202         }
2203     }
2204
2205     uiInterface.NotifyNetworkActiveChanged(fNetworkActive);
2206 }
2207
2208 CConnman::CConnman(uint64_t nSeed0In, uint64_t nSeed1In) : nSeed0(nSeed0In), nSeed1(nSeed1In)
2209 {
2210     fNetworkActive = true;
2211     setBannedIsDirty = false;
2212     fAddressesInitialized = false;
2213     nLastNodeId = 0;
2214     nSendBufferMaxSize = 0;
2215     nReceiveFloodSize = 0;
2216     flagInterruptMsgProc = false;
2217     SetTryNewOutboundPeer(false);
2218
2219     Options connOptions;
2220     Init(connOptions);
2221 }
2222
2223 NodeId CConnman::GetNewNodeId()
2224 {
2225     return nLastNodeId.fetch_add(1, std::memory_order_relaxed);
2226 }
2227
2228
2229 bool CConnman::Bind(const CService &addr, unsigned int flags) {
2230     if (!(flags & BF_EXPLICIT) && IsLimited(addr))
2231         return false;
2232     std::string strError;
2233     if (!BindListenPort(addr, strError, (flags & BF_WHITELIST) != 0)) {
2234         if ((flags & BF_REPORT_ERROR) && clientInterface) {
2235             clientInterface->ThreadSafeMessageBox(strError, "", CClientUIInterface::MSG_ERROR);
2236         }
2237         return false;
2238     }
2239     return true;
2240 }
2241
2242 bool CConnman::InitBinds(const std::vector<CService>& binds, const std::vector<CService>& whiteBinds) {
2243     bool fBound = false;
2244     for (const auto& addrBind : binds) {
2245         fBound |= Bind(addrBind, (BF_EXPLICIT | BF_REPORT_ERROR));
2246     }
2247     for (const auto& addrBind : whiteBinds) {
2248         fBound |= Bind(addrBind, (BF_EXPLICIT | BF_REPORT_ERROR | BF_WHITELIST));
2249     }
2250     if (binds.empty() && whiteBinds.empty()) {
2251         struct in_addr inaddr_any;
2252         inaddr_any.s_addr = INADDR_ANY;
2253         fBound |= Bind(CService(in6addr_any, GetListenPort()), BF_NONE);
2254         fBound |= Bind(CService(inaddr_any, GetListenPort()), !fBound ? BF_REPORT_ERROR : BF_NONE);
2255     }
2256     return fBound;
2257 }
2258
2259 bool CConnman::Start(CScheduler& scheduler, const Options& connOptions)
2260 {
2261     Init(connOptions);
2262
2263     {
2264         LOCK(cs_totalBytesRecv);
2265         nTotalBytesRecv = 0;
2266     }
2267     {
2268         LOCK(cs_totalBytesSent);
2269         nTotalBytesSent = 0;
2270         nMaxOutboundTotalBytesSentInCycle = 0;
2271         nMaxOutboundCycleStartTime = 0;
2272     }
2273
2274     if (fListen && !InitBinds(connOptions.vBinds, connOptions.vWhiteBinds)) {
2275         if (clientInterface) {
2276             clientInterface->ThreadSafeMessageBox(
2277                 _("Failed to listen on any port. Use -listen=0 if you want this."),
2278                 "", CClientUIInterface::MSG_ERROR);
2279         }
2280         return false;
2281     }
2282
2283     for (const auto& strDest : connOptions.vSeedNodes) {
2284         AddOneShot(strDest);
2285     }
2286
2287     if (clientInterface) {
2288         clientInterface->InitMessage(_("Loading P2P addresses..."));
2289     }
2290     // Load addresses from peers.dat
2291     int64_t nStart = GetTimeMillis();
2292     {
2293         CAddrDB adb;
2294         if (adb.Read(addrman))
2295             LogPrintf("Loaded %i addresses from peers.dat  %dms\n", addrman.size(), GetTimeMillis() - nStart);
2296         else {
2297             addrman.Clear(); // Addrman can be in an inconsistent state after failure, reset it
2298             LogPrintf("Invalid or missing peers.dat; recreating\n");
2299             DumpAddresses();
2300         }
2301     }
2302     if (clientInterface)
2303         clientInterface->InitMessage(_("Loading banlist..."));
2304     // Load addresses from banlist.dat
2305     nStart = GetTimeMillis();
2306     CBanDB bandb;
2307     banmap_t banmap;
2308     if (bandb.Read(banmap)) {
2309         SetBanned(banmap); // thread save setter
2310         SetBannedSetDirty(false); // no need to write down, just read data
2311         SweepBanned(); // sweep out unused entries
2312
2313         LogPrint(BCLog::NET, "Loaded %d banned node ips/subnets from banlist.dat  %dms\n",
2314             banmap.size(), GetTimeMillis() - nStart);
2315     } else {
2316         LogPrintf("Invalid or missing banlist.dat; recreating\n");
2317         SetBannedSetDirty(true); // force write
2318         DumpBanlist();
2319     }
2320
2321     uiInterface.InitMessage(_("Starting network threads..."));
2322
2323     fAddressesInitialized = true;
2324
2325     if (semOutbound == nullptr) {
2326         // initialize semaphore
2327         semOutbound = MakeUnique<CSemaphore>(std::min((nMaxOutbound + nMaxFeeler), nMaxConnections));
2328     }
2329     if (semAddnode == nullptr) {
2330         // initialize semaphore
2331         semAddnode = MakeUnique<CSemaphore>(nMaxAddnode);
2332     }
2333
2334     //
2335     // Start threads
2336     //
2337     assert(m_msgproc);
2338     InterruptSocks5(false);
2339     interruptNet.reset();
2340     flagInterruptMsgProc = false;
2341
2342     {
2343         std::unique_lock<std::mutex> lock(mutexMsgProc);
2344         fMsgProcWake = false;
2345     }
2346
2347     // Send and receive from sockets, accept connections
2348     threadSocketHandler = std::thread(&TraceThread<std::function<void()> >, "net", std::function<void()>(std::bind(&CConnman::ThreadSocketHandler, this)));
2349
2350     if (!gArgs.GetBoolArg("-dnsseed", true))
2351         LogPrintf("DNS seeding disabled\n");
2352     else
2353         threadDNSAddressSeed = std::thread(&TraceThread<std::function<void()> >, "dnsseed", std::function<void()>(std::bind(&CConnman::ThreadDNSAddressSeed, this)));
2354
2355     // Initiate outbound connections from -addnode
2356     threadOpenAddedConnections = std::thread(&TraceThread<std::function<void()> >, "addcon", std::function<void()>(std::bind(&CConnman::ThreadOpenAddedConnections, this)));
2357
2358     if (connOptions.m_use_addrman_outgoing && !connOptions.m_specified_outgoing.empty()) {
2359         if (clientInterface) {
2360             clientInterface->ThreadSafeMessageBox(
2361                 _("Cannot provide specific connections and have addrman find outgoing connections at the same."),
2362                 "", CClientUIInterface::MSG_ERROR);
2363         }
2364         return false;
2365     }
2366     if (connOptions.m_use_addrman_outgoing || !connOptions.m_specified_outgoing.empty())
2367         threadOpenConnections = std::thread(&TraceThread<std::function<void()> >, "opencon", std::function<void()>(std::bind(&CConnman::ThreadOpenConnections, this, connOptions.m_specified_outgoing)));
2368
2369     // Process messages
2370     threadMessageHandler = std::thread(&TraceThread<std::function<void()> >, "msghand", std::function<void()>(std::bind(&CConnman::ThreadMessageHandler, this)));
2371
2372     // Dump network addresses
2373     scheduler.scheduleEvery(std::bind(&CConnman::DumpData, this), DUMP_ADDRESSES_INTERVAL * 1000);
2374
2375     return true;
2376 }
2377
2378 class CNetCleanup
2379 {
2380 public:
2381     CNetCleanup() {}
2382
2383     ~CNetCleanup()
2384     {
2385 #ifdef WIN32
2386         // Shutdown Windows Sockets
2387         WSACleanup();
2388 #endif
2389     }
2390 }
2391 instance_of_cnetcleanup;
2392
2393 void CConnman::Interrupt()
2394 {
2395     {
2396         std::lock_guard<std::mutex> lock(mutexMsgProc);
2397         flagInterruptMsgProc = true;
2398     }
2399     condMsgProc.notify_all();
2400
2401     interruptNet();
2402     InterruptSocks5(true);
2403
2404     if (semOutbound) {
2405         for (int i=0; i<(nMaxOutbound + nMaxFeeler); i++) {
2406             semOutbound->post();
2407         }
2408     }
2409
2410     if (semAddnode) {
2411         for (int i=0; i<nMaxAddnode; i++) {
2412             semAddnode->post();
2413         }
2414     }
2415 }
2416
2417 void CConnman::Stop()
2418 {
2419     if (threadMessageHandler.joinable())
2420         threadMessageHandler.join();
2421     if (threadOpenConnections.joinable())
2422         threadOpenConnections.join();
2423     if (threadOpenAddedConnections.joinable())
2424         threadOpenAddedConnections.join();
2425     if (threadDNSAddressSeed.joinable())
2426         threadDNSAddressSeed.join();
2427     if (threadSocketHandler.joinable())
2428         threadSocketHandler.join();
2429
2430     if (fAddressesInitialized)
2431     {
2432         DumpData();
2433         fAddressesInitialized = false;
2434     }
2435
2436     // Close sockets
2437     for (CNode* pnode : vNodes)
2438         pnode->CloseSocketDisconnect();
2439     for (ListenSocket& hListenSocket : vhListenSocket)
2440         if (hListenSocket.socket != INVALID_SOCKET)
2441             if (!CloseSocket(hListenSocket.socket))
2442                 LogPrintf("CloseSocket(hListenSocket) failed with error %s\n", NetworkErrorString(WSAGetLastError()));
2443
2444     // clean up some globals (to help leak detection)
2445     for (CNode *pnode : vNodes) {
2446         DeleteNode(pnode);
2447     }
2448     for (CNode *pnode : vNodesDisconnected) {
2449         DeleteNode(pnode);
2450     }
2451     vNodes.clear();
2452     vNodesDisconnected.clear();
2453     vhListenSocket.clear();
2454     semOutbound.reset();
2455     semAddnode.reset();
2456 }
2457
2458 void CConnman::DeleteNode(CNode* pnode)
2459 {
2460     assert(pnode);
2461     bool fUpdateConnectionTime = false;
2462     m_msgproc->FinalizeNode(pnode->GetId(), fUpdateConnectionTime);
2463     if(fUpdateConnectionTime) {
2464         addrman.Connected(pnode->addr);
2465     }
2466     delete pnode;
2467 }
2468
2469 CConnman::~CConnman()
2470 {
2471     Interrupt();
2472     Stop();
2473 }
2474
2475 size_t CConnman::GetAddressCount() const
2476 {
2477     return addrman.size();
2478 }
2479
2480 void CConnman::SetServices(const CService &addr, ServiceFlags nServices)
2481 {
2482     addrman.SetServices(addr, nServices);
2483 }
2484
2485 void CConnman::MarkAddressGood(const CAddress& addr)
2486 {
2487     addrman.Good(addr);
2488 }
2489
2490 void CConnman::AddNewAddresses(const std::vector<CAddress>& vAddr, const CAddress& addrFrom, int64_t nTimePenalty)
2491 {
2492     addrman.Add(vAddr, addrFrom, nTimePenalty);
2493 }
2494
2495 std::vector<CAddress> CConnman::GetAddresses()
2496 {
2497     return addrman.GetAddr();
2498 }
2499
2500 bool CConnman::AddNode(const std::string& strNode)
2501 {
2502     LOCK(cs_vAddedNodes);
2503     for (const std::string& it : vAddedNodes) {
2504         if (strNode == it) return false;
2505     }
2506
2507     vAddedNodes.push_back(strNode);
2508     return true;
2509 }
2510
2511 bool CConnman::RemoveAddedNode(const std::string& strNode)
2512 {
2513     LOCK(cs_vAddedNodes);
2514     for(std::vector<std::string>::iterator it = vAddedNodes.begin(); it != vAddedNodes.end(); ++it) {
2515         if (strNode == *it) {
2516             vAddedNodes.erase(it);
2517             return true;
2518         }
2519     }
2520     return false;
2521 }
2522
2523 size_t CConnman::GetNodeCount(NumConnections flags)
2524 {
2525     LOCK(cs_vNodes);
2526     if (flags == CConnman::CONNECTIONS_ALL) // Shortcut if we want total
2527         return vNodes.size();
2528
2529     int nNum = 0;
2530     for (const auto& pnode : vNodes) {
2531         if (flags & (pnode->fInbound ? CONNECTIONS_IN : CONNECTIONS_OUT)) {
2532             nNum++;
2533         }
2534     }
2535
2536     return nNum;
2537 }
2538
2539 void CConnman::GetNodeStats(std::vector<CNodeStats>& vstats)
2540 {
2541     vstats.clear();
2542     LOCK(cs_vNodes);
2543     vstats.reserve(vNodes.size());
2544     for (CNode* pnode : vNodes) {
2545         vstats.emplace_back();
2546         pnode->copyStats(vstats.back());
2547     }
2548 }
2549
2550 bool CConnman::DisconnectNode(const std::string& strNode)
2551 {
2552     LOCK(cs_vNodes);
2553     if (CNode* pnode = FindNode(strNode)) {
2554         pnode->fDisconnect = true;
2555         return true;
2556     }
2557     return false;
2558 }
2559 bool CConnman::DisconnectNode(NodeId id)
2560 {
2561     LOCK(cs_vNodes);
2562     for(CNode* pnode : vNodes) {
2563         if (id == pnode->GetId()) {
2564             pnode->fDisconnect = true;
2565             return true;
2566         }
2567     }
2568     return false;
2569 }
2570
2571 void CConnman::RecordBytesRecv(uint64_t bytes)
2572 {
2573     LOCK(cs_totalBytesRecv);
2574     nTotalBytesRecv += bytes;
2575 }
2576
2577 void CConnman::RecordBytesSent(uint64_t bytes)
2578 {
2579     LOCK(cs_totalBytesSent);
2580     nTotalBytesSent += bytes;
2581
2582     uint64_t now = GetTime();
2583     if (nMaxOutboundCycleStartTime + nMaxOutboundTimeframe < now)
2584     {
2585         // timeframe expired, reset cycle
2586         nMaxOutboundCycleStartTime = now;
2587         nMaxOutboundTotalBytesSentInCycle = 0;
2588     }
2589
2590     // TODO, exclude whitebind peers
2591     nMaxOutboundTotalBytesSentInCycle += bytes;
2592 }
2593
2594 void CConnman::SetMaxOutboundTarget(uint64_t limit)
2595 {
2596     LOCK(cs_totalBytesSent);
2597     nMaxOutboundLimit = limit;
2598 }
2599
2600 uint64_t CConnman::GetMaxOutboundTarget()
2601 {
2602     LOCK(cs_totalBytesSent);
2603     return nMaxOutboundLimit;
2604 }
2605
2606 uint64_t CConnman::GetMaxOutboundTimeframe()
2607 {
2608     LOCK(cs_totalBytesSent);
2609     return nMaxOutboundTimeframe;
2610 }
2611
2612 uint64_t CConnman::GetMaxOutboundTimeLeftInCycle()
2613 {
2614     LOCK(cs_totalBytesSent);
2615     if (nMaxOutboundLimit == 0)
2616         return 0;
2617
2618     if (nMaxOutboundCycleStartTime == 0)
2619         return nMaxOutboundTimeframe;
2620
2621     uint64_t cycleEndTime = nMaxOutboundCycleStartTime + nMaxOutboundTimeframe;
2622     uint64_t now = GetTime();
2623     return (cycleEndTime < now) ? 0 : cycleEndTime - GetTime();
2624 }
2625
2626 void CConnman::SetMaxOutboundTimeframe(uint64_t timeframe)
2627 {
2628     LOCK(cs_totalBytesSent);
2629     if (nMaxOutboundTimeframe != timeframe)
2630     {
2631         // reset measure-cycle in case of changing
2632         // the timeframe
2633         nMaxOutboundCycleStartTime = GetTime();
2634     }
2635     nMaxOutboundTimeframe = timeframe;
2636 }
2637
2638 bool CConnman::OutboundTargetReached(bool historicalBlockServingLimit)
2639 {
2640     LOCK(cs_totalBytesSent);
2641     if (nMaxOutboundLimit == 0)
2642         return false;
2643
2644     if (historicalBlockServingLimit)
2645     {
2646         // keep a large enough buffer to at least relay each block once
2647         uint64_t timeLeftInCycle = GetMaxOutboundTimeLeftInCycle();
2648         uint64_t buffer = timeLeftInCycle / 600 * MAX_BLOCK_SERIALIZED_SIZE;
2649         if (buffer >= nMaxOutboundLimit || nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit - buffer)
2650             return true;
2651     }
2652     else if (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit)
2653         return true;
2654
2655     return false;
2656 }
2657
2658 uint64_t CConnman::GetOutboundTargetBytesLeft()
2659 {
2660     LOCK(cs_totalBytesSent);
2661     if (nMaxOutboundLimit == 0)
2662         return 0;
2663
2664     return (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit) ? 0 : nMaxOutboundLimit - nMaxOutboundTotalBytesSentInCycle;
2665 }
2666
2667 uint64_t CConnman::GetTotalBytesRecv()
2668 {
2669     LOCK(cs_totalBytesRecv);
2670     return nTotalBytesRecv;
2671 }
2672
2673 uint64_t CConnman::GetTotalBytesSent()
2674 {
2675     LOCK(cs_totalBytesSent);
2676     return nTotalBytesSent;
2677 }
2678
2679 ServiceFlags CConnman::GetLocalServices() const
2680 {
2681     return nLocalServices;
2682 }
2683
2684 void CConnman::SetBestHeight(int height)
2685 {
2686     nBestHeight.store(height, std::memory_order_release);
2687 }
2688
2689 int CConnman::GetBestHeight() const
2690 {
2691     return nBestHeight.load(std::memory_order_acquire);
2692 }
2693
2694 unsigned int CConnman::GetReceiveFloodSize() const { return nReceiveFloodSize; }
2695
2696 CNode::CNode(NodeId idIn, ServiceFlags nLocalServicesIn, int nMyStartingHeightIn, SOCKET hSocketIn, const CAddress& addrIn, uint64_t nKeyedNetGroupIn, uint64_t nLocalHostNonceIn, const CAddress &addrBindIn, const std::string& addrNameIn, bool fInboundIn) :
2697     nTimeConnected(GetSystemTimeInSeconds()),
2698     addr(addrIn),
2699     addrBind(addrBindIn),
2700     fInbound(fInboundIn),
2701     nKeyedNetGroup(nKeyedNetGroupIn),
2702     addrKnown(5000, 0.001),
2703     filterInventoryKnown(50000, 0.000001),
2704     id(idIn),
2705     nLocalHostNonce(nLocalHostNonceIn),
2706     nLocalServices(nLocalServicesIn),
2707     nMyStartingHeight(nMyStartingHeightIn),
2708     nSendVersion(0)
2709 {
2710     nServices = NODE_NONE;
2711     hSocket = hSocketIn;
2712     nRecvVersion = INIT_PROTO_VERSION;
2713     nLastSend = 0;
2714     nLastRecv = 0;
2715     nSendBytes = 0;
2716     nRecvBytes = 0;
2717     nTimeOffset = 0;
2718     addrName = addrNameIn == "" ? addr.ToStringIPPort() : addrNameIn;
2719     nVersion = 0;
2720     strSubVer = "";
2721     fWhitelisted = false;
2722     fOneShot = false;
2723     m_manual_connection = false;
2724     fClient = false; // set by version message
2725     fFeeler = false;
2726     fSuccessfullyConnected = false;
2727     fDisconnect = false;
2728     nRefCount = 0;
2729     nSendSize = 0;
2730     nSendOffset = 0;
2731     hashContinue = uint256();
2732     nStartingHeight = -1;
2733     filterInventoryKnown.reset();
2734     fSendMempool = false;
2735     fGetAddr = false;
2736     nNextLocalAddrSend = 0;
2737     nNextAddrSend = 0;
2738     nNextInvSend = 0;
2739     fRelayTxes = false;
2740     fSentAddr = false;
2741     pfilter = MakeUnique<CBloomFilter>();
2742     timeLastMempoolReq = 0;
2743     nLastBlockTime = 0;
2744     nLastTXTime = 0;
2745     nPingNonceSent = 0;
2746     nPingUsecStart = 0;
2747     nPingUsecTime = 0;
2748     fPingQueued = false;
2749     nMinPingUsecTime = std::numeric_limits<int64_t>::max();
2750     minFeeFilter = 0;
2751     lastSentFeeFilter = 0;
2752     nextSendTimeFeeFilter = 0;
2753     fPauseRecv = false;
2754     fPauseSend = false;
2755     nProcessQueueSize = 0;
2756
2757     for (const std::string &msg : getAllNetMessageTypes())
2758         mapRecvBytesPerMsgCmd[msg] = 0;
2759     mapRecvBytesPerMsgCmd[NET_MESSAGE_COMMAND_OTHER] = 0;
2760
2761     if (fLogIPs) {
2762         LogPrint(BCLog::NET, "Added connection to %s peer=%d\n", addrName, id);
2763     } else {
2764         LogPrint(BCLog::NET, "Added connection peer=%d\n", id);
2765     }
2766 }
2767
2768 CNode::~CNode()
2769 {
2770     CloseSocket(hSocket);
2771 }
2772
2773 void CNode::AskFor(const CInv& inv)
2774 {
2775     if (mapAskFor.size() > MAPASKFOR_MAX_SZ || setAskFor.size() > SETASKFOR_MAX_SZ)
2776         return;
2777     // a peer may not have multiple non-responded queue positions for a single inv item
2778     if (!setAskFor.insert(inv.hash).second)
2779         return;
2780
2781     // We're using mapAskFor as a priority queue,
2782     // the key is the earliest time the request can be sent
2783     int64_t nRequestTime;
2784     limitedmap<uint256, int64_t>::const_iterator it = mapAlreadyAskedFor.find(inv.hash);
2785     if (it != mapAlreadyAskedFor.end())
2786         nRequestTime = it->second;
2787     else
2788         nRequestTime = 0;
2789     LogPrint(BCLog::NET, "askfor %s  %d (%s) peer=%d\n", inv.ToString(), nRequestTime, DateTimeStrFormat("%H:%M:%S", nRequestTime/1000000), id);
2790
2791     // Make sure not to reuse time indexes to keep things in the same order
2792     int64_t nNow = GetTimeMicros() - 1000000;
2793     static int64_t nLastTime;
2794     ++nLastTime;
2795     nNow = std::max(nNow, nLastTime);
2796     nLastTime = nNow;
2797
2798     // Each retry is 2 minutes after the last
2799     nRequestTime = std::max(nRequestTime + 2 * 60 * 1000000, nNow);
2800     if (it != mapAlreadyAskedFor.end())
2801         mapAlreadyAskedFor.update(it, nRequestTime);
2802     else
2803         mapAlreadyAskedFor.insert(std::make_pair(inv.hash, nRequestTime));
2804     mapAskFor.insert(std::make_pair(nRequestTime, inv));
2805 }
2806
2807 bool CConnman::NodeFullyConnected(const CNode* pnode)
2808 {
2809     return pnode && pnode->fSuccessfullyConnected && !pnode->fDisconnect;
2810 }
2811
2812 void CConnman::PushMessage(CNode* pnode, CSerializedNetMsg&& msg)
2813 {
2814     size_t nMessageSize = msg.data.size();
2815     size_t nTotalSize = nMessageSize + CMessageHeader::HEADER_SIZE;
2816     LogPrint(BCLog::NET, "sending %s (%d bytes) peer=%d\n",  SanitizeString(msg.command.c_str()), nMessageSize, pnode->GetId());
2817
2818     std::vector<unsigned char> serializedHeader;
2819     serializedHeader.reserve(CMessageHeader::HEADER_SIZE);
2820     uint256 hash = Hash(msg.data.data(), msg.data.data() + nMessageSize);
2821     CMessageHeader hdr(Params().MessageStart(), msg.command.c_str(), nMessageSize);
2822     memcpy(hdr.pchChecksum, hash.begin(), CMessageHeader::CHECKSUM_SIZE);
2823
2824     CVectorWriter{SER_NETWORK, INIT_PROTO_VERSION, serializedHeader, 0, hdr};
2825
2826     size_t nBytesSent = 0;
2827     {
2828         LOCK(pnode->cs_vSend);
2829         bool optimisticSend(pnode->vSendMsg.empty());
2830
2831         //log total amount of bytes per command
2832         pnode->mapSendBytesPerMsgCmd[msg.command] += nTotalSize;
2833         pnode->nSendSize += nTotalSize;
2834
2835         if (pnode->nSendSize > nSendBufferMaxSize)
2836             pnode->fPauseSend = true;
2837         pnode->vSendMsg.push_back(std::move(serializedHeader));
2838         if (nMessageSize)
2839             pnode->vSendMsg.push_back(std::move(msg.data));
2840
2841         // If write queue empty, attempt "optimistic write"
2842         if (optimisticSend == true)
2843             nBytesSent = SocketSendData(pnode);
2844     }
2845     if (nBytesSent)
2846         RecordBytesSent(nBytesSent);
2847 }
2848
2849 bool CConnman::ForNode(NodeId id, std::function<bool(CNode* pnode)> func)
2850 {
2851     CNode* found = nullptr;
2852     LOCK(cs_vNodes);
2853     for (auto&& pnode : vNodes) {
2854         if(pnode->GetId() == id) {
2855             found = pnode;
2856             break;
2857         }
2858     }
2859     return found != nullptr && NodeFullyConnected(found) && func(found);
2860 }
2861
2862 int64_t PoissonNextSend(int64_t nNow, int average_interval_seconds) {
2863     return nNow + (int64_t)(log1p(GetRand(1ULL << 48) * -0.0000000000000035527136788 /* -1/2^48 */) * average_interval_seconds * -1000000.0 + 0.5);
2864 }
2865
2866 CSipHasher CConnman::GetDeterministicRandomizer(uint64_t id) const
2867 {
2868     return CSipHasher(nSeed0, nSeed1).Write(id);
2869 }
2870
2871 uint64_t CConnman::CalculateKeyedNetGroup(const CAddress& ad) const
2872 {
2873     std::vector<unsigned char> vchNetGroup(ad.GetGroup());
2874
2875     return GetDeterministicRandomizer(RANDOMIZER_ID_NETGROUP).Write(vchNetGroup.data(), vchNetGroup.size()).Finalize();
2876 }