src/net.cpp

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2014 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 "addrman.h"
  13 #include "chainparams.h"
  14 #include "clientversion.h"
  15 #include "consensus/consensus.h"
  16 #include "crypto/common.h"
  17 #include "hash.h"
  18 #include "primitives/transaction.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 #include <boost/filesystem.hpp>
  37 #include <boost/thread.hpp>
  38
  39 // Dump addresses to peers.dat every 15 minutes (900s)
  40 #define DUMP_ADDRESSES_INTERVAL 900
  41
  42 #if !defined(HAVE_MSG_NOSIGNAL) && !defined(MSG_NOSIGNAL)
  43 #define MSG_NOSIGNAL 0
  44 #endif
  45
  46 // Fix for ancient MinGW versions, that don't have defined these in ws2tcpip.h.
  47 // Todo: Can be removed when our pull-tester is upgraded to a modern MinGW version.
  48 #ifdef WIN32
  49 #ifndef PROTECTION_LEVEL_UNRESTRICTED
  50 #define PROTECTION_LEVEL_UNRESTRICTED 10
  51 #endif
  52 #ifndef IPV6_PROTECTION_LEVEL
  53 #define IPV6_PROTECTION_LEVEL 23
  54 #endif
  55 #endif
  56
  57 using namespace std;
  58
  59 namespace {
  60     const int MAX_OUTBOUND_CONNECTIONS = 8;
  61
  62     struct ListenSocket {
  63         SOCKET socket;
  64         bool whitelisted;
  65
  66         ListenSocket(SOCKET socket, bool whitelisted) : socket(socket), whitelisted(whitelisted) {}
  67     };
  68 }
  69
  70 //
  71 // Global state variables
  72 //
  73 bool fDiscover = true;
  74 bool fListen = true;
  75 uint64_t nLocalServices = NODE_NETWORK;
  76 CCriticalSection cs_mapLocalHost;
  77 map<CNetAddr, LocalServiceInfo> mapLocalHost;
  78 static bool vfReachable[NET_MAX] = {};
  79 static bool vfLimited[NET_MAX] = {};
  80 static CNode* pnodeLocalHost = NULL;
  81 uint64_t nLocalHostNonce = 0;
  82 static std::vector<ListenSocket> vhListenSocket;
  83 CAddrMan addrman;
  84 int nMaxConnections = DEFAULT_MAX_PEER_CONNECTIONS;
  85 bool fAddressesInitialized = false;
  86 std::string strSubVersion;
  87
  88 vector<CNode*> vNodes;
  89 CCriticalSection cs_vNodes;
  90 map<CInv, CDataStream> mapRelay;
  91 deque<pair<int64_t, CInv> > vRelayExpiration;
  92 CCriticalSection cs_mapRelay;
  93 limitedmap<CInv, int64_t> mapAlreadyAskedFor(MAX_INV_SZ);
  94
  95 static deque<string> vOneShots;
  96 CCriticalSection cs_vOneShots;
  97
  98 set<CNetAddr> setservAddNodeAddresses;
  99 CCriticalSection cs_setservAddNodeAddresses;
 100
 101 vector<std::string> vAddedNodes;
 102 CCriticalSection cs_vAddedNodes;
 103
 104 NodeId nLastNodeId = 0;
 105 CCriticalSection cs_nLastNodeId;
 106
 107 static CSemaphore *semOutbound = NULL;
 108 boost::condition_variable messageHandlerCondition;
 109
 110 // Signals for message handling
 111 static CNodeSignals g_signals;
 112 CNodeSignals& GetNodeSignals() { return g_signals; }
 113
 114 void AddOneShot(const std::string& strDest)
 115 {
 116     LOCK(cs_vOneShots);
 117     vOneShots.push_back(strDest);
 118 }
 119
 120 unsigned short GetListenPort()
 121 {
 122     return (unsigned short)(GetArg("-port", Params().GetDefaultPort()));
 123 }
 124
 125 // find 'best' local address for a particular peer
 126 bool GetLocal(CService& addr, const CNetAddr *paddrPeer)
 127 {
 128     if (!fListen)
 129         return false;
 130
 131     int nBestScore = -1;
 132     int nBestReachability = -1;
 133     {
 134         LOCK(cs_mapLocalHost);
 135         for (map<CNetAddr, LocalServiceInfo>::iterator it = mapLocalHost.begin(); it != mapLocalHost.end(); it++)
 136         {
 137             int nScore = (*it).second.nScore;
 138             int nReachability = (*it).first.GetReachabilityFrom(paddrPeer);
 139             if (nReachability > nBestReachability || (nReachability == nBestReachability && nScore > nBestScore))
 140             {
 141                 addr = CService((*it).first, (*it).second.nPort);
 142                 nBestReachability = nReachability;
 143                 nBestScore = nScore;
 144             }
 145         }
 146     }
 147     return nBestScore >= 0;
 148 }
 149
 150 //! Convert the pnSeeds6 array into usable address objects.
 151 static std::vector<CAddress> convertSeed6(const std::vector<SeedSpec6> &vSeedsIn)
 152 {
 153     // It'll only connect to one or two seed nodes because once it connects,
 154     // it'll get a pile of addresses with newer timestamps.
 155     // Seed nodes are given a random 'last seen time' of between one and two
 156     // weeks ago.
 157     const int64_t nOneWeek = 7*24*60*60;
 158     std::vector<CAddress> vSeedsOut;
 159     vSeedsOut.reserve(vSeedsIn.size());
 160     for (std::vector<SeedSpec6>::const_iterator i(vSeedsIn.begin()); i != vSeedsIn.end(); ++i)
 161     {
 162         struct in6_addr ip;
 163         memcpy(&ip, i->addr, sizeof(ip));
 164         CAddress addr(CService(ip, i->port));
 165         addr.nTime = GetTime() - GetRand(nOneWeek) - nOneWeek;
 166         vSeedsOut.push_back(addr);
 167     }
 168     return vSeedsOut;
 169 }
 170
 171 // get best local address for a particular peer as a CAddress
 172 // Otherwise, return the unroutable 0.0.0.0 but filled in with
 173 // the normal parameters, since the IP may be changed to a useful
 174 // one by discovery.
 175 CAddress GetLocalAddress(const CNetAddr *paddrPeer)
 176 {
 177     CAddress ret(CService("0.0.0.0",GetListenPort()),0);
 178     CService addr;
 179     if (GetLocal(addr, paddrPeer))
 180     {
 181         ret = CAddress(addr);
 182     }
 183     ret.nServices = nLocalServices;
 184     ret.nTime = GetAdjustedTime();
 185     return ret;
 186 }
 187
 188 int GetnScore(const CService& addr)
 189 {
 190     LOCK(cs_mapLocalHost);
 191     if (mapLocalHost.count(addr) == LOCAL_NONE)
 192         return 0;
 193     return mapLocalHost[addr].nScore;
 194 }
 195
 196 // Is our peer's addrLocal potentially useful as an external IP source?
 197 bool IsPeerAddrLocalGood(CNode *pnode)
 198 {
 199     return fDiscover && pnode->addr.IsRoutable() && pnode->addrLocal.IsRoutable() &&
 200            !IsLimited(pnode->addrLocal.GetNetwork());
 201 }
 202
 203 // pushes our own address to a peer
 204 void AdvertizeLocal(CNode *pnode)
 205 {
 206     if (fListen && pnode->fSuccessfullyConnected)
 207     {
 208         CAddress addrLocal = GetLocalAddress(&pnode->addr);
 209         // If discovery is enabled, sometimes give our peer the address it
 210         // tells us that it sees us as in case it has a better idea of our
 211         // address than we do.
 212         if (IsPeerAddrLocalGood(pnode) && (!addrLocal.IsRoutable() ||
 213              GetRand((GetnScore(addrLocal) > LOCAL_MANUAL) ? 8:2) == 0))
 214         {
 215             addrLocal.SetIP(pnode->addrLocal);
 216         }
 217         if (addrLocal.IsRoutable())
 218         {
 219             LogPrintf("AdvertizeLocal: advertizing address %s\n", addrLocal.ToString());
 220             pnode->PushAddress(addrLocal);
 221         }
 222     }
 223 }
 224
 225 void SetReachable(enum Network net, bool fFlag)
 226 {
 227     LOCK(cs_mapLocalHost);
 228     vfReachable[net] = fFlag;
 229     if (net == NET_IPV6 && fFlag)
 230         vfReachable[NET_IPV4] = true;
 231 }
 232
 233 // learn a new local address
 234 bool AddLocal(const CService& addr, int nScore)
 235 {
 236     if (!addr.IsRoutable())
 237         return false;
 238
 239     if (!fDiscover && nScore < LOCAL_MANUAL)
 240         return false;
 241
 242     if (IsLimited(addr))
 243         return false;
 244
 245     LogPrintf("AddLocal(%s,%i)\n", addr.ToString(), nScore);
 246
 247     {
 248         LOCK(cs_mapLocalHost);
 249         bool fAlready = mapLocalHost.count(addr) > 0;
 250         LocalServiceInfo &info = mapLocalHost[addr];
 251         if (!fAlready || nScore >= info.nScore) {
 252             info.nScore = nScore + (fAlready ? 1 : 0);
 253             info.nPort = addr.GetPort();
 254         }
 255         SetReachable(addr.GetNetwork());
 256     }
 257
 258     return true;
 259 }
 260
 261 bool AddLocal(const CNetAddr &addr, int nScore)
 262 {
 263     return AddLocal(CService(addr, GetListenPort()), nScore);
 264 }
 265
 266 bool RemoveLocal(const CService& addr)
 267 {
 268     LOCK(cs_mapLocalHost);
 269     LogPrintf("RemoveLocal(%s)\n", addr.ToString());
 270     mapLocalHost.erase(addr);
 271     return true;
 272 }
 273
 274 /** Make a particular network entirely off-limits (no automatic connects to it) */
 275 void SetLimited(enum Network net, bool fLimited)
 276 {
 277     if (net == NET_UNROUTABLE)
 278         return;
 279     LOCK(cs_mapLocalHost);
 280     vfLimited[net] = fLimited;
 281 }
 282
 283 bool IsLimited(enum Network net)
 284 {
 285     LOCK(cs_mapLocalHost);
 286     return vfLimited[net];
 287 }
 288
 289 bool IsLimited(const CNetAddr &addr)
 290 {
 291     return IsLimited(addr.GetNetwork());
 292 }
 293
 294 /** vote for a local address */
 295 bool SeenLocal(const CService& addr)
 296 {
 297     {
 298         LOCK(cs_mapLocalHost);
 299         if (mapLocalHost.count(addr) == 0)
 300             return false;
 301         mapLocalHost[addr].nScore++;
 302     }
 303     return true;
 304 }
 305
 306
 307 /** check whether a given address is potentially local */
 308 bool IsLocal(const CService& addr)
 309 {
 310     LOCK(cs_mapLocalHost);
 311     return mapLocalHost.count(addr) > 0;
 312 }
 313
 314 /** check whether a given network is one we can probably connect to */
 315 bool IsReachable(enum Network net)
 316 {
 317     LOCK(cs_mapLocalHost);
 318     return vfReachable[net] && !vfLimited[net];
 319 }
 320
 321 /** check whether a given address is in a network we can probably connect to */
 322 bool IsReachable(const CNetAddr& addr)
 323 {
 324     enum Network net = addr.GetNetwork();
 325     return IsReachable(net);
 326 }
 327
 328 void AddressCurrentlyConnected(const CService& addr)
 329 {
 330     addrman.Connected(addr);
 331 }
 332
 333
 334 uint64_t CNode::nTotalBytesRecv = 0;
 335 uint64_t CNode::nTotalBytesSent = 0;
 336 CCriticalSection CNode::cs_totalBytesRecv;
 337 CCriticalSection CNode::cs_totalBytesSent;
 338
 339 uint64_t CNode::nMaxOutboundLimit = 0;
 340 uint64_t CNode::nMaxOutboundTotalBytesSentInCycle = 0;
 341 uint64_t CNode::nMaxOutboundTimeframe = 60*60*24; //1 day
 342 uint64_t CNode::nMaxOutboundCycleStartTime = 0;
 343
 344 CNode* FindNode(const CNetAddr& ip)
 345 {
 346     LOCK(cs_vNodes);
 347     BOOST_FOREACH(CNode* pnode, vNodes)
 348         if ((CNetAddr)pnode->addr == ip)
 349             return (pnode);
 350     return NULL;
 351 }
 352
 353 CNode* FindNode(const CSubNet& subNet)
 354 {
 355     LOCK(cs_vNodes);
 356     BOOST_FOREACH(CNode* pnode, vNodes)
 357     if (subNet.Match((CNetAddr)pnode->addr))
 358         return (pnode);
 359     return NULL;
 360 }
 361
 362 CNode* FindNode(const std::string& addrName)
 363 {
 364     LOCK(cs_vNodes);
 365     BOOST_FOREACH(CNode* pnode, vNodes)
 366         if (pnode->addrName == addrName)
 367             return (pnode);
 368     return NULL;
 369 }
 370
 371 CNode* FindNode(const CService& addr)
 372 {
 373     LOCK(cs_vNodes);
 374     BOOST_FOREACH(CNode* pnode, vNodes)
 375         if ((CService)pnode->addr == addr)
 376             return (pnode);
 377     return NULL;
 378 }
 379
 380 CNode* ConnectNode(CAddress addrConnect, const char *pszDest)
 381 {
 382     if (pszDest == NULL) {
 383         if (IsLocal(addrConnect))
 384             return NULL;
 385
 386         // Look for an existing connection
 387         CNode* pnode = FindNode((CService)addrConnect);
 388         if (pnode)
 389         {
 390             pnode->AddRef();
 391             return pnode;
 392         }
 393     }
 394
 395     /// debug print
 396     LogPrint("net", "trying connection %s lastseen=%.1fhrs\n",
 397         pszDest ? pszDest : addrConnect.ToString(),
 398         pszDest ? 0.0 : (double)(GetAdjustedTime() - addrConnect.nTime)/3600.0);
 399
 400     // Connect
 401     SOCKET hSocket;
 402     bool proxyConnectionFailed = false;
 403     if (pszDest ? ConnectSocketByName(addrConnect, hSocket, pszDest, Params().GetDefaultPort(), nConnectTimeout, &proxyConnectionFailed) :
 404                   ConnectSocket(addrConnect, hSocket, nConnectTimeout, &proxyConnectionFailed))
 405     {
 406         if (!IsSelectableSocket(hSocket)) {
 407             LogPrintf("Cannot create connection: non-selectable socket created (fd >= FD_SETSIZE ?)\n");
 408             CloseSocket(hSocket);
 409             return NULL;
 410         }
 411
 412         addrman.Attempt(addrConnect);
 413
 414         // Add node
 415         CNode* pnode = new CNode(hSocket, addrConnect, pszDest ? pszDest : "", false);
 416         pnode->AddRef();
 417
 418         {
 419             LOCK(cs_vNodes);
 420             vNodes.push_back(pnode);
 421         }
 422
 423         pnode->nTimeConnected = GetTime();
 424
 425         return pnode;
 426     } else if (!proxyConnectionFailed) {
 427         // If connecting to the node failed, and failure is not caused by a problem connecting to
 428         // the proxy, mark this as an attempt.
 429         addrman.Attempt(addrConnect);
 430     }
 431
 432     return NULL;
 433 }
 434
 435 void CNode::CloseSocketDisconnect()
 436 {
 437     fDisconnect = true;
 438     if (hSocket != INVALID_SOCKET)
 439     {
 440         LogPrint("net", "disconnecting peer=%d\n", id);
 441         CloseSocket(hSocket);
 442     }
 443
 444     // in case this fails, we'll empty the recv buffer when the CNode is deleted
 445     TRY_LOCK(cs_vRecvMsg, lockRecv);
 446     if (lockRecv)
 447         vRecvMsg.clear();
 448 }
 449
 450 void CNode::PushVersion()
 451 {
 452     int nBestHeight = g_signals.GetHeight().get_value_or(0);
 453
 454     int64_t nTime = (fInbound ? GetAdjustedTime() : GetTime());
 455     CAddress addrYou = (addr.IsRoutable() && !IsProxy(addr) ? addr : CAddress(CService("0.0.0.0",0)));
 456     CAddress addrMe = GetLocalAddress(&addr);
 457     GetRandBytes((unsigned char*)&nLocalHostNonce, sizeof(nLocalHostNonce));
 458     if (fLogIPs)
 459         LogPrint("net", "send version message: version %d, blocks=%d, us=%s, them=%s, peer=%d\n", PROTOCOL_VERSION, nBestHeight, addrMe.ToString(), addrYou.ToString(), id);
 460     else
 461         LogPrint("net", "send version message: version %d, blocks=%d, us=%s, peer=%d\n", PROTOCOL_VERSION, nBestHeight, addrMe.ToString(), id);
 462     PushMessage("version", PROTOCOL_VERSION, nLocalServices, nTime, addrYou, addrMe,
 463                 nLocalHostNonce, strSubVersion, nBestHeight, !GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY));
 464 }
 465
 466
 467
 468
 469
 470 banmap_t CNode::setBanned;
 471 CCriticalSection CNode::cs_setBanned;
 472 bool CNode::setBannedIsDirty;
 473
 474 void CNode::ClearBanned()
 475 {
 476     LOCK(cs_setBanned);
 477     setBanned.clear();
 478     setBannedIsDirty = true;
 479 }
 480
 481 bool CNode::IsBanned(CNetAddr ip)
 482 {
 483     bool fResult = false;
 484     {
 485         LOCK(cs_setBanned);
 486         for (banmap_t::iterator it = setBanned.begin(); it != setBanned.end(); it++)
 487         {
 488             CSubNet subNet = (*it).first;
 489             CBanEntry banEntry = (*it).second;
 490
 491             if(subNet.Match(ip) && GetTime() < banEntry.nBanUntil)
 492                 fResult = true;
 493         }
 494     }
 495     return fResult;
 496 }
 497
 498 bool CNode::IsBanned(CSubNet subnet)
 499 {
 500     bool fResult = false;
 501     {
 502         LOCK(cs_setBanned);
 503         banmap_t::iterator i = setBanned.find(subnet);
 504         if (i != setBanned.end())
 505         {
 506             CBanEntry banEntry = (*i).second;
 507             if (GetTime() < banEntry.nBanUntil)
 508                 fResult = true;
 509         }
 510     }
 511     return fResult;
 512 }
 513
 514 void CNode::Ban(const CNetAddr& addr, const BanReason &banReason, int64_t bantimeoffset, bool sinceUnixEpoch) {
 515     CSubNet subNet(addr);
 516     Ban(subNet, banReason, bantimeoffset, sinceUnixEpoch);
 517 }
 518
 519 void CNode::Ban(const CSubNet& subNet, const BanReason &banReason, int64_t bantimeoffset, bool sinceUnixEpoch) {
 520     CBanEntry banEntry(GetTime());
 521     banEntry.banReason = banReason;
 522     if (bantimeoffset <= 0)
 523     {
 524         bantimeoffset = GetArg("-bantime", 60*60*24); // Default 24-hour ban
 525         sinceUnixEpoch = false;
 526     }
 527     banEntry.nBanUntil = (sinceUnixEpoch ? 0 : GetTime() )+bantimeoffset;
 528
 529
 530     LOCK(cs_setBanned);
 531     if (setBanned[subNet].nBanUntil < banEntry.nBanUntil)
 532         setBanned[subNet] = banEntry;
 533
 534     setBannedIsDirty = true;
 535 }
 536
 537 bool CNode::Unban(const CNetAddr &addr) {
 538     CSubNet subNet(addr);
 539     return Unban(subNet);
 540 }
 541
 542 bool CNode::Unban(const CSubNet &subNet) {
 543     LOCK(cs_setBanned);
 544     if (setBanned.erase(subNet))
 545     {
 546         setBannedIsDirty = true;
 547         return true;
 548     }
 549     return false;
 550 }
 551
 552 void CNode::GetBanned(banmap_t &banMap)
 553 {
 554     LOCK(cs_setBanned);
 555     banMap = setBanned; //create a thread safe copy
 556 }
 557
 558 void CNode::SetBanned(const banmap_t &banMap)
 559 {
 560     LOCK(cs_setBanned);
 561     setBanned = banMap;
 562     setBannedIsDirty = true;
 563 }
 564
 565 void CNode::SweepBanned()
 566 {
 567     int64_t now = GetTime();
 568
 569     LOCK(cs_setBanned);
 570     banmap_t::iterator it = setBanned.begin();
 571     while(it != setBanned.end())
 572     {
 573         CBanEntry banEntry = (*it).second;
 574         if(now > banEntry.nBanUntil)
 575         {
 576             setBanned.erase(it++);
 577             setBannedIsDirty = true;
 578         }
 579         else
 580             ++it;
 581     }
 582 }
 583
 584 bool CNode::BannedSetIsDirty()
 585 {
 586     LOCK(cs_setBanned);
 587     return setBannedIsDirty;
 588 }
 589
 590 void CNode::SetBannedSetDirty(bool dirty)
 591 {
 592     LOCK(cs_setBanned); //reuse setBanned lock for the isDirty flag
 593     setBannedIsDirty = dirty;
 594 }
 595
 596
 597 std::vector<CSubNet> CNode::vWhitelistedRange;
 598 CCriticalSection CNode::cs_vWhitelistedRange;
 599
 600 bool CNode::IsWhitelistedRange(const CNetAddr &addr) {
 601     LOCK(cs_vWhitelistedRange);
 602     BOOST_FOREACH(const CSubNet& subnet, vWhitelistedRange) {
 603         if (subnet.Match(addr))
 604             return true;
 605     }
 606     return false;
 607 }
 608
 609 void CNode::AddWhitelistedRange(const CSubNet &subnet) {
 610     LOCK(cs_vWhitelistedRange);
 611     vWhitelistedRange.push_back(subnet);
 612 }
 613
 614 #undef X
 615 #define X(name) stats.name = name
 616 void CNode::copyStats(CNodeStats &stats)
 617 {
 618     stats.nodeid = this->GetId();
 619     X(nServices);
 620     X(nLastSend);
 621     X(nLastRecv);
 622     X(nTimeConnected);
 623     X(nTimeOffset);
 624     X(addrName);
 625     X(nVersion);
 626     X(cleanSubVer);
 627     X(fInbound);
 628     X(nStartingHeight);
 629     X(nSendBytes);
 630     X(nRecvBytes);
 631     X(fWhitelisted);
 632
 633     // It is common for nodes with good ping times to suddenly become lagged,
 634     // due to a new block arriving or other large transfer.
 635     // Merely reporting pingtime might fool the caller into thinking the node was still responsive,
 636     // since pingtime does not update until the ping is complete, which might take a while.
 637     // So, if a ping is taking an unusually long time in flight,
 638     // the caller can immediately detect that this is happening.
 639     int64_t nPingUsecWait = 0;
 640     if ((0 != nPingNonceSent) && (0 != nPingUsecStart)) {
 641         nPingUsecWait = GetTimeMicros() - nPingUsecStart;
 642     }
 643
 644     // 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 :)
 645     stats.dPingTime = (((double)nPingUsecTime) / 1e6);
 646     stats.dPingMin  = (((double)nMinPingUsecTime) / 1e6);
 647     stats.dPingWait = (((double)nPingUsecWait) / 1e6);
 648
 649     // Leave string empty if addrLocal invalid (not filled in yet)
 650     stats.addrLocal = addrLocal.IsValid() ? addrLocal.ToString() : "";
 651 }
 652 #undef X
 653
 654 // requires LOCK(cs_vRecvMsg)
 655 bool CNode::ReceiveMsgBytes(const char *pch, unsigned int nBytes)
 656 {
 657     while (nBytes > 0) {
 658
 659         // get current incomplete message, or create a new one
 660         if (vRecvMsg.empty() ||
 661             vRecvMsg.back().complete())
 662             vRecvMsg.push_back(CNetMessage(Params().MessageStart(), SER_NETWORK, nRecvVersion));
 663
 664         CNetMessage& msg = vRecvMsg.back();
 665
 666         // absorb network data
 667         int handled;
 668         if (!msg.in_data)
 669             handled = msg.readHeader(pch, nBytes);
 670         else
 671             handled = msg.readData(pch, nBytes);
 672
 673         if (handled < 0)
 674                 return false;
 675
 676         if (msg.in_data && msg.hdr.nMessageSize > MAX_PROTOCOL_MESSAGE_LENGTH) {
 677             LogPrint("net", "Oversized message from peer=%i, disconnecting\n", GetId());
 678             return false;
 679         }
 680
 681         pch += handled;
 682         nBytes -= handled;
 683
 684         if (msg.complete()) {
 685             msg.nTime = GetTimeMicros();
 686             messageHandlerCondition.notify_one();
 687         }
 688     }
 689
 690     return true;
 691 }
 692
 693 int CNetMessage::readHeader(const char *pch, unsigned int nBytes)
 694 {
 695     // copy data to temporary parsing buffer
 696     unsigned int nRemaining = 24 - nHdrPos;
 697     unsigned int nCopy = std::min(nRemaining, nBytes);
 698
 699     memcpy(&hdrbuf[nHdrPos], pch, nCopy);
 700     nHdrPos += nCopy;
 701
 702     // if header incomplete, exit
 703     if (nHdrPos < 24)
 704         return nCopy;
 705
 706     // deserialize to CMessageHeader
 707     try {
 708         hdrbuf >> hdr;
 709     }
 710     catch (const std::exception&) {
 711         return -1;
 712     }
 713
 714     // reject messages larger than MAX_SIZE
 715     if (hdr.nMessageSize > MAX_SIZE)
 716             return -1;
 717
 718     // switch state to reading message data
 719     in_data = true;
 720
 721     return nCopy;
 722 }
 723
 724 int CNetMessage::readData(const char *pch, unsigned int nBytes)
 725 {
 726     unsigned int nRemaining = hdr.nMessageSize - nDataPos;
 727     unsigned int nCopy = std::min(nRemaining, nBytes);
 728
 729     if (vRecv.size() < nDataPos + nCopy) {
 730         // Allocate up to 256 KiB ahead, but never more than the total message size.
 731         vRecv.resize(std::min(hdr.nMessageSize, nDataPos + nCopy + 256 * 1024));
 732     }
 733
 734     memcpy(&vRecv[nDataPos], pch, nCopy);
 735     nDataPos += nCopy;
 736
 737     return nCopy;
 738 }
 739
 740
 741
 742
 743
 744
 745
 746
 747
 748 // requires LOCK(cs_vSend)
 749 void SocketSendData(CNode *pnode)
 750 {
 751     std::deque<CSerializeData>::iterator it = pnode->vSendMsg.begin();
 752
 753     while (it != pnode->vSendMsg.end()) {
 754         const CSerializeData &data = *it;
 755         assert(data.size() > pnode->nSendOffset);
 756         int nBytes = send(pnode->hSocket, &data[pnode->nSendOffset], data.size() - pnode->nSendOffset, MSG_NOSIGNAL | MSG_DONTWAIT);
 757         if (nBytes > 0) {
 758             pnode->nLastSend = GetTime();
 759             pnode->nSendBytes += nBytes;
 760             pnode->nSendOffset += nBytes;
 761             pnode->RecordBytesSent(nBytes);
 762             if (pnode->nSendOffset == data.size()) {
 763                 pnode->nSendOffset = 0;
 764                 pnode->nSendSize -= data.size();
 765                 it++;
 766             } else {
 767                 // could not send full message; stop sending more
 768                 break;
 769             }
 770         } else {
 771             if (nBytes < 0) {
 772                 // error
 773                 int nErr = WSAGetLastError();
 774                 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
 775                 {
 776                     LogPrintf("socket send error %s\n", NetworkErrorString(nErr));
 777                     pnode->CloseSocketDisconnect();
 778                 }
 779             }
 780             // couldn't send anything at all
 781             break;
 782         }
 783     }
 784
 785     if (it == pnode->vSendMsg.end()) {
 786         assert(pnode->nSendOffset == 0);
 787         assert(pnode->nSendSize == 0);
 788     }
 789     pnode->vSendMsg.erase(pnode->vSendMsg.begin(), it);
 790 }
 791
 792 static list<CNode*> vNodesDisconnected;
 793
 794 class CNodeRef {
 795 public:
 796     CNodeRef(CNode *pnode) : _pnode(pnode) {
 797         LOCK(cs_vNodes);
 798         _pnode->AddRef();
 799     }
 800
 801     ~CNodeRef() {
 802         LOCK(cs_vNodes);
 803         _pnode->Release();
 804     }
 805
 806     CNode& operator *() const {return *_pnode;};
 807     CNode* operator ->() const {return _pnode;};
 808
 809     CNodeRef& operator =(const CNodeRef& other)
 810     {
 811         if (this != &other) {
 812             LOCK(cs_vNodes);
 813
 814             _pnode->Release();
 815             _pnode = other._pnode;
 816             _pnode->AddRef();
 817         }
 818         return *this;
 819     }
 820
 821     CNodeRef(const CNodeRef& other):
 822         _pnode(other._pnode)
 823     {
 824         LOCK(cs_vNodes);
 825         _pnode->AddRef();
 826     }
 827 private:
 828     CNode *_pnode;
 829 };
 830
 831 static bool ReverseCompareNodeMinPingTime(const CNodeRef &a, const CNodeRef &b)
 832 {
 833     return a->nMinPingUsecTime > b->nMinPingUsecTime;
 834 }
 835
 836 static bool ReverseCompareNodeTimeConnected(const CNodeRef &a, const CNodeRef &b)
 837 {
 838     return a->nTimeConnected > b->nTimeConnected;
 839 }
 840
 841 class CompareNetGroupKeyed
 842 {
 843     std::vector<unsigned char> vchSecretKey;
 844 public:
 845     CompareNetGroupKeyed()
 846     {
 847         vchSecretKey.resize(32, 0);
 848         GetRandBytes(vchSecretKey.data(), vchSecretKey.size());
 849     }
 850
 851     bool operator()(const CNodeRef &a, const CNodeRef &b)
 852     {
 853         std::vector<unsigned char> vchGroupA, vchGroupB;
 854         CSHA256 hashA, hashB;
 855         std::vector<unsigned char> vchA(32), vchB(32);
 856
 857         vchGroupA = a->addr.GetGroup();
 858         vchGroupB = b->addr.GetGroup();
 859
 860         hashA.Write(begin_ptr(vchGroupA), vchGroupA.size());
 861         hashB.Write(begin_ptr(vchGroupB), vchGroupB.size());
 862
 863         hashA.Write(begin_ptr(vchSecretKey), vchSecretKey.size());
 864         hashB.Write(begin_ptr(vchSecretKey), vchSecretKey.size());
 865
 866         hashA.Finalize(begin_ptr(vchA));
 867         hashB.Finalize(begin_ptr(vchB));
 868
 869         return vchA < vchB;
 870     }
 871 };
 872
 873 static bool AttemptToEvictConnection(bool fPreferNewConnection) {
 874     std::vector<CNodeRef> vEvictionCandidates;
 875     {
 876         LOCK(cs_vNodes);
 877
 878         BOOST_FOREACH(CNode *node, vNodes) {
 879             if (node->fWhitelisted)
 880                 continue;
 881             if (!node->fInbound)
 882                 continue;
 883             if (node->fDisconnect)
 884                 continue;
 885             if (node->addr.IsLocal())
 886                 continue;
 887             vEvictionCandidates.push_back(CNodeRef(node));
 888         }
 889     }
 890
 891     if (vEvictionCandidates.empty()) return false;
 892
 893     // Protect connections with certain characteristics
 894
 895     // Deterministically select 4 peers to protect by netgroup.
 896     // An attacker cannot predict which netgroups will be protected.
 897     static CompareNetGroupKeyed comparerNetGroupKeyed;
 898     std::sort(vEvictionCandidates.begin(), vEvictionCandidates.end(), comparerNetGroupKeyed);
 899     vEvictionCandidates.erase(vEvictionCandidates.end() - std::min(4, static_cast<int>(vEvictionCandidates.size())), vEvictionCandidates.end());
 900
 901     if (vEvictionCandidates.empty()) return false;
 902
 903     // Protect the 8 nodes with the best ping times.
 904     // An attacker cannot manipulate this metric without physically moving nodes closer to the target.
 905     std::sort(vEvictionCandidates.begin(), vEvictionCandidates.end(), ReverseCompareNodeMinPingTime);
 906     vEvictionCandidates.erase(vEvictionCandidates.end() - std::min(8, static_cast<int>(vEvictionCandidates.size())), vEvictionCandidates.end());
 907
 908     if (vEvictionCandidates.empty()) return false;
 909
 910     // Protect the half of the remaining nodes which have been connected the longest.
 911     // This replicates the existing implicit behavior.
 912     std::sort(vEvictionCandidates.begin(), vEvictionCandidates.end(), ReverseCompareNodeTimeConnected);
 913     vEvictionCandidates.erase(vEvictionCandidates.end() - static_cast<int>(vEvictionCandidates.size() / 2), vEvictionCandidates.end());
 914
 915     if (vEvictionCandidates.empty()) return false;
 916
 917     // Identify the network group with the most connections
 918     std::vector<unsigned char> naMostConnections;
 919     unsigned int nMostConnections = 0;
 920     std::map<std::vector<unsigned char>, std::vector<CNodeRef> > mapAddrCounts;
 921     BOOST_FOREACH(const CNodeRef &node, vEvictionCandidates) {
 922         mapAddrCounts[node->addr.GetGroup()].push_back(node);
 923
 924         if (mapAddrCounts[node->addr.GetGroup()].size() > nMostConnections) {
 925             nMostConnections = mapAddrCounts[node->addr.GetGroup()].size();
 926             naMostConnections = node->addr.GetGroup();
 927         }
 928     }
 929
 930     // Reduce to the network group with the most connections
 931     vEvictionCandidates = mapAddrCounts[naMostConnections];
 932
 933     // Do not disconnect peers if there is only 1 connection from their network group
 934     if (vEvictionCandidates.size() <= 1)
 935         // unless we prefer the new connection (for whitelisted peers)
 936         if (!fPreferNewConnection)
 937             return false;
 938
 939     // Disconnect the most recent connection from the network group with the most connections
 940     std::sort(vEvictionCandidates.begin(), vEvictionCandidates.end(), ReverseCompareNodeTimeConnected);
 941     vEvictionCandidates[0]->fDisconnect = true;
 942
 943     return true;
 944 }
 945
 946 static void AcceptConnection(const ListenSocket& hListenSocket) {
 947     struct sockaddr_storage sockaddr;
 948     socklen_t len = sizeof(sockaddr);
 949     SOCKET hSocket = accept(hListenSocket.socket, (struct sockaddr*)&sockaddr, &len);
 950     CAddress addr;
 951     int nInbound = 0;
 952     int nMaxInbound = nMaxConnections - MAX_OUTBOUND_CONNECTIONS;
 953
 954     if (hSocket != INVALID_SOCKET)
 955         if (!addr.SetSockAddr((const struct sockaddr*)&sockaddr))
 956             LogPrintf("Warning: Unknown socket family\n");
 957
 958     bool whitelisted = hListenSocket.whitelisted || CNode::IsWhitelistedRange(addr);
 959     {
 960         LOCK(cs_vNodes);
 961         BOOST_FOREACH(CNode* pnode, vNodes)
 962             if (pnode->fInbound)
 963                 nInbound++;
 964     }
 965
 966     if (hSocket == INVALID_SOCKET)
 967     {
 968         int nErr = WSAGetLastError();
 969         if (nErr != WSAEWOULDBLOCK)
 970             LogPrintf("socket error accept failed: %s\n", NetworkErrorString(nErr));
 971         return;
 972     }
 973
 974     if (!IsSelectableSocket(hSocket))
 975     {
 976         LogPrintf("connection from %s dropped: non-selectable socket\n", addr.ToString());
 977         CloseSocket(hSocket);
 978         return;
 979     }
 980
 981     // According to the internet TCP_NODELAY is not carried into accepted sockets
 982     // on all platforms.  Set it again here just to be sure.
 983     int set = 1;
 984 #ifdef WIN32
 985     setsockopt(hSocket, IPPROTO_TCP, TCP_NODELAY, (const char*)&set, sizeof(int));
 986 #else
 987     setsockopt(hSocket, IPPROTO_TCP, TCP_NODELAY, (void*)&set, sizeof(int));
 988 #endif
 989
 990     if (CNode::IsBanned(addr) && !whitelisted)
 991     {
 992         LogPrintf("connection from %s dropped (banned)\n", addr.ToString());
 993         CloseSocket(hSocket);
 994         return;
 995     }
 996
 997     if (nInbound >= nMaxInbound)
 998     {
 999         if (!AttemptToEvictConnection(whitelisted)) {
1000             // No connection to evict, disconnect the new connection
1001             LogPrint("net", "failed to find an eviction candidate - connection dropped (full)\n");
1002             CloseSocket(hSocket);
1003             return;
1004         }
1005     }
1006
1007     CNode* pnode = new CNode(hSocket, addr, "", true);
1008     pnode->AddRef();
1009     pnode->fWhitelisted = whitelisted;
1010
1011     LogPrint("net", "connection from %s accepted\n", addr.ToString());
1012
1013     {
1014         LOCK(cs_vNodes);
1015         vNodes.push_back(pnode);
1016     }
1017 }
1018
1019 void ThreadSocketHandler()
1020 {
1021     unsigned int nPrevNodeCount = 0;
1022     while (true)
1023     {
1024         //
1025         // Disconnect nodes
1026         //
1027         {
1028             LOCK(cs_vNodes);
1029             // Disconnect unused nodes
1030             vector<CNode*> vNodesCopy = vNodes;
1031             BOOST_FOREACH(CNode* pnode, vNodesCopy)
1032             {
1033                 if (pnode->fDisconnect ||
1034                     (pnode->GetRefCount() <= 0 && pnode->vRecvMsg.empty() && pnode->nSendSize == 0 && pnode->ssSend.empty()))
1035                 {
1036                     // remove from vNodes
1037                     vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end());
1038
1039                     // release outbound grant (if any)
1040                     pnode->grantOutbound.Release();
1041
1042                     // close socket and cleanup
1043                     pnode->CloseSocketDisconnect();
1044
1045                     // hold in disconnected pool until all refs are released
1046                     if (pnode->fNetworkNode || pnode->fInbound)
1047                         pnode->Release();
1048                     vNodesDisconnected.push_back(pnode);
1049                 }
1050             }
1051         }
1052         {
1053             // Delete disconnected nodes
1054             list<CNode*> vNodesDisconnectedCopy = vNodesDisconnected;
1055             BOOST_FOREACH(CNode* pnode, vNodesDisconnectedCopy)
1056             {
1057                 // wait until threads are done using it
1058                 if (pnode->GetRefCount() <= 0)
1059                 {
1060                     bool fDelete = false;
1061                     {
1062                         TRY_LOCK(pnode->cs_vSend, lockSend);
1063                         if (lockSend)
1064                         {
1065                             TRY_LOCK(pnode->cs_vRecvMsg, lockRecv);
1066                             if (lockRecv)
1067                             {
1068                                 TRY_LOCK(pnode->cs_inventory, lockInv);
1069                                 if (lockInv)
1070                                     fDelete = true;
1071                             }
1072                         }
1073                     }
1074                     if (fDelete)
1075                     {
1076                         vNodesDisconnected.remove(pnode);
1077                         delete pnode;
1078                     }
1079                 }
1080             }
1081         }
1082         if(vNodes.size() != nPrevNodeCount) {
1083             nPrevNodeCount = vNodes.size();
1084             uiInterface.NotifyNumConnectionsChanged(nPrevNodeCount);
1085         }
1086
1087         //
1088         // Find which sockets have data to receive
1089         //
1090         struct timeval timeout;
1091         timeout.tv_sec  = 0;
1092         timeout.tv_usec = 50000; // frequency to poll pnode->vSend
1093
1094         fd_set fdsetRecv;
1095         fd_set fdsetSend;
1096         fd_set fdsetError;
1097         FD_ZERO(&fdsetRecv);
1098         FD_ZERO(&fdsetSend);
1099         FD_ZERO(&fdsetError);
1100         SOCKET hSocketMax = 0;
1101         bool have_fds = false;
1102
1103         BOOST_FOREACH(const ListenSocket& hListenSocket, vhListenSocket) {
1104             FD_SET(hListenSocket.socket, &fdsetRecv);
1105             hSocketMax = max(hSocketMax, hListenSocket.socket);
1106             have_fds = true;
1107         }
1108
1109         {
1110             LOCK(cs_vNodes);
1111             BOOST_FOREACH(CNode* pnode, vNodes)
1112             {
1113                 if (pnode->hSocket == INVALID_SOCKET)
1114                     continue;
1115                 FD_SET(pnode->hSocket, &fdsetError);
1116                 hSocketMax = max(hSocketMax, pnode->hSocket);
1117                 have_fds = true;
1118
1119                 // Implement the following logic:
1120                 // * If there is data to send, select() for sending data. As this only
1121                 //   happens when optimistic write failed, we choose to first drain the
1122                 //   write buffer in this case before receiving more. This avoids
1123                 //   needlessly queueing received data, if the remote peer is not themselves
1124                 //   receiving data. This means properly utilizing TCP flow control signalling.
1125                 // * Otherwise, if there is no (complete) message in the receive buffer,
1126                 //   or there is space left in the buffer, select() for receiving data.
1127                 // * (if neither of the above applies, there is certainly one message
1128                 //   in the receiver buffer ready to be processed).
1129                 // Together, that means that at least one of the following is always possible,
1130                 // so we don't deadlock:
1131                 // * We send some data.
1132                 // * We wait for data to be received (and disconnect after timeout).
1133                 // * We process a message in the buffer (message handler thread).
1134                 {
1135                     TRY_LOCK(pnode->cs_vSend, lockSend);
1136                     if (lockSend && !pnode->vSendMsg.empty()) {
1137                         FD_SET(pnode->hSocket, &fdsetSend);
1138                         continue;
1139                     }
1140                 }
1141                 {
1142                     TRY_LOCK(pnode->cs_vRecvMsg, lockRecv);
1143                     if (lockRecv && (
1144                         pnode->vRecvMsg.empty() || !pnode->vRecvMsg.front().complete() ||
1145                         pnode->GetTotalRecvSize() <= ReceiveFloodSize()))
1146                         FD_SET(pnode->hSocket, &fdsetRecv);
1147                 }
1148             }
1149         }
1150
1151         int nSelect = select(have_fds ? hSocketMax + 1 : 0,
1152                              &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
1153         boost::this_thread::interruption_point();
1154
1155         if (nSelect == SOCKET_ERROR)
1156         {
1157             if (have_fds)
1158             {
1159                 int nErr = WSAGetLastError();
1160                 LogPrintf("socket select error %s\n", NetworkErrorString(nErr));
1161                 for (unsigned int i = 0; i <= hSocketMax; i++)
1162                     FD_SET(i, &fdsetRecv);
1163             }
1164             FD_ZERO(&fdsetSend);
1165             FD_ZERO(&fdsetError);
1166             MilliSleep(timeout.tv_usec/1000);
1167         }
1168
1169         //
1170         // Accept new connections
1171         //
1172         BOOST_FOREACH(const ListenSocket& hListenSocket, vhListenSocket)
1173         {
1174             if (hListenSocket.socket != INVALID_SOCKET && FD_ISSET(hListenSocket.socket, &fdsetRecv))
1175             {
1176                 AcceptConnection(hListenSocket);
1177             }
1178         }
1179
1180         //
1181         // Service each socket
1182         //
1183         vector<CNode*> vNodesCopy;
1184         {
1185             LOCK(cs_vNodes);
1186             vNodesCopy = vNodes;
1187             BOOST_FOREACH(CNode* pnode, vNodesCopy)
1188                 pnode->AddRef();
1189         }
1190         BOOST_FOREACH(CNode* pnode, vNodesCopy)
1191         {
1192             boost::this_thread::interruption_point();
1193
1194             //
1195             // Receive
1196             //
1197             if (pnode->hSocket == INVALID_SOCKET)
1198                 continue;
1199             if (FD_ISSET(pnode->hSocket, &fdsetRecv) || FD_ISSET(pnode->hSocket, &fdsetError))
1200             {
1201                 TRY_LOCK(pnode->cs_vRecvMsg, lockRecv);
1202                 if (lockRecv)
1203                 {
1204                     {
1205                         // typical socket buffer is 8K-64K
1206                         char pchBuf[0x10000];
1207                         int nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
1208                         if (nBytes > 0)
1209                         {
1210                             if (!pnode->ReceiveMsgBytes(pchBuf, nBytes))
1211                                 pnode->CloseSocketDisconnect();
1212                             pnode->nLastRecv = GetTime();
1213                             pnode->nRecvBytes += nBytes;
1214                             pnode->RecordBytesRecv(nBytes);
1215                         }
1216                         else if (nBytes == 0)
1217                         {
1218                             // socket closed gracefully
1219                             if (!pnode->fDisconnect)
1220                                 LogPrint("net", "socket closed\n");
1221                             pnode->CloseSocketDisconnect();
1222                         }
1223                         else if (nBytes < 0)
1224                         {
1225                             // error
1226                             int nErr = WSAGetLastError();
1227                             if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
1228                             {
1229                                 if (!pnode->fDisconnect)
1230                                     LogPrintf("socket recv error %s\n", NetworkErrorString(nErr));
1231                                 pnode->CloseSocketDisconnect();
1232                             }
1233                         }
1234                     }
1235                 }
1236             }
1237
1238             //
1239             // Send
1240             //
1241             if (pnode->hSocket == INVALID_SOCKET)
1242                 continue;
1243             if (FD_ISSET(pnode->hSocket, &fdsetSend))
1244             {
1245                 TRY_LOCK(pnode->cs_vSend, lockSend);
1246                 if (lockSend)
1247                     SocketSendData(pnode);
1248             }
1249
1250             //
1251             // Inactivity checking
1252             //
1253             int64_t nTime = GetTime();
1254             if (nTime - pnode->nTimeConnected > 60)
1255             {
1256                 if (pnode->nLastRecv == 0 || pnode->nLastSend == 0)
1257                 {
1258                     LogPrint("net", "socket no message in first 60 seconds, %d %d from %d\n", pnode->nLastRecv != 0, pnode->nLastSend != 0, pnode->id);
1259                     pnode->fDisconnect = true;
1260                 }
1261                 else if (nTime - pnode->nLastSend > TIMEOUT_INTERVAL)
1262                 {
1263                     LogPrintf("socket sending timeout: %is\n", nTime - pnode->nLastSend);
1264                     pnode->fDisconnect = true;
1265                 }
1266                 else if (nTime - pnode->nLastRecv > (pnode->nVersion > BIP0031_VERSION ? TIMEOUT_INTERVAL : 90*60))
1267                 {
1268                     LogPrintf("socket receive timeout: %is\n", nTime - pnode->nLastRecv);
1269                     pnode->fDisconnect = true;
1270                 }
1271                 else if (pnode->nPingNonceSent && pnode->nPingUsecStart + TIMEOUT_INTERVAL * 1000000 < GetTimeMicros())
1272                 {
1273                     LogPrintf("ping timeout: %fs\n", 0.000001 * (GetTimeMicros() - pnode->nPingUsecStart));
1274                     pnode->fDisconnect = true;
1275                 }
1276             }
1277         }
1278         {
1279             LOCK(cs_vNodes);
1280             BOOST_FOREACH(CNode* pnode, vNodesCopy)
1281                 pnode->Release();
1282         }
1283     }
1284 }
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294 #ifdef USE_UPNP
1295 void ThreadMapPort()
1296 {
1297     std::string port = strprintf("%u", GetListenPort());
1298     const char * multicastif = 0;
1299     const char * minissdpdpath = 0;
1300     struct UPNPDev * devlist = 0;
1301     char lanaddr[64];
1302
1303 #ifndef UPNPDISCOVER_SUCCESS
1304     /* miniupnpc 1.5 */
1305     devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0);
1306 #elif MINIUPNPC_API_VERSION < 14
1307     /* miniupnpc 1.6 */
1308     int error = 0;
1309     devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, &error);
1310 #else
1311     /* miniupnpc 1.9.20150730 */
1312     int error = 0;
1313     devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, 2, &error);
1314 #endif
1315
1316     struct UPNPUrls urls;
1317     struct IGDdatas data;
1318     int r;
1319
1320     r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
1321     if (r == 1)
1322     {
1323         if (fDiscover) {
1324             char externalIPAddress[40];
1325             r = UPNP_GetExternalIPAddress(urls.controlURL, data.first.servicetype, externalIPAddress);
1326             if(r != UPNPCOMMAND_SUCCESS)
1327                 LogPrintf("UPnP: GetExternalIPAddress() returned %d\n", r);
1328             else
1329             {
1330                 if(externalIPAddress[0])
1331                 {
1332                     LogPrintf("UPnP: ExternalIPAddress = %s\n", externalIPAddress);
1333                     AddLocal(CNetAddr(externalIPAddress), LOCAL_UPNP);
1334                 }
1335                 else
1336                     LogPrintf("UPnP: GetExternalIPAddress failed.\n");
1337             }
1338         }
1339
1340         string strDesc = "Bitcoin " + FormatFullVersion();
1341
1342         try {
1343             while (true) {
1344 #ifndef UPNPDISCOVER_SUCCESS
1345                 /* miniupnpc 1.5 */
1346                 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1347                                     port.c_str(), port.c_str(), lanaddr, strDesc.c_str(), "TCP", 0);
1348 #else
1349                 /* miniupnpc 1.6 */
1350                 r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
1351                                     port.c_str(), port.c_str(), lanaddr, strDesc.c_str(), "TCP", 0, "0");
1352 #endif
1353
1354                 if(r!=UPNPCOMMAND_SUCCESS)
1355                     LogPrintf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
1356                         port, port, lanaddr, r, strupnperror(r));
1357                 else
1358                     LogPrintf("UPnP Port Mapping successful.\n");;
1359
1360                 MilliSleep(20*60*1000); // Refresh every 20 minutes
1361             }
1362         }
1363         catch (const boost::thread_interrupted&)
1364         {
1365             r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port.c_str(), "TCP", 0);
1366             LogPrintf("UPNP_DeletePortMapping() returned: %d\n", r);
1367             freeUPNPDevlist(devlist); devlist = 0;
1368             FreeUPNPUrls(&urls);
1369             throw;
1370         }
1371     } else {
1372         LogPrintf("No valid UPnP IGDs found\n");
1373         freeUPNPDevlist(devlist); devlist = 0;
1374         if (r != 0)
1375             FreeUPNPUrls(&urls);
1376     }
1377 }
1378
1379 void MapPort(bool fUseUPnP)
1380 {
1381     static boost::thread* upnp_thread = NULL;
1382
1383     if (fUseUPnP)
1384     {
1385         if (upnp_thread) {
1386             upnp_thread->interrupt();
1387             upnp_thread->join();
1388             delete upnp_thread;
1389         }
1390         upnp_thread = new boost::thread(boost::bind(&TraceThread<void (*)()>, "upnp", &ThreadMapPort));
1391     }
1392     else if (upnp_thread) {
1393         upnp_thread->interrupt();
1394         upnp_thread->join();
1395         delete upnp_thread;
1396         upnp_thread = NULL;
1397     }
1398 }
1399
1400 #else
1401 void MapPort(bool)
1402 {
1403     // Intentionally left blank.
1404 }
1405 #endif
1406
1407
1408
1409
1410
1411
1412 void ThreadDNSAddressSeed()
1413 {
1414     // goal: only query DNS seeds if address need is acute
1415     if ((addrman.size() > 0) &&
1416         (!GetBoolArg("-forcednsseed", false))) {
1417         MilliSleep(11 * 1000);
1418
1419         LOCK(cs_vNodes);
1420         if (vNodes.size() >= 2) {
1421             LogPrintf("P2P peers available. Skipped DNS seeding.\n");
1422             return;
1423         }
1424     }
1425
1426     const vector<CDNSSeedData> &vSeeds = Params().DNSSeeds();
1427     int found = 0;
1428
1429     LogPrintf("Loading addresses from DNS seeds (could take a while)\n");
1430
1431     BOOST_FOREACH(const CDNSSeedData &seed, vSeeds) {
1432         if (HaveNameProxy()) {
1433             AddOneShot(seed.host);
1434         } else {
1435             vector<CNetAddr> vIPs;
1436             vector<CAddress> vAdd;
1437             if (LookupHost(seed.host.c_str(), vIPs))
1438             {
1439                 BOOST_FOREACH(const CNetAddr& ip, vIPs)
1440                 {
1441                     int nOneDay = 24*3600;
1442                     CAddress addr = CAddress(CService(ip, Params().GetDefaultPort()));
1443                     addr.nTime = GetTime() - 3*nOneDay - GetRand(4*nOneDay); // use a random age between 3 and 7 days old
1444                     vAdd.push_back(addr);
1445                     found++;
1446                 }
1447             }
1448             addrman.Add(vAdd, CNetAddr(seed.name, true));
1449         }
1450     }
1451
1452     LogPrintf("%d addresses found from DNS seeds\n", found);
1453 }
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466 void DumpAddresses()
1467 {
1468     int64_t nStart = GetTimeMillis();
1469
1470     CAddrDB adb;
1471     adb.Write(addrman);
1472
1473     LogPrint("net", "Flushed %d addresses to peers.dat  %dms\n",
1474            addrman.size(), GetTimeMillis() - nStart);
1475 }
1476
1477 void DumpData()
1478 {
1479     DumpAddresses();
1480
1481     if (CNode::BannedSetIsDirty())
1482     {
1483         DumpBanlist();
1484         CNode::SetBannedSetDirty(false);
1485     }
1486 }
1487
1488 void static ProcessOneShot()
1489 {
1490     string strDest;
1491     {
1492         LOCK(cs_vOneShots);
1493         if (vOneShots.empty())
1494             return;
1495         strDest = vOneShots.front();
1496         vOneShots.pop_front();
1497     }
1498     CAddress addr;
1499     CSemaphoreGrant grant(*semOutbound, true);
1500     if (grant) {
1501         if (!OpenNetworkConnection(addr, &grant, strDest.c_str(), true))
1502             AddOneShot(strDest);
1503     }
1504 }
1505
1506 void ThreadOpenConnections()
1507 {
1508     // Connect to specific addresses
1509     if (mapArgs.count("-connect") && mapMultiArgs["-connect"].size() > 0)
1510     {
1511         for (int64_t nLoop = 0;; nLoop++)
1512         {
1513             ProcessOneShot();
1514             BOOST_FOREACH(const std::string& strAddr, mapMultiArgs["-connect"])
1515             {
1516                 CAddress addr;
1517                 OpenNetworkConnection(addr, NULL, strAddr.c_str());
1518                 for (int i = 0; i < 10 && i < nLoop; i++)
1519                 {
1520                     MilliSleep(500);
1521                 }
1522             }
1523             MilliSleep(500);
1524         }
1525     }
1526
1527     // Initiate network connections
1528     int64_t nStart = GetTime();
1529     while (true)
1530     {
1531         ProcessOneShot();
1532
1533         MilliSleep(500);
1534
1535         CSemaphoreGrant grant(*semOutbound);
1536         boost::this_thread::interruption_point();
1537
1538         // Add seed nodes if DNS seeds are all down (an infrastructure attack?).
1539         if (addrman.size() == 0 && (GetTime() - nStart > 60)) {
1540             static bool done = false;
1541             if (!done) {
1542                 LogPrintf("Adding fixed seed nodes as DNS doesn't seem to be available.\n");
1543                 addrman.Add(convertSeed6(Params().FixedSeeds()), CNetAddr("127.0.0.1"));
1544                 done = true;
1545             }
1546         }
1547
1548         //
1549         // Choose an address to connect to based on most recently seen
1550         //
1551         CAddress addrConnect;
1552
1553         // Only connect out to one peer per network group (/16 for IPv4).
1554         // Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
1555         int nOutbound = 0;
1556         set<vector<unsigned char> > setConnected;
1557         {
1558             LOCK(cs_vNodes);
1559             BOOST_FOREACH(CNode* pnode, vNodes) {
1560                 if (!pnode->fInbound) {
1561                     setConnected.insert(pnode->addr.GetGroup());
1562                     nOutbound++;
1563                 }
1564             }
1565         }
1566
1567         int64_t nANow = GetAdjustedTime();
1568
1569         int nTries = 0;
1570         while (true)
1571         {
1572             CAddrInfo addr = addrman.Select();
1573
1574             // if we selected an invalid address, restart
1575             if (!addr.IsValid() || setConnected.count(addr.GetGroup()) || IsLocal(addr))
1576                 break;
1577
1578             // If we didn't find an appropriate destination after trying 100 addresses fetched from addrman,
1579             // stop this loop, and let the outer loop run again (which sleeps, adds seed nodes, recalculates
1580             // already-connected network ranges, ...) before trying new addrman addresses.
1581             nTries++;
1582             if (nTries > 100)
1583                 break;
1584
1585             if (IsLimited(addr))
1586                 continue;
1587
1588             // only consider very recently tried nodes after 30 failed attempts
1589             if (nANow - addr.nLastTry < 600 && nTries < 30)
1590                 continue;
1591
1592             // do not allow non-default ports, unless after 50 invalid addresses selected already
1593             if (addr.GetPort() != Params().GetDefaultPort() && nTries < 50)
1594                 continue;
1595
1596             addrConnect = addr;
1597             break;
1598         }
1599
1600         if (addrConnect.IsValid())
1601             OpenNetworkConnection(addrConnect, &grant);
1602     }
1603 }
1604
1605 void ThreadOpenAddedConnections()
1606 {
1607     {
1608         LOCK(cs_vAddedNodes);
1609         vAddedNodes = mapMultiArgs["-addnode"];
1610     }
1611
1612     if (HaveNameProxy()) {
1613         while(true) {
1614             list<string> lAddresses(0);
1615             {
1616                 LOCK(cs_vAddedNodes);
1617                 BOOST_FOREACH(const std::string& strAddNode, vAddedNodes)
1618                     lAddresses.push_back(strAddNode);
1619             }
1620             BOOST_FOREACH(const std::string& strAddNode, lAddresses) {
1621                 CAddress addr;
1622                 CSemaphoreGrant grant(*semOutbound);
1623                 OpenNetworkConnection(addr, &grant, strAddNode.c_str());
1624                 MilliSleep(500);
1625             }
1626             MilliSleep(120000); // Retry every 2 minutes
1627         }
1628     }
1629
1630     for (unsigned int i = 0; true; i++)
1631     {
1632         list<string> lAddresses(0);
1633         {
1634             LOCK(cs_vAddedNodes);
1635             BOOST_FOREACH(const std::string& strAddNode, vAddedNodes)
1636                 lAddresses.push_back(strAddNode);
1637         }
1638
1639         list<vector<CService> > lservAddressesToAdd(0);
1640         BOOST_FOREACH(const std::string& strAddNode, lAddresses) {
1641             vector<CService> vservNode(0);
1642             if(Lookup(strAddNode.c_str(), vservNode, Params().GetDefaultPort(), fNameLookup, 0))
1643             {
1644                 lservAddressesToAdd.push_back(vservNode);
1645                 {
1646                     LOCK(cs_setservAddNodeAddresses);
1647                     BOOST_FOREACH(const CService& serv, vservNode)
1648                         setservAddNodeAddresses.insert(serv);
1649                 }
1650             }
1651         }
1652         // Attempt to connect to each IP for each addnode entry until at least one is successful per addnode entry
1653         // (keeping in mind that addnode entries can have many IPs if fNameLookup)
1654         {
1655             LOCK(cs_vNodes);
1656             BOOST_FOREACH(CNode* pnode, vNodes)
1657                 for (list<vector<CService> >::iterator it = lservAddressesToAdd.begin(); it != lservAddressesToAdd.end(); it++)
1658                     BOOST_FOREACH(const CService& addrNode, *(it))
1659                         if (pnode->addr == addrNode)
1660                         {
1661                             it = lservAddressesToAdd.erase(it);
1662                             it--;
1663                             break;
1664                         }
1665         }
1666         BOOST_FOREACH(vector<CService>& vserv, lservAddressesToAdd)
1667         {
1668             CSemaphoreGrant grant(*semOutbound);
1669             OpenNetworkConnection(CAddress(vserv[i % vserv.size()]), &grant);
1670             MilliSleep(500);
1671         }
1672         MilliSleep(120000); // Retry every 2 minutes
1673     }
1674 }
1675
1676 // if successful, this moves the passed grant to the constructed node
1677 bool OpenNetworkConnection(const CAddress& addrConnect, CSemaphoreGrant *grantOutbound, const char *pszDest, bool fOneShot)
1678 {
1679     //
1680     // Initiate outbound network connection
1681     //
1682     boost::this_thread::interruption_point();
1683     if (!pszDest) {
1684         if (IsLocal(addrConnect) ||
1685             FindNode((CNetAddr)addrConnect) || CNode::IsBanned(addrConnect) ||
1686             FindNode(addrConnect.ToStringIPPort()))
1687             return false;
1688     } else if (FindNode(std::string(pszDest)))
1689         return false;
1690
1691     CNode* pnode = ConnectNode(addrConnect, pszDest);
1692     boost::this_thread::interruption_point();
1693
1694     if (!pnode)
1695         return false;
1696     if (grantOutbound)
1697         grantOutbound->MoveTo(pnode->grantOutbound);
1698     pnode->fNetworkNode = true;
1699     if (fOneShot)
1700         pnode->fOneShot = true;
1701
1702     return true;
1703 }
1704
1705
1706 void ThreadMessageHandler()
1707 {
1708     boost::mutex condition_mutex;
1709     boost::unique_lock<boost::mutex> lock(condition_mutex);
1710
1711     SetThreadPriority(THREAD_PRIORITY_BELOW_NORMAL);
1712     while (true)
1713     {
1714         vector<CNode*> vNodesCopy;
1715         {
1716             LOCK(cs_vNodes);
1717             vNodesCopy = vNodes;
1718             BOOST_FOREACH(CNode* pnode, vNodesCopy) {
1719                 pnode->AddRef();
1720             }
1721         }
1722
1723         // Poll the connected nodes for messages
1724         CNode* pnodeTrickle = NULL;
1725         if (!vNodesCopy.empty())
1726             pnodeTrickle = vNodesCopy[GetRand(vNodesCopy.size())];
1727
1728         bool fSleep = true;
1729
1730         BOOST_FOREACH(CNode* pnode, vNodesCopy)
1731         {
1732             if (pnode->fDisconnect)
1733                 continue;
1734
1735             // Receive messages
1736             {
1737                 TRY_LOCK(pnode->cs_vRecvMsg, lockRecv);
1738                 if (lockRecv)
1739                 {
1740                     if (!g_signals.ProcessMessages(pnode))
1741                         pnode->CloseSocketDisconnect();
1742
1743                     if (pnode->nSendSize < SendBufferSize())
1744                     {
1745                         if (!pnode->vRecvGetData.empty() || (!pnode->vRecvMsg.empty() && pnode->vRecvMsg[0].complete()))
1746                         {
1747                             fSleep = false;
1748                         }
1749                     }
1750                 }
1751             }
1752             boost::this_thread::interruption_point();
1753
1754             // Send messages
1755             {
1756                 TRY_LOCK(pnode->cs_vSend, lockSend);
1757                 if (lockSend)
1758                     g_signals.SendMessages(pnode, pnode == pnodeTrickle || pnode->fWhitelisted);
1759             }
1760             boost::this_thread::interruption_point();
1761         }
1762
1763         {
1764             LOCK(cs_vNodes);
1765             BOOST_FOREACH(CNode* pnode, vNodesCopy)
1766                 pnode->Release();
1767         }
1768
1769         if (fSleep)
1770             messageHandlerCondition.timed_wait(lock, boost::posix_time::microsec_clock::universal_time() + boost::posix_time::milliseconds(100));
1771     }
1772 }
1773
1774
1775
1776
1777
1778
1779 bool BindListenPort(const CService &addrBind, string& strError, bool fWhitelisted)
1780 {
1781     strError = "";
1782     int nOne = 1;
1783
1784     // Create socket for listening for incoming connections
1785     struct sockaddr_storage sockaddr;
1786     socklen_t len = sizeof(sockaddr);
1787     if (!addrBind.GetSockAddr((struct sockaddr*)&sockaddr, &len))
1788     {
1789         strError = strprintf("Error: Bind address family for %s not supported", addrBind.ToString());
1790         LogPrintf("%s\n", strError);
1791         return false;
1792     }
1793
1794     SOCKET hListenSocket = socket(((struct sockaddr*)&sockaddr)->sa_family, SOCK_STREAM, IPPROTO_TCP);
1795     if (hListenSocket == INVALID_SOCKET)
1796     {
1797         strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %s)", NetworkErrorString(WSAGetLastError()));
1798         LogPrintf("%s\n", strError);
1799         return false;
1800     }
1801     if (!IsSelectableSocket(hListenSocket))
1802     {
1803         strError = "Error: Couldn't create a listenable socket for incoming connections";
1804         LogPrintf("%s\n", strError);
1805         return false;
1806     }
1807
1808
1809 #ifndef WIN32
1810 #ifdef SO_NOSIGPIPE
1811     // Different way of disabling SIGPIPE on BSD
1812     setsockopt(hListenSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&nOne, sizeof(int));
1813 #endif
1814     // Allow binding if the port is still in TIME_WAIT state after
1815     // the program was closed and restarted.
1816     setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (void*)&nOne, sizeof(int));
1817     // Disable Nagle's algorithm
1818     setsockopt(hListenSocket, IPPROTO_TCP, TCP_NODELAY, (void*)&nOne, sizeof(int));
1819 #else
1820     setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (const char*)&nOne, sizeof(int));
1821     setsockopt(hListenSocket, IPPROTO_TCP, TCP_NODELAY, (const char*)&nOne, sizeof(int));
1822 #endif
1823
1824     // Set to non-blocking, incoming connections will also inherit this
1825     if (!SetSocketNonBlocking(hListenSocket, true)) {
1826         strError = strprintf("BindListenPort: Setting listening socket to non-blocking failed, error %s\n", NetworkErrorString(WSAGetLastError()));
1827         LogPrintf("%s\n", strError);
1828         return false;
1829     }
1830
1831     // some systems don't have IPV6_V6ONLY but are always v6only; others do have the option
1832     // and enable it by default or not. Try to enable it, if possible.
1833     if (addrBind.IsIPv6()) {
1834 #ifdef IPV6_V6ONLY
1835 #ifdef WIN32
1836         setsockopt(hListenSocket, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&nOne, sizeof(int));
1837 #else
1838         setsockopt(hListenSocket, IPPROTO_IPV6, IPV6_V6ONLY, (void*)&nOne, sizeof(int));
1839 #endif
1840 #endif
1841 #ifdef WIN32
1842         int nProtLevel = PROTECTION_LEVEL_UNRESTRICTED;
1843         setsockopt(hListenSocket, IPPROTO_IPV6, IPV6_PROTECTION_LEVEL, (const char*)&nProtLevel, sizeof(int));
1844 #endif
1845     }
1846
1847     if (::bind(hListenSocket, (struct sockaddr*)&sockaddr, len) == SOCKET_ERROR)
1848     {
1849         int nErr = WSAGetLastError();
1850         if (nErr == WSAEADDRINUSE)
1851             strError = strprintf(_("Unable to bind to %s on this computer. Bitcoin Core is probably already running."), addrBind.ToString());
1852         else
1853             strError = strprintf(_("Unable to bind to %s on this computer (bind returned error %s)"), addrBind.ToString(), NetworkErrorString(nErr));
1854         LogPrintf("%s\n", strError);
1855         CloseSocket(hListenSocket);
1856         return false;
1857     }
1858     LogPrintf("Bound to %s\n", addrBind.ToString());
1859
1860     // Listen for incoming connections
1861     if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR)
1862     {
1863         strError = strprintf(_("Error: Listening for incoming connections failed (listen returned error %s)"), NetworkErrorString(WSAGetLastError()));
1864         LogPrintf("%s\n", strError);
1865         CloseSocket(hListenSocket);
1866         return false;
1867     }
1868
1869     vhListenSocket.push_back(ListenSocket(hListenSocket, fWhitelisted));
1870
1871     if (addrBind.IsRoutable() && fDiscover && !fWhitelisted)
1872         AddLocal(addrBind, LOCAL_BIND);
1873
1874     return true;
1875 }
1876
1877 void static Discover(boost::thread_group& threadGroup)
1878 {
1879     if (!fDiscover)
1880         return;
1881
1882 #ifdef WIN32
1883     // Get local host IP
1884     char pszHostName[256] = "";
1885     if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR)
1886     {
1887         vector<CNetAddr> vaddr;
1888         if (LookupHost(pszHostName, vaddr))
1889         {
1890             BOOST_FOREACH (const CNetAddr &addr, vaddr)
1891             {
1892                 if (AddLocal(addr, LOCAL_IF))
1893                     LogPrintf("%s: %s - %s\n", __func__, pszHostName, addr.ToString());
1894             }
1895         }
1896     }
1897 #else
1898     // Get local host ip
1899     struct ifaddrs* myaddrs;
1900     if (getifaddrs(&myaddrs) == 0)
1901     {
1902         for (struct ifaddrs* ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
1903         {
1904             if (ifa->ifa_addr == NULL) continue;
1905             if ((ifa->ifa_flags & IFF_UP) == 0) continue;
1906             if (strcmp(ifa->ifa_name, "lo") == 0) continue;
1907             if (strcmp(ifa->ifa_name, "lo0") == 0) continue;
1908             if (ifa->ifa_addr->sa_family == AF_INET)
1909             {
1910                 struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
1911                 CNetAddr addr(s4->sin_addr);
1912                 if (AddLocal(addr, LOCAL_IF))
1913                     LogPrintf("%s: IPv4 %s: %s\n", __func__, ifa->ifa_name, addr.ToString());
1914             }
1915             else if (ifa->ifa_addr->sa_family == AF_INET6)
1916             {
1917                 struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
1918                 CNetAddr addr(s6->sin6_addr);
1919                 if (AddLocal(addr, LOCAL_IF))
1920                     LogPrintf("%s: IPv6 %s: %s\n", __func__, ifa->ifa_name, addr.ToString());
1921             }
1922         }
1923         freeifaddrs(myaddrs);
1924     }
1925 #endif
1926 }
1927
1928 void StartNode(boost::thread_group& threadGroup, CScheduler& scheduler)
1929 {
1930     uiInterface.InitMessage(_("Loading addresses..."));
1931     // Load addresses for peers.dat
1932     int64_t nStart = GetTimeMillis();
1933     {
1934         CAddrDB adb;
1935         if (!adb.Read(addrman))
1936             LogPrintf("Invalid or missing peers.dat; recreating\n");
1937     }
1938
1939     //try to read stored banlist
1940     CBanDB bandb;
1941     banmap_t banmap;
1942     if (!bandb.Read(banmap))
1943         LogPrintf("Invalid or missing banlist.dat; recreating\n");
1944
1945     CNode::SetBanned(banmap); //thread save setter
1946     CNode::SetBannedSetDirty(false); //no need to write down just read or nonexistent data
1947     CNode::SweepBanned(); //sweap out unused entries
1948
1949     LogPrintf("Loaded %i addresses from peers.dat  %dms\n",
1950            addrman.size(), GetTimeMillis() - nStart);
1951     fAddressesInitialized = true;
1952
1953     if (semOutbound == NULL) {
1954         // initialize semaphore
1955         int nMaxOutbound = min(MAX_OUTBOUND_CONNECTIONS, nMaxConnections);
1956         semOutbound = new CSemaphore(nMaxOutbound);
1957     }
1958
1959     if (pnodeLocalHost == NULL)
1960         pnodeLocalHost = new CNode(INVALID_SOCKET, CAddress(CService("127.0.0.1", 0), nLocalServices));
1961
1962     Discover(threadGroup);
1963
1964     //
1965     // Start threads
1966     //
1967
1968     if (!GetBoolArg("-dnsseed", true))
1969         LogPrintf("DNS seeding disabled\n");
1970     else
1971         threadGroup.create_thread(boost::bind(&TraceThread<void (*)()>, "dnsseed", &ThreadDNSAddressSeed));
1972
1973     // Map ports with UPnP
1974     MapPort(GetBoolArg("-upnp", DEFAULT_UPNP));
1975
1976     // Send and receive from sockets, accept connections
1977     threadGroup.create_thread(boost::bind(&TraceThread<void (*)()>, "net", &ThreadSocketHandler));
1978
1979     // Initiate outbound connections from -addnode
1980     threadGroup.create_thread(boost::bind(&TraceThread<void (*)()>, "addcon", &ThreadOpenAddedConnections));
1981
1982     // Initiate outbound connections
1983     threadGroup.create_thread(boost::bind(&TraceThread<void (*)()>, "opencon", &ThreadOpenConnections));
1984
1985     // Process messages
1986     threadGroup.create_thread(boost::bind(&TraceThread<void (*)()>, "msghand", &ThreadMessageHandler));
1987
1988     // Dump network addresses
1989     scheduler.scheduleEvery(&DumpData, DUMP_ADDRESSES_INTERVAL);
1990 }
1991
1992 bool StopNode()
1993 {
1994     LogPrintf("StopNode()\n");
1995     MapPort(false);
1996     if (semOutbound)
1997         for (int i=0; i<MAX_OUTBOUND_CONNECTIONS; i++)
1998             semOutbound->post();
1999
2000     if (fAddressesInitialized)
2001     {
2002         DumpData();
2003         fAddressesInitialized = false;
2004     }
2005
2006     return true;
2007 }
2008
2009 class CNetCleanup
2010 {
2011 public:
2012     CNetCleanup() {}
2013
2014     ~CNetCleanup()
2015     {
2016         // Close sockets
2017         BOOST_FOREACH(CNode* pnode, vNodes)
2018             if (pnode->hSocket != INVALID_SOCKET)
2019                 CloseSocket(pnode->hSocket);
2020         BOOST_FOREACH(ListenSocket& hListenSocket, vhListenSocket)
2021             if (hListenSocket.socket != INVALID_SOCKET)
2022                 if (!CloseSocket(hListenSocket.socket))
2023                     LogPrintf("CloseSocket(hListenSocket) failed with error %s\n", NetworkErrorString(WSAGetLastError()));
2024
2025         // clean up some globals (to help leak detection)
2026         BOOST_FOREACH(CNode *pnode, vNodes)
2027             delete pnode;
2028         BOOST_FOREACH(CNode *pnode, vNodesDisconnected)
2029             delete pnode;
2030         vNodes.clear();
2031         vNodesDisconnected.clear();
2032         vhListenSocket.clear();
2033         delete semOutbound;
2034         semOutbound = NULL;
2035         delete pnodeLocalHost;
2036         pnodeLocalHost = NULL;
2037
2038 #ifdef WIN32
2039         // Shutdown Windows Sockets
2040         WSACleanup();
2041 #endif
2042     }
2043 }
2044 instance_of_cnetcleanup;
2045
2046
2047
2048
2049
2050
2051
2052 void RelayTransaction(const CTransaction& tx)
2053 {
2054     CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
2055     ss.reserve(10000);
2056     ss << tx;
2057     RelayTransaction(tx, ss);
2058 }
2059
2060 void RelayTransaction(const CTransaction& tx, const CDataStream& ss)
2061 {
2062     CInv inv(MSG_TX, tx.GetHash());
2063     {
2064         LOCK(cs_mapRelay);
2065         // Expire old relay messages
2066         while (!vRelayExpiration.empty() && vRelayExpiration.front().first < GetTime())
2067         {
2068             mapRelay.erase(vRelayExpiration.front().second);
2069             vRelayExpiration.pop_front();
2070         }
2071
2072         // Save original serialized message so newer versions are preserved
2073         mapRelay.insert(std::make_pair(inv, ss));
2074         vRelayExpiration.push_back(std::make_pair(GetTime() + 15 * 60, inv));
2075     }
2076     LOCK(cs_vNodes);
2077     BOOST_FOREACH(CNode* pnode, vNodes)
2078     {
2079         if(!pnode->fRelayTxes)
2080             continue;
2081         LOCK(pnode->cs_filter);
2082         if (pnode->pfilter)
2083         {
2084             if (pnode->pfilter->IsRelevantAndUpdate(tx))
2085                 pnode->PushInventory(inv);
2086         } else
2087             pnode->PushInventory(inv);
2088     }
2089 }
2090
2091 void CNode::RecordBytesRecv(uint64_t bytes)
2092 {
2093     LOCK(cs_totalBytesRecv);
2094     nTotalBytesRecv += bytes;
2095 }
2096
2097 void CNode::RecordBytesSent(uint64_t bytes)
2098 {
2099     LOCK(cs_totalBytesSent);
2100     nTotalBytesSent += bytes;
2101
2102     uint64_t now = GetTime();
2103     if (nMaxOutboundCycleStartTime + nMaxOutboundTimeframe < now)
2104     {
2105         // timeframe expired, reset cycle
2106         nMaxOutboundCycleStartTime = now;
2107         nMaxOutboundTotalBytesSentInCycle = 0;
2108     }
2109
2110     // TODO, exclude whitebind peers
2111     nMaxOutboundTotalBytesSentInCycle += bytes;
2112 }
2113
2114 void CNode::SetMaxOutboundTarget(uint64_t limit)
2115 {
2116     LOCK(cs_totalBytesSent);
2117     uint64_t recommendedMinimum = (nMaxOutboundTimeframe / 600) * MAX_BLOCK_SIZE;
2118     nMaxOutboundLimit = limit;
2119
2120     if (limit > 0 && limit < recommendedMinimum)
2121         LogPrintf("Max outbound target is very small (%s bytes) and will be overshot. Recommended minimum is %s bytes.\n", nMaxOutboundLimit, recommendedMinimum);
2122 }
2123
2124 uint64_t CNode::GetMaxOutboundTarget()
2125 {
2126     LOCK(cs_totalBytesSent);
2127     return nMaxOutboundLimit;
2128 }
2129
2130 uint64_t CNode::GetMaxOutboundTimeframe()
2131 {
2132     LOCK(cs_totalBytesSent);
2133     return nMaxOutboundTimeframe;
2134 }
2135
2136 uint64_t CNode::GetMaxOutboundTimeLeftInCycle()
2137 {
2138     LOCK(cs_totalBytesSent);
2139     if (nMaxOutboundLimit == 0)
2140         return 0;
2141
2142     if (nMaxOutboundCycleStartTime == 0)
2143         return nMaxOutboundTimeframe;
2144
2145     uint64_t cycleEndTime = nMaxOutboundCycleStartTime + nMaxOutboundTimeframe;
2146     uint64_t now = GetTime();
2147     return (cycleEndTime < now) ? 0 : cycleEndTime - GetTime();
2148 }
2149
2150 void CNode::SetMaxOutboundTimeframe(uint64_t timeframe)
2151 {
2152     LOCK(cs_totalBytesSent);
2153     if (nMaxOutboundTimeframe != timeframe)
2154     {
2155         // reset measure-cycle in case of changing
2156         // the timeframe
2157         nMaxOutboundCycleStartTime = GetTime();
2158     }
2159     nMaxOutboundTimeframe = timeframe;
2160 }
2161
2162 bool CNode::OutboundTargetReached(bool historicalBlockServingLimit)
2163 {
2164     LOCK(cs_totalBytesSent);
2165     if (nMaxOutboundLimit == 0)
2166         return false;
2167
2168     if (historicalBlockServingLimit)
2169     {
2170         // keep a large enought buffer to at least relay each block once
2171         uint64_t timeLeftInCycle = GetMaxOutboundTimeLeftInCycle();
2172         uint64_t buffer = timeLeftInCycle / 600 * MAX_BLOCK_SIZE;
2173         if (buffer >= nMaxOutboundLimit || nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit - buffer)
2174             return true;
2175     }
2176     else if (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit)
2177         return true;
2178
2179     return false;
2180 }
2181
2182 uint64_t CNode::GetOutboundTargetBytesLeft()
2183 {
2184     LOCK(cs_totalBytesSent);
2185     if (nMaxOutboundLimit == 0)
2186         return 0;
2187
2188     return (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit) ? 0 : nMaxOutboundLimit - nMaxOutboundTotalBytesSentInCycle;
2189 }
2190
2191 uint64_t CNode::GetTotalBytesRecv()
2192 {
2193     LOCK(cs_totalBytesRecv);
2194     return nTotalBytesRecv;
2195 }
2196
2197 uint64_t CNode::GetTotalBytesSent()
2198 {
2199     LOCK(cs_totalBytesSent);
2200     return nTotalBytesSent;
2201 }
2202
2203 void CNode::Fuzz(int nChance)
2204 {
2205     if (!fSuccessfullyConnected) return; // Don't fuzz initial handshake
2206     if (GetRand(nChance) != 0) return; // Fuzz 1 of every nChance messages
2207
2208     switch (GetRand(3))
2209     {
2210     case 0:
2211         // xor a random byte with a random value:
2212         if (!ssSend.empty()) {
2213             CDataStream::size_type pos = GetRand(ssSend.size());
2214             ssSend[pos] ^= (unsigned char)(GetRand(256));
2215         }
2216         break;
2217     case 1:
2218         // delete a random byte:
2219         if (!ssSend.empty()) {
2220             CDataStream::size_type pos = GetRand(ssSend.size());
2221             ssSend.erase(ssSend.begin()+pos);
2222         }
2223         break;
2224     case 2:
2225         // insert a random byte at a random position
2226         {
2227             CDataStream::size_type pos = GetRand(ssSend.size());
2228             char ch = (char)GetRand(256);
2229             ssSend.insert(ssSend.begin()+pos, ch);
2230         }
2231         break;
2232     }
2233     // Chance of more than one change half the time:
2234     // (more changes exponentially less likely):
2235     Fuzz(2);
2236 }
2237
2238 //
2239 // CAddrDB
2240 //
2241
2242 CAddrDB::CAddrDB()
2243 {
2244     pathAddr = GetDataDir() / "peers.dat";
2245 }
2246
2247 bool CAddrDB::Write(const CAddrMan& addr)
2248 {
2249     // Generate random temporary filename
2250     unsigned short randv = 0;
2251     GetRandBytes((unsigned char*)&randv, sizeof(randv));
2252     std::string tmpfn = strprintf("peers.dat.%04x", randv);
2253
2254     // serialize addresses, checksum data up to that point, then append csum
2255     CDataStream ssPeers(SER_DISK, CLIENT_VERSION);
2256     ssPeers << FLATDATA(Params().MessageStart());
2257     ssPeers << addr;
2258     uint256 hash = Hash(ssPeers.begin(), ssPeers.end());
2259     ssPeers << hash;
2260
2261     // open temp output file, and associate with CAutoFile
2262     boost::filesystem::path pathTmp = GetDataDir() / tmpfn;
2263     FILE *file = fopen(pathTmp.string().c_str(), "wb");
2264     CAutoFile fileout(file, SER_DISK, CLIENT_VERSION);
2265     if (fileout.IsNull())
2266         return error("%s: Failed to open file %s", __func__, pathTmp.string());
2267
2268     // Write and commit header, data
2269     try {
2270         fileout << ssPeers;
2271     }
2272     catch (const std::exception& e) {
2273         return error("%s: Serialize or I/O error - %s", __func__, e.what());
2274     }
2275     FileCommit(fileout.Get());
2276     fileout.fclose();
2277
2278     // replace existing peers.dat, if any, with new peers.dat.XXXX
2279     if (!RenameOver(pathTmp, pathAddr))
2280         return error("%s: Rename-into-place failed", __func__);
2281
2282     return true;
2283 }
2284
2285 bool CAddrDB::Read(CAddrMan& addr)
2286 {
2287     // open input file, and associate with CAutoFile
2288     FILE *file = fopen(pathAddr.string().c_str(), "rb");
2289     CAutoFile filein(file, SER_DISK, CLIENT_VERSION);
2290     if (filein.IsNull())
2291         return error("%s: Failed to open file %s", __func__, pathAddr.string());
2292
2293     // use file size to size memory buffer
2294     uint64_t fileSize = boost::filesystem::file_size(pathAddr);
2295     uint64_t dataSize = 0;
2296     // Don't try to resize to a negative number if file is small
2297     if (fileSize >= sizeof(uint256))
2298         dataSize = fileSize - sizeof(uint256);
2299     vector<unsigned char> vchData;
2300     vchData.resize(dataSize);
2301     uint256 hashIn;
2302
2303     // read data and checksum from file
2304     try {
2305         filein.read((char *)&vchData[0], dataSize);
2306         filein >> hashIn;
2307     }
2308     catch (const std::exception& e) {
2309         return error("%s: Deserialize or I/O error - %s", __func__, e.what());
2310     }
2311     filein.fclose();
2312
2313     CDataStream ssPeers(vchData, SER_DISK, CLIENT_VERSION);
2314
2315     // verify stored checksum matches input data
2316     uint256 hashTmp = Hash(ssPeers.begin(), ssPeers.end());
2317     if (hashIn != hashTmp)
2318         return error("%s: Checksum mismatch, data corrupted", __func__);
2319
2320     unsigned char pchMsgTmp[4];
2321     try {
2322         // de-serialize file header (network specific magic number) and ..
2323         ssPeers >> FLATDATA(pchMsgTmp);
2324
2325         // ... verify the network matches ours
2326         if (memcmp(pchMsgTmp, Params().MessageStart(), sizeof(pchMsgTmp)))
2327             return error("%s: Invalid network magic number", __func__);
2328
2329         // de-serialize address data into one CAddrMan object
2330         ssPeers >> addr;
2331     }
2332     catch (const std::exception& e) {
2333         return error("%s: Deserialize or I/O error - %s", __func__, e.what());
2334     }
2335
2336     return true;
2337 }
2338
2339 unsigned int ReceiveFloodSize() { return 1000*GetArg("-maxreceivebuffer", 5*1000); }
2340 unsigned int SendBufferSize() { return 1000*GetArg("-maxsendbuffer", 1*1000); }
2341
2342 CNode::CNode(SOCKET hSocketIn, const CAddress& addrIn, const std::string& addrNameIn, bool fInboundIn) :
2343     ssSend(SER_NETWORK, INIT_PROTO_VERSION),
2344     addrKnown(5000, 0.001),
2345     setInventoryKnown(SendBufferSize() / 1000)
2346 {
2347     nServices = 0;
2348     hSocket = hSocketIn;
2349     nRecvVersion = INIT_PROTO_VERSION;
2350     nLastSend = 0;
2351     nLastRecv = 0;
2352     nSendBytes = 0;
2353     nRecvBytes = 0;
2354     nTimeConnected = GetTime();
2355     nTimeOffset = 0;
2356     addr = addrIn;
2357     addrName = addrNameIn == "" ? addr.ToStringIPPort() : addrNameIn;
2358     nVersion = 0;
2359     strSubVer = "";
2360     fWhitelisted = false;
2361     fOneShot = false;
2362     fClient = false; // set by version message
2363     fInbound = fInboundIn;
2364     fNetworkNode = false;
2365     fSuccessfullyConnected = false;
2366     fDisconnect = false;
2367     nRefCount = 0;
2368     nSendSize = 0;
2369     nSendOffset = 0;
2370     hashContinue = uint256();
2371     nStartingHeight = -1;
2372     fGetAddr = false;
2373     fRelayTxes = false;
2374     pfilter = new CBloomFilter();
2375     nPingNonceSent = 0;
2376     nPingUsecStart = 0;
2377     nPingUsecTime = 0;
2378     fPingQueued = false;
2379     nMinPingUsecTime = std::numeric_limits<int64_t>::max();
2380
2381     {
2382         LOCK(cs_nLastNodeId);
2383         id = nLastNodeId++;
2384     }
2385
2386     if (fLogIPs)
2387         LogPrint("net", "Added connection to %s peer=%d\n", addrName, id);
2388     else
2389         LogPrint("net", "Added connection peer=%d\n", id);
2390
2391     // Be shy and don't send version until we hear
2392     if (hSocket != INVALID_SOCKET && !fInbound)
2393         PushVersion();
2394
2395     GetNodeSignals().InitializeNode(GetId(), this);
2396 }
2397
2398 CNode::~CNode()
2399 {
2400     CloseSocket(hSocket);
2401
2402     if (pfilter)
2403         delete pfilter;
2404
2405     GetNodeSignals().FinalizeNode(GetId());
2406 }
2407
2408 void CNode::AskFor(const CInv& inv)
2409 {
2410     if (mapAskFor.size() > MAPASKFOR_MAX_SZ)
2411         return;
2412     // We're using mapAskFor as a priority queue,
2413     // the key is the earliest time the request can be sent
2414     int64_t nRequestTime;
2415     limitedmap<CInv, int64_t>::const_iterator it = mapAlreadyAskedFor.find(inv);
2416     if (it != mapAlreadyAskedFor.end())
2417         nRequestTime = it->second;
2418     else
2419         nRequestTime = 0;
2420     LogPrint("net", "askfor %s  %d (%s) peer=%d\n", inv.ToString(), nRequestTime, DateTimeStrFormat("%H:%M:%S", nRequestTime/1000000), id);
2421
2422     // Make sure not to reuse time indexes to keep things in the same order
2423     int64_t nNow = GetTimeMicros() - 1000000;
2424     static int64_t nLastTime;
2425     ++nLastTime;
2426     nNow = std::max(nNow, nLastTime);
2427     nLastTime = nNow;
2428
2429     // Each retry is 2 minutes after the last
2430     nRequestTime = std::max(nRequestTime + 2 * 60 * 1000000, nNow);
2431     if (it != mapAlreadyAskedFor.end())
2432         mapAlreadyAskedFor.update(it, nRequestTime);
2433     else
2434         mapAlreadyAskedFor.insert(std::make_pair(inv, nRequestTime));
2435     mapAskFor.insert(std::make_pair(nRequestTime, inv));
2436 }
2437
2438 void CNode::BeginMessage(const char* pszCommand) EXCLUSIVE_LOCK_FUNCTION(cs_vSend)
2439 {
2440     ENTER_CRITICAL_SECTION(cs_vSend);
2441     assert(ssSend.size() == 0);
2442     ssSend << CMessageHeader(Params().MessageStart(), pszCommand, 0);
2443     LogPrint("net", "sending: %s ", SanitizeString(pszCommand));
2444 }
2445
2446 void CNode::AbortMessage() UNLOCK_FUNCTION(cs_vSend)
2447 {
2448     ssSend.clear();
2449
2450     LEAVE_CRITICAL_SECTION(cs_vSend);
2451
2452     LogPrint("net", "(aborted)\n");
2453 }
2454
2455 void CNode::EndMessage() UNLOCK_FUNCTION(cs_vSend)
2456 {
2457     // The -*messagestest options are intentionally not documented in the help message,
2458     // since they are only used during development to debug the networking code and are
2459     // not intended for end-users.
2460     if (mapArgs.count("-dropmessagestest") && GetRand(GetArg("-dropmessagestest", 2)) == 0)
2461     {
2462         LogPrint("net", "dropmessages DROPPING SEND MESSAGE\n");
2463         AbortMessage();
2464         return;
2465     }
2466     if (mapArgs.count("-fuzzmessagestest"))
2467         Fuzz(GetArg("-fuzzmessagestest", 10));
2468
2469     if (ssSend.size() == 0)
2470     {
2471         LEAVE_CRITICAL_SECTION(cs_vSend);
2472         return;
2473     }
2474     // Set the size
2475     unsigned int nSize = ssSend.size() - CMessageHeader::HEADER_SIZE;
2476     WriteLE32((uint8_t*)&ssSend[CMessageHeader::MESSAGE_SIZE_OFFSET], nSize);
2477
2478     // Set the checksum
2479     uint256 hash = Hash(ssSend.begin() + CMessageHeader::HEADER_SIZE, ssSend.end());
2480     unsigned int nChecksum = 0;
2481     memcpy(&nChecksum, &hash, sizeof(nChecksum));
2482     assert(ssSend.size () >= CMessageHeader::CHECKSUM_OFFSET + sizeof(nChecksum));
2483     memcpy((char*)&ssSend[CMessageHeader::CHECKSUM_OFFSET], &nChecksum, sizeof(nChecksum));
2484
2485     LogPrint("net", "(%d bytes) peer=%d\n", nSize, id);
2486
2487     std::deque<CSerializeData>::iterator it = vSendMsg.insert(vSendMsg.end(), CSerializeData());
2488     ssSend.GetAndClear(*it);
2489     nSendSize += (*it).size();
2490
2491     // If write queue empty, attempt "optimistic write"
2492     if (it == vSendMsg.begin())
2493         SocketSendData(this);
2494
2495     LEAVE_CRITICAL_SECTION(cs_vSend);
2496 }
2497
2498 //
2499 // CBanDB
2500 //
2501
2502 CBanDB::CBanDB()
2503 {
2504     pathBanlist = GetDataDir() / "banlist.dat";
2505 }
2506
2507 bool CBanDB::Write(const banmap_t& banSet)
2508 {
2509     // Generate random temporary filename
2510     unsigned short randv = 0;
2511     GetRandBytes((unsigned char*)&randv, sizeof(randv));
2512     std::string tmpfn = strprintf("banlist.dat.%04x", randv);
2513
2514     // serialize banlist, checksum data up to that point, then append csum
2515     CDataStream ssBanlist(SER_DISK, CLIENT_VERSION);
2516     ssBanlist << FLATDATA(Params().MessageStart());
2517     ssBanlist << banSet;
2518     uint256 hash = Hash(ssBanlist.begin(), ssBanlist.end());
2519     ssBanlist << hash;
2520
2521     // open temp output file, and associate with CAutoFile
2522     boost::filesystem::path pathTmp = GetDataDir() / tmpfn;
2523     FILE *file = fopen(pathTmp.string().c_str(), "wb");
2524     CAutoFile fileout(file, SER_DISK, CLIENT_VERSION);
2525     if (fileout.IsNull())
2526         return error("%s: Failed to open file %s", __func__, pathTmp.string());
2527
2528     // Write and commit header, data
2529     try {
2530         fileout << ssBanlist;
2531     }
2532     catch (const std::exception& e) {
2533         return error("%s: Serialize or I/O error - %s", __func__, e.what());
2534     }
2535     FileCommit(fileout.Get());
2536     fileout.fclose();
2537
2538     // replace existing banlist.dat, if any, with new banlist.dat.XXXX
2539     if (!RenameOver(pathTmp, pathBanlist))
2540         return error("%s: Rename-into-place failed", __func__);
2541
2542     return true;
2543 }
2544
2545 bool CBanDB::Read(banmap_t& banSet)
2546 {
2547     // open input file, and associate with CAutoFile
2548     FILE *file = fopen(pathBanlist.string().c_str(), "rb");
2549     CAutoFile filein(file, SER_DISK, CLIENT_VERSION);
2550     if (filein.IsNull())
2551         return error("%s: Failed to open file %s", __func__, pathBanlist.string());
2552
2553     // use file size to size memory buffer
2554     uint64_t fileSize = boost::filesystem::file_size(pathBanlist);
2555     uint64_t dataSize = 0;
2556     // Don't try to resize to a negative number if file is small
2557     if (fileSize >= sizeof(uint256))
2558         dataSize = fileSize - sizeof(uint256);
2559     vector<unsigned char> vchData;
2560     vchData.resize(dataSize);
2561     uint256 hashIn;
2562
2563     // read data and checksum from file
2564     try {
2565         filein.read((char *)&vchData[0], dataSize);
2566         filein >> hashIn;
2567     }
2568     catch (const std::exception& e) {
2569         return error("%s: Deserialize or I/O error - %s", __func__, e.what());
2570     }
2571     filein.fclose();
2572
2573     CDataStream ssBanlist(vchData, SER_DISK, CLIENT_VERSION);
2574
2575     // verify stored checksum matches input data
2576     uint256 hashTmp = Hash(ssBanlist.begin(), ssBanlist.end());
2577     if (hashIn != hashTmp)
2578         return error("%s: Checksum mismatch, data corrupted", __func__);
2579
2580     unsigned char pchMsgTmp[4];
2581     try {
2582         // de-serialize file header (network specific magic number) and ..
2583         ssBanlist >> FLATDATA(pchMsgTmp);
2584
2585         // ... verify the network matches ours
2586         if (memcmp(pchMsgTmp, Params().MessageStart(), sizeof(pchMsgTmp)))
2587             return error("%s: Invalid network magic number", __func__);
2588
2589         // de-serialize address data into one CAddrMan object
2590         ssBanlist >> banSet;
2591     }
2592     catch (const std::exception& e) {
2593         return error("%s: Deserialize or I/O error - %s", __func__, e.what());
2594     }
2595
2596     return true;
2597 }
2598
2599 void DumpBanlist()
2600 {
2601     int64_t nStart = GetTimeMillis();
2602
2603     CNode::SweepBanned(); //clean unused entries (if bantime has expired)
2604
2605     CBanDB bandb;
2606     banmap_t banmap;
2607     CNode::GetBanned(banmap);
2608     bandb.Write(banmap);
2609
2610     LogPrint("net", "Flushed %d banned node ips/subnets to banlist.dat  %dms\n",
2611              banmap.size(), GetTimeMillis() - nStart);
2612 }