Realtime Price(实时价格):

比特币源码分析–P2P网络初始化

比特币布道者1,002 次浏览
作者：jupiterwangq
发布时间：2018年5月14日
网络来源：https://blog.csdn.net/ztemt_sw2/article/details/80291705

     区块链和AI无疑是近期业界当之无愧的两大风口。AI就不说了，区块链从17年各种数字货币被炒上了天，一下成为了人们街头巷议的焦点，本文撇开数字货币的投资不说，仅仅从技术层面来剖析一下区块链各个部分的原理。毕竟目前已经有包括BAT等巨头在内的许多公司投入到了区块链的研发，其相关的应用相信也会越来越多的落地，作为技术人员，学习一下区块链的源码，抓住这个风口是非常值得的。

本系列将以比特币区块链作为学习的对象，这是所有区块链项目的始祖，也是学习区块链的最佳原材料。另外对于区块链的学习，建议可以先看一下《精通比特币》这本书，对比特币整体的原理有一定了解后，再结合源码一块块的学习将会事半功倍。

因为区块链的本质是一个建立在P2P网络上的分布式数据库，所以P2P网络可以算得上是区块链的一块基石，我们就以P2P网络作为切入点来开始比特币源码的学习。本文将结合比特币源码，分析比特币P2P网络中的一个节点是如何发现其他节点并与之建立数据通信的通道。

由于作者本人也是区块链新手，所以文中有错误的地方也欢迎大家指正。

1、源码获取

比特币是一个开源项目，其源码可以从以下github链接上获取：

https://github.com/bitcoin/bitcoin

关于源码的编译，在《精通比特币》一书中有较为详细的说明，有兴趣的读者可以参考此书中的说明尝试去编译一下。

2、比特币P2P网络

区块链从本质上讲就是建立在一个P2P网络上的分布式数据库，然后采用PoW或者PoS等共识算法让网络上的节点对某件事情（比如比特币交易）达成共识。因此在了解比特币其他模块之前，先了解比特币的P2P网络是一个比较好的切入点。本文就从源码的角度来分析一下比特币网络相关的知识点，比如一个新启动的节点是如何发现并连接其他节点的，其他网络的节点又是如何连接到我们的节点上。

2.1、节点发现

当一个新的网络节点启动后，为了能够参与协同运作，它必须至少发现一个其他网络中的节点并与之建立连接。比特币的网络拓扑结构不基于地理位置，因此可以随机的选择节点建立连接。

那么一个新启动的节点是如何发现其他网络的节点呢？比特币网络采用了两种方式：

(1) 利用种子节点

比特币的客户端会维护一个列表，列表中记录了长期稳定运行的节点，这些节点也被称之为种子节点。连接到种子节点的好处就是新节点可以快速的发现网络中的其他节点。在比特币里，可以通过选项“-dnsseed”来指定是否使用种子节点，该选项默认是开启的。

(2) 节点引荐

除了使用种子节点外，还可以将当前启动节点引荐给其他节点的方式。可以通过“-seednode”选项指定一个节点的ip，之后节点将和该节点建立连接，将该节点作为DNS种子节点，在引荐信息形成之后断开与该节点的连接，并与新发现的节点连接。

2.2 握手协议

当节点与对等节点建立好连接后，首先要做的就是握手。其过程如下：

(1)节点向peer发送version消息开始握手，此消息中包含如下一些内容：

PROTOCOL_VERSION:当前节点的比特币P2P协议的版本号；

nLocalServices:节点支持的本地服务列表，目前仅支持NODE_NETWORK;

nTime:当前时间；

addrYou:当前节点可见的远程节点的IP地址；

addrMe:本节点发现的本地IP地址；

subver：当前节点运行的软件类型的子版本号；

baseHeight:当前节点上的区块链的高度。

对等节点收到version消息后，会回应verack进行确认并建立连接。有时候对等端可能需要互换连接并连回起始节点，此时对等端也会发送该节点的version消息。

参考下图：

2.3、地址广播及发现

完成握手协议后，新节点将会发送一条包含自己IP地址的addr消息给对等端，对等端收到以后又向与它连接的相邻节点发送addr消息，这样新节点的ip地址就会在P2P网络中广播出去。此外新节点还可以发送getaddr消息，要求对等端把自己知道的节点的IP地址发送过来。通过这种方式，新节点可以找到需要连接的对等节点。如下图：

节点必须连接到若干不同的对等节点才能在比特币网络中建立通向比特币网络的种类各异的路径（path）。由于节点可以随时加入和离开，通讯路径是不可靠的。因此，节点必须持续进行两项工作：在失去已有连接时发现新节点，并在其他节点启动时为其提供帮助。节点启动时只需要一个连接，因为第一个节点可以将它引荐给它的对等节点，而这些节点又会进一步提供引荐。一个节点，如果连接到大量的其他对等节点，这既没必要，也是对网络资源的浪费。在启动完成后，节点会记住它最近成功连接的对等节点；因此，当重新启动后它可以迅速与先前的对等节点网络重新建立连接。如果先前的网络的对等节点对连接请求无应答，该节点可以使用种子节点进行重启动。

用户可以通过提供-connect=<IP地址>选项来指定一个或多个IP地址，从而达到复写自动节点管理功能并指定IP地址列表的目的。如果采用此选项，节点只连接到这些选定的节点IP地址，而不会自动发现并维护对等节点之间的连接。

如果已建立的连接没有数据通信，所在的节点会定期发送信息以维持连接。如果节点持续某个连接长达90分钟没有任何通信，它会被认为已经从网络中断开，网络将开始查找一个新的对等节点。因此，比特币网络会随时根据变化的节点及网络问题进行动态调整，不需经过中心化的控制即可进行规模增、减的有机调整。

3、源码分析

以上分析了比特币P2P网络中的握手协议，以及地址的广播扩散的原理。这一节我们就来分析源码，看看上面描述的这些交互过程在代码中是如何体现的。

3.1、初始化参数

比特币核心的入口函数main函数位于文件bitcoind.cpp中，入口函数非常简短：

  1. int main(int argc, char* argv[])
  2. {
  3. SetupEnvironment();
  5. // Connect bitcoind signal handlers
  6. noui_connect();
  8. return (AppInit(argc, argv) ? EXIT_SUCCESS : EXIT_FAILURE);
  9. }

比特币核心的初始化操作的重任基本上都在AppInit这个函数里。我们对这个函数抽丝剥茧，一步一步的展开分析。

  1. static bool AppInit(int argc, char* argv[])
  2. {
  3. bool fRet = false;
  5. //
  6. // Parameters
  7. //
  8. // If Qt is used, parameters/bitcoin.conf are parsed in qt/bitcoin.cpp’s main()
  9. SetupServerArgs();

第一个调用的就是SetupServerArgs，这里会初始化整个服务端的相关参数，给一些默认值。首先来认识几个类：

3.1.1 CBaseChainParams

这是比特币客户端(bitcoin_cli)和服务端共享的一个类，定义了基本的比特币参数，主要是比特币的数据存储目录和相互通信的rpc端口号。这个类比较简单，可以一窥源码：

  1. class CBaseChainParams
  2. {
  3. public:
  4. /** BIP70 chain name strings (main, test or regtest) */
  5. static const std::string MAIN;
  6. static const std::string TESTNET;
  7. static const std::string REGTEST;
  9. const std::string& DataDir() const { return strDataDir; }
  10. int RPCPort() const { return nRPCPort; }
  12. CBaseChainParams() = delete;
  13. CBaseChainParams(const std::string& data_dir, int rpc_port) : nRPCPort(rpc_port), strDataDir(data_dir) {}
  15. private:
  16. int nRPCPort;
  17. std::string strDataDir;
  18. };

里面就两个成员：nRPCPort定义了客户端和服务端通信的rpc端口，strDataDir定义了数据存储的目录。

3.1.2 CChainParams

这个类定义了比特币系统的很多比较重要的参数。我们看看都有哪些：

  1.     Consensus::Params consensus;
  2. CMessageHeader::MessageStartChars pchMessageStart;
  3. int nDefaultPort;
  4. uint64_t nPruneAfterHeight;
  5. std::vector<std::string> vSeeds;
  6. std::vector<unsigned char> base58Prefixes[MAX_BASE58_TYPES];
  7. std::string bech32_hrp;
  8. std::string strNetworkID;
  9. CBlock genesis;
  10. std::vector<SeedSpec6> vFixedSeeds;
  11. bool fDefaultConsistencyChecks;
  12. bool fRequireStandard;
  13. bool fMineBlocksOnDemand;
  14. CCheckpointData checkpointData;
  15. ChainTxData chainTxData;
  16. bool m_fallback_fee_enabled;

比较多，这里我们就关注几个和比特币网络相关的参数：

nDefaultPort:比特币P2P网络默认的监听端口，默认是8333。

vSeeds:这个是比特币代码中内置的一些DNS种子节点。在默认开启-dnsseed选项并且不指定-connect的情况下，新节点启动时将尝试通过这些种子节点加入P2P网络中。

3.1.3 CMainParams

这个类继承自上一节的CChainParams。这个类的构造函数里初始化了比特币系统的一些核心参数。另外比特币创世区块（区块链上第一个区块）也是在这里生成的。这里暂且先不关心其他的，先把关注点放在P2P网络相关的事情上来。

在这个类的构造函数中内置了一些种子节点：

  1. // Note that of those which support the service bits prefix, most only support a subset of
  2. // possible options.
  3. // This is fine at runtime as we’ll fall back to using them as a oneshot if they don’t support the
  4. // service bits we want, but we should get them updated to support all service bits wanted by any
  5. // release ASAP to avoid it where possible.
  6. vSeeds.emplace_back(“seed.bitcoin.sipa.be”); // Pieter Wuille, only supports x1, x5, x9, and xd
  7. vSeeds.emplace_back(“dnsseed.bluematt.me”); // Matt Corallo, only supports x9
  8. vSeeds.emplace_back(“dnsseed.bitcoin.dashjr.org”); // Luke Dashjr
  9. vSeeds.emplace_back(“seed.bitcoinstats.com”); // Christian Decker, supports x1 – xf
  10. vSeeds.emplace_back(“seed.bitcoin.jonasschnelli.ch”); // Jonas Schnelli, only supports x1, x5, x9, and xd
  11. vSeeds.emplace_back(“seed.btc.petertodd.org”); // Peter Todd, only supports x1, x5, x9, and xd
  12. vSeeds.emplace_back(“seed.bitcoin.sprovoost.nl”); // Sjors Provoost

感兴趣的同学可以用DNS查询工具来查询这些种子。

认识了这三个记录了比特币系统运行所必须的参数的类以后，回到之前提到的SetupServerArgs这个函数：

  1. void SetupServerArgs()
  2. {
  3. const auto defaultBaseParams = CreateBaseChainParams(CBaseChainParams::MAIN);
  4. const auto testnetBaseParams = CreateBaseChainParams(CBaseChainParams::TESTNET);
  5. const auto defaultChainParams = CreateChainParams(CBaseChainParams::MAIN);
  6. const auto testnetChainParams = CreateChainParams(CBaseChainParams::TESTNET);

可以看到这里针对比特币主网和测试用公网生成了不同的默认参数。

最终这些参数信息将保存在全局变量中，方便其他模块引用：globalChainParams和globalChainBaseParams。

AppInit函数的最后，会调用AppInitMain，完成整个系统的初始化，AppInitMain比较重，比特币系统核心的东西基本上都从这里诞生。

3.2 比特币P2P网络组件

在继续了解比特币网络的连接过程之前，需要先简单了解一些和网络相关的封装类。逐一过一下。

3.2.1 CConnman

顾名思义，这个类是网络连接的管理类。负责节点的初始化及启动，P2P消息的推送及接收，接收其他节点的连接等等。这个类比较庞大。

3.2.2 PeerLogicValidation

这个类多重继承了两个接口类CValidationInterface和NetEventsInterface。其中CValidationInterface是和钱包相关的一个接口，暂且不提。NetEventsInterface是和网络相关的，看一下这个接口的定义：

  1. class NetEventsInterface
  2. {
  3. public:
  4. virtual bool ProcessMessages(CNode* pnode, std::atomic<bool>& interrupt) = 0;
  5. virtual bool SendMessages(CNode* pnode, std::atomic<bool>& interrupt) = 0;
  6. virtual void InitializeNode(CNode* pnode) = 0;
  7. virtual void FinalizeNode(NodeId id, bool& update_connection_time) = 0;
  9. protected:
  10. /**
  11. * Protected destructor so that instances can only be deleted by derived classes.
  12. * If that restriction is no longer desired, this should be made public and virtual.
  13. */
  14. ~NetEventsInterface() = default;
  15. };

NetEventsInterface::ProcessMessage：处理接收到的消息；

NetEventsInterface::SendMessage:发送消息；

NetEventsInterface::InitializeNode:初始化节点；

3.2.3 CNode

维护节点信息，包括通信的套接字，发送缓冲区，接收缓冲区等等。

3.2.4 CNetAddr和CService

对IP地址的封装（IPV4和IPV6）.

  1. class CNetAddr
  2. {
  3. protected:
  4. unsigned char ip[16]; // in network byte order
  5. uint32_t scopeId; // for scoped/link-local ipv6 addresses

可以看到其主要属性就是一个ip地址。另外这个类里还包含了一些对IP地址类型进行各种判断的工具函数。

CService继承了CNetAddr,再其基础上多了端口号的属性。

  1. class CService : public CNetAddr
  2. {
  3. protected:
  4. uint16_t port; // host order

3.3 利用种子发现节点

本文之前已经提到过，新启动的节点首先需要发现网络中的其他节点并与之建立连接。发现节点可以通过内置的种子节点，也可以在启动bitcoind时通过-dnsseed选项指定一个种子节点。接下来就逐步分析代码里是如何实现的。

继续看AppInitMain这个函数，他会创建出上一节提到的连接管理器对象：

  1. g_connman = std::unique_ptr<CConnman>(new CConnman(GetRand(std::numeric_limits<uint64_t>::max()), GetRand(std::numeric_limits<uint64_t>::max())));
  2. CConnman& connman = *g_connman;
  4. peerLogic.reset(new PeerLogicValidation(&connman, scheduler));

这两个对象均为全局变量。

接下来将调用Discover函数，找到所有的本地网络接口地址，并保存起来。这些地址在随后将发送给连接到的对等节点（广播本机地址）。

  1. void Discover()
  2. {
  3. if (!fDiscover)
  4. return;
  6. #ifdef WIN32
  7. // Get local host IP
  8. char pszHostName[256] = “”;
  9. if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR)
  10. {
  11. std::vector<CNetAddr> vaddr;
  12. if (LookupHost(pszHostName, vaddr, 0, true))
  13. {
  14. for (const CNetAddr &addr : vaddr)
  15. {
  16. if (AddLocal(addr, LOCAL_IF))
  17. LogPrintf(“%s: %s – %s\n”, __func__, pszHostName, addr.ToString());
  18. }
  19. }
  20. }
  21. #else
  22. // Get local host ip
  23. struct ifaddrs* myaddrs;
  24. if (getifaddrs(&myaddrs) == 0)
  25. {
  26. for (struct ifaddrs* ifa = myaddrs; ifa != nullptr; ifa = ifa->ifa_next)
  27. {
  28. if (ifa->ifa_addr == nullptr) continue;
  29. if ((ifa->ifa_flags & IFF_UP) == 0) continue;
  30. if (strcmp(ifa->ifa_name, “lo”) == 0) continue;
  31. if (strcmp(ifa->ifa_name, “lo0”) == 0) continue;
  32. if (ifa->ifa_addr->sa_family == AF_INET)
  33. {
  34. struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
  35. CNetAddr addr(s4->sin_addr);
  36. if (AddLocal(addr, LOCAL_IF))
  37. LogPrintf(“%s: IPv4 %s: %s\n”, __func__, ifa->ifa_name, addr.ToString());
  38. }
  39. else if (ifa->ifa_addr->sa_family == AF_INET6)
  40. {
  41. struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
  42. CNetAddr addr(s6->sin6_addr);
  43. if (AddLocal(addr, LOCAL_IF))
  44. LogPrintf(“%s: IPv6 %s: %s\n”, __func__, ifa->ifa_name, addr.ToString());
  45. }
  46. }
  47. freeifaddrs(myaddrs);
  48. }
  49. #endif
  50. }

主要就是调用getifaddrs这个网络api获取所有的本地地址，并调用AddLocal将这些地址添加到保存本地地址的全局变量中。这个后续在说明广播本地地址给相邻节点时还会提到，暂且略过。

接着初始化一个封装网络连接各种参数的CConnman::Options对象：

  1.     CConnman::Options connOptions;
  2. connOptions.nLocalServices = nLocalServices;
  3. connOptions.nMaxConnections = nMaxConnections;
  4. connOptions.nMaxOutbound = std::min(MAX_OUTBOUND_CONNECTIONS, connOptions.nMaxConnections);
  5. connOptions.nMaxAddnode = MAX_ADDNODE_CONNECTIONS;
  6. connOptions.nMaxFeeler = 1;
  7. connOptions.nBestHeight = chain_active_height;
  8. connOptions.uiInterface = &uiInterface;
  9. connOptions.m_msgproc = peerLogic.get();
  10. connOptions.nSendBufferMaxSize = 1000*gArgs.GetArg(“-maxsendbuffer”, DEFAULT_MAXSENDBUFFER);
  11. connOptions.nReceiveFloodSize = 1000*gArgs.GetArg(“-maxreceivebuffer”, DEFAULT_MAXRECEIVEBUFFER);
  12. connOptions.m_added_nodes = gArgs.GetArgs(“-addnode”);
  14. connOptions.nMaxOutboundTimeframe = nMaxOutboundTimeframe;
  15. connOptions.nMaxOutboundLimit = nMaxOutboundLimit;

这些参数包含了后续网络连接及通信过程中的很多参数，比如一个节点允许的最大连接数，能够连接的外部节点的最大数目，-seednode选项指定的种子节点等等。如果运行bitcoind时通过-seednode指定了种子节点，这些种子节点也会被保存进来：

    connOptions.vSeedNodes = gArgs.GetArgs("-seednode");

接下来，启动节点、发现节点的过程就正式拉开序幕了：

  1.     if (!connman.Start(scheduler, connOptions)) {
  2. return false;
  3. }

调用CConnman::Start开始，一个崭新的节点即将诞生了。

首先需要用前面生成的CConnman::Options对CConnman进行初始化，很简单：

    Init(connOptions);

其实就是将Options里面的值复制一份给CConnman相应的字段而已。

接下来就要加载已经保存的节点的地址了。之前在说明节点发现的原理时提到过，这里在温习一下：

在启动完成后，节点会记住它最近成功连接的对等节点；因此，当重新启动后它可以迅速与先前的对等节点网络重新建立连接。如果先前的网络的对等节点对连接请求无应答，该节点可以使用种子节点进行重启动。

加载先前连接过的对等节点的地址的代码：

  1.     // Load addresses from peers.dat
  2. int64_t nStart = GetTimeMillis();
  3. {
  4. CAddrDB adb;
  5. if (adb.Read(addrman))
  6. LogPrintf(“Loaded %i addresses from peers.dat %dms\n”, addrman.size(), GetTimeMillis() – nStart);
  7. else {
  8. addrman.Clear(); // Addrman can be in an inconsistent state after failure, reset it
  9. LogPrintf(“Invalid or missing peers.dat; recreating\n”);
  10. DumpAddresses();
  11. }
  12. }
  13. if (clientInterface)
  14. clientInterface->InitMessage(_(“Loading banlist…”));
  15. // Load addresses from banlist.dat
  16. nStart = GetTimeMillis();
  17. CBanDB bandb;
  18. banmap_t banmap;
  19. if (bandb.Read(banmap)) {
  20. SetBanned(banmap); // thread save setter
  21. SetBannedSetDirty(false); // no need to write down, just read data
  22. SweepBanned(); // sweep out unused entries
  24. LogPrint(BCLog::NET, “Loaded %d banned node ips/subnets from banlist.dat %dms\n”,
  25. banmap.size(), GetTimeMillis() – nStart);
  26. } else {
  27. LogPrintf(“Invalid or missing banlist.dat; recreating\n”);
  28. SetBannedSetDirty(true); // force write
  29. DumpBanlist();
  30. }

其中CAddrMan暂时不必细究，把它理解成一个小型DB即可。

最后CConnman将调兵遣将，把任务交给几个线程去做：

(1) net线程

  1.     // Send and receive from sockets, accept connections
  2. threadSocketHandler = std::thread(&TraceThread<std::function<void()> >, “net”, std::function<void()>(std::bind(&CConnman::ThreadSocketHandler, this)));

从注释上就知道，这个”net”线程的任务就是从套接字发送和接收数据，同时还要监听其他节点的连接请求。

(2) dnsseed线程

  1.     if (!gArgs.GetBoolArg(“-dnsseed”, true))
  2. LogPrintf(“DNS seeding disabled\n”);
  3. else
  4. threadDNSAddressSeed = std::thread(&TraceThread<std::function<void()> >, “dnsseed”, std::function<void()>(std::bind(&CConnman::ThreadDNSAddressSeed, this)));

这个线程名字就叫做”dnsseed”，它的作用是通过dns查询解析出种子节点的地址，之后新启动的节点将要向这些种子节点发起连接。

(3)opencon线程

  1.     if (connOptions.m_use_addrman_outgoing || !connOptions.m_specified_outgoing.empty())
  2. threadOpenConnections = std::thread(&TraceThread<std::function<void()> >, “opencon”, std::function<void()>(std::bind(&CConnman::ThreadOpenConnections, this, connOptions.m_specified_outgoing)));

这个线程将负责向已发现的节点发起连接。

(4)msghand线程

  1.     // Process messages
  2. threadMessageHandler = std::thread(&TraceThread<std::function<void()> >, “msghand”, std::function<void()>(std::bind(&CConnman::ThreadMessageHandler, this)));

此线程将负责比特币P2P协议的消息处理。

接下来我们各个击破，对这四个线程进行逐一分析。

3.3.1 解析种子节点

首先来看看种子节点的解析，之前提到过，利用种子发现节点有两种方式，一种是开启-dnsseed选项（默认开启）连接内置的一些由专人维护的比较稳定的DNS种子，还由一种是通过-seednode选项指定种子节点。这里dnsseed线程的作用是在开启-dnsseed选项时，解析比特币P2P网络内置的DNS种子：

  1. void CConnman::ThreadDNSAddressSeed()
  2. {
  3. // goal: only query DNS seeds if address need is acute
  4. // Avoiding DNS seeds when we don’t need them improves user privacy by
  5. // creating fewer identifying DNS requests, reduces trust by giving seeds
  6. // less influence on the network topology, and reduces traffic to the seeds.
  7. if ((addrman.size() > 0) &&
  8. (!gArgs.GetBoolArg(“-forcednsseed”, DEFAULT_FORCEDNSSEED))) {
  9. if (!interruptNet.sleep_for(std::chrono::seconds(11)))
  10. return;
  12. LOCK(cs_vNodes);
  13. int nRelevant = 0;
  14. for (auto pnode : vNodes) {
  15. nRelevant += pnode->fSuccessfullyConnected && !pnode->fFeeler && !pnode->fOneShot && !pnode->m_manual_connection && !pnode->fInbound;
  16. }
  17. if (nRelevant >= 2) {
  18. LogPrintf(“P2P peers available. Skipped DNS seeding.\n”);
  19. return;
  20. }
  21. }
  23. const std::vector<std::string> &vSeeds = Params().DNSSeeds();
  24. int found = 0;
  26. LogPrintf(“Loading addresses from DNS seeds (could take a while)\n”);
  28. for (const std::string &seed : vSeeds) {
  29. if (interruptNet) {
  30. return;
  31. }
  32. if (HaveNameProxy()) {
  33. AddOneShot(seed);
  34. } else {
  35. std::vector<CNetAddr> vIPs;
  36. std::vector<CAddress> vAdd;
  37. ServiceFlags requiredServiceBits = GetDesirableServiceFlags(NODE_NONE);
  38. std::string host = strprintf(“x%x.%s”, requiredServiceBits, seed);
  39. CNetAddr resolveSource;
  40. if (!resolveSource.SetInternal(host)) {
  41. continue;
  42. }
  43. unsigned int nMaxIPs = 256; // Limits number of IPs learned from a DNS seed
  44. if (LookupHost(host.c_str(), vIPs, nMaxIPs, true))
  45. {
  46. for (const CNetAddr& ip : vIPs)
  47. {
  48. int nOneDay = 24*3600;
  49. CAddress addr = CAddress(CService(ip, Params().GetDefaultPort()), requiredServiceBits);
  50. addr.nTime = GetTime() – 3*nOneDay – GetRand(4*nOneDay); // use a random age between 3 and 7 days old
  51. vAdd.push_back(addr);
  52. found++;
  53. }
  54. addrman.Add(vAdd, resolveSource);
  55. } else {
  56. // We now avoid directly using results from DNS Seeds which do not support service bit filtering,
  57. // instead using them as a oneshot to get nodes with our desired service bits.
  58. AddOneShot(seed);
  59. }
  60. }
  61. }
  63. LogPrintf(“%d addresses found from DNS seeds\n”, found);
  64. }

这个线程的工作其实比较简单，代码也比较短。简单来分析一下：

(1) 首先通过Params().DNSSeeds()拿到内置的DNS种子节点，这个在前文提到过的CMainParams的构造函数中已经说明，比特币系统已经内置了一些DNS种子在里面。

(2) 对于每个种子，通过LookupHost调用，进行DNS查询，这个函数最终调用的是操作系统api：getaddrinfo，解析到的ip地址将存入CAddrMan中以备后用。

3.3.2 节点连接的建立

上一节已经解析出了比特币系统内置的DNS种子节点，接下来就要连接这些节点。连接工作由上一节提到的opencon线程来处理。这个线程代码稍长，挑主要的来分析。

(1) 连接由-seednode指定的种子节点

如果用户通过-seednode指定了种子节点，那么将尝试连接这些种子节点（这是节点发现的第二种方式）

  1.     while (!interruptNet)
  2. {
  3. ProcessOneShot();

ProcessOneshot函数的实现如下：

  1. void CConnman::ProcessOneShot()
  2. {
  3. std::string strDest;
  4. {
  5. LOCK(cs_vOneShots);
  6. if (vOneShots.empty())
  7. return;
  8. strDest = vOneShots.front();
  9. vOneShots.pop_front();
  10. }
  11. CAddress addr;
  12. CSemaphoreGrant grant(*semOutbound, true);
  13. if (grant) {
  14. OpenNetworkConnection(addr, false, &grant, strDest.c_str(), true);
  15. }
  16. }

最终调用了OpenNetworkConnection来连接这些种子节点。

(2) 如果CAddrMan中有记录的地址信息（上一次连接过的peer的地址或者是解析出来的内置dns种子的地址），同样调用OpenNetworkConnection来发起连接。

继续抽丝剥茧，揭开OpenNetworkConnection这个函数的神秘面纱，看看他是如何发起连接的。

  1. void CConnman::OpenNetworkConnection(const CAddress& addrConnect, bool fCountFailure, CSemaphoreGrant *grantOutbound, const char *pszDest, bool fOneShot, bool fFeeler, bool manual_connection)
  2. {
  3. //
  4. // Initiate outbound network connection
  5. //
  6. if (interruptNet) {
  7. return;
  8. }
  9. if (!fNetworkActive) {
  10. return;
  11. }
  12. if (!pszDest) {
  13. if (IsLocal(addrConnect) ||
  14. FindNode(static_cast<CNetAddr>(addrConnect)) || IsBanned(addrConnect) ||
  15. FindNode(addrConnect.ToStringIPPort()))
  16. return;
  17. } else if (FindNode(std::string(pszDest)))
  18. return;
  20. CNode* pnode = ConnectNode(addrConnect, pszDest, fCountFailure, manual_connection);
  22. if (!pnode)
  23. return;
  24. if (grantOutbound)
  25. grantOutbound->MoveTo(pnode->grantOutbound);
  26. if (fOneShot)
  27. pnode->fOneShot = true;
  28. if (fFeeler)
  29. pnode->fFeeler = true;
  30. if (manual_connection)
  31. pnode->m_manual_connection = true;
  33. m_msgproc->InitializeNode(pnode);
  34. {
  35. LOCK(cs_vNodes);
  36. vNodes.push_back(pnode);
  37. }
  38. }

代码很短，除了一些错误检查外，主要是两步：ConnectNode创建节点，InitializeNode初始化节点。其中连接已发现节点在ConnectNode中完成，而前文提到的握手协议（发送version握手消息）则在InitializeNode中发起。节点之间的握手后文单独分析。先看节点的连接。

ConnectNode函数先做一些检查，以确保给定的节点地址还没有连接。之后将创建套接字，并建立网络连接：

  1. if (addrConnect.IsValid()) {
  2. bool proxyConnectionFailed = false;
  4. if (GetProxy(addrConnect.GetNetwork(), proxy)) {
  5. hSocket = CreateSocket(proxy.proxy);
  6. if (hSocket == INVALID_SOCKET) {
  7. return nullptr;
  8. }
  9. connected = ConnectThroughProxy(proxy, addrConnect.ToStringIP(), addrConnect.GetPort(), hSocket, nConnectTimeout, &proxyConnectionFailed);
  10. } else {
  11. // no proxy needed (none set for target network)
  12. hSocket = CreateSocket(addrConnect);
  13. if (hSocket == INVALID_SOCKET) {
  14. return nullptr;
  15. }
  16. connected = ConnectSocketDirectly(addrConnect, hSocket, nConnectTimeout, manual_connection);
  17. }

这里根据是否有设置代理分别进行处理，对于不配置代理的情况，将直接通过ConnectSocketDirectly来连接，其内部是调用socket api的connect函数。如果一切正常，那么此时到所有发现的节点的网络连接就已经建立起来了，两个节点之间就可以互通数据。ConnectNode函数的最后，会创建一个CNode对象，将连接好的套接字及其他必要的信息封装起来：

  1.     NodeId id = GetNewNodeId();
  2. uint64_t nonce = GetDeterministicRandomizer(RANDOMIZER_ID_LOCALHOSTNONCE).Write(id).Finalize();
  3. CAddress addr_bind = GetBindAddress(hSocket);
  4. CNode* pnode = new CNode(id, nLocalServices, GetBestHeight(), hSocket, addrConnect, CalculateKeyedNetGroup(addrConnect), nonce, addr_bind, pszDest ? pszDest : “”, false);
  5. pnode->AddRef();

可以看到，CNode封装了许多的东西，包括已连接的套接字，本节点支持的服务，本节点当前的区块高度等等。生成的节点将会加入到集合中。

连接好以后，两个节点就可以开始握手交互了。

3.3.3 通过套接字收发数据

上一节描述了节点是如何连接到发现相邻节点的。这一节来看看是如何通过套接字收发数据的。收发数据是在net线程中完成的。线程函数体为CConnman::ThreadSocketHandler。相信有过网络编程基础的同学对这一部分会倍感亲切。我们截取其主要代码一窥究竟。值得注意的是消息的收发是有net线程和msghand线程协同处理的：msghand线程在条件变量上阻塞等待节点的新消息的到来，net线程从套接字读取数据，将数据拼接成消息放到节点的消息缓冲区中，并通知msghand线程有新消息可以处理了。

ThreadSocketHandler将遍历所有节点，将其套接字加入到接收描述符集合、发送描述符集合中，然后通过select函数等待相应的描述符中的读写事件的到来：

  1.             LOCK(cs_vNodes);
  2. for (CNode* pnode : vNodes)
  3. {
  4. // Implement the following logic:
  5. // * If there is data to send, select() for sending data. As this only
  6. // happens when optimistic write failed, we choose to first drain the
  7. // write buffer in this case before receiving more. This avoids
  8. // needlessly queueing received data, if the remote peer is not themselves
  9. // receiving data. This means properly utilizing TCP flow control signalling.
  10. // * Otherwise, if there is space left in the receive buffer, select() for
  11. // receiving data.
  12. // * Hand off all complete messages to the processor, to be handled without
  13. // blocking here.
  15. bool select_recv = !pnode->fPauseRecv;
  16. bool select_send;
  17. {
  18. LOCK(pnode->cs_vSend);
  19. select_send = !pnode->vSendMsg.empty();
  20. }
  22. LOCK(pnode->cs_hSocket);
  23. if (pnode->hSocket == INVALID_SOCKET)
  24. continue;
  26. FD_SET(pnode->hSocket, &fdsetError);
  27. hSocketMax = std::max(hSocketMax, pnode->hSocket);
  28. have_fds = true;
  30. if (select_send) {
  31. FD_SET(pnode->hSocket, &fdsetSend);
  32. continue;
  33. }
  34. if (select_recv) {
  35. FD_SET(pnode->hSocket, &fdsetRecv);
  36. }
  37. }
  38. }
  40. int nSelect = select(have_fds ? hSocketMax + 1 : 0,
  41. &fdsetRecv, &fdsetSend, &fdsetError, &timeout);

(1) 接收数据并处理

当某个节点的套接字可读时，将从套接字读取数据并把数据添加到节点的接收缓冲区（pNode->ReceiveMsgBytes）：

  1.         for (CNode* pnode : vNodesCopy)
  2. {
  3. if (interruptNet)
  4. return;
  6. //
  7. // Receive
  8. //
  9. bool recvSet = false;
  10. bool sendSet = false;
  11. bool errorSet = false;
  12. {
  13. LOCK(pnode->cs_hSocket);
  14. if (pnode->hSocket == INVALID_SOCKET)
  15. continue;
  16. recvSet = FD_ISSET(pnode->hSocket, &fdsetRecv);
  17. sendSet = FD_ISSET(pnode->hSocket, &fdsetSend);
  18. errorSet = FD_ISSET(pnode->hSocket, &fdsetError);
  19. }
  20. if (recvSet || errorSet)
  21. {
  22. // typical socket buffer is 8K-64K
  23. char pchBuf[0x10000];
  24. int nBytes = 0;
  25. {
  26. LOCK(pnode->cs_hSocket);
  27. if (pnode->hSocket == INVALID_SOCKET)
  28. continue;
  29. nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
  30. }
  31. if (nBytes > 0)
  32. {
  33. bool notify = false;
  34. if (!pnode->ReceiveMsgBytes(pchBuf, nBytes, notify))
  35. pnode->CloseSocketDisconnect();
  36. RecordBytesRecv(nBytes);

最后，把接收缓冲区的数据拼接到待处理消息缓冲区，然后通知消息处理线程有新的消息需要处理：

  1.                     if (notify) {
  2. size_t nSizeAdded = 0;
  3. auto it(pnode->vRecvMsg.begin());
  4. for (; it != pnode->vRecvMsg.end(); ++it) {
  5. if (!it->complete())
  6. break;
  7. nSizeAdded += it->vRecv.size() + CMessageHeader::HEADER_SIZE;
  8. }
  9. {
  10. LOCK(pnode->cs_vProcessMsg);
  11. pnode->vProcessMsg.splice(pnode->vProcessMsg.end(), pnode->vRecvMsg, pnode->vRecvMsg.begin(), it);
  12. pnode->nProcessQueueSize += nSizeAdded;
  13. pnode->fPauseRecv = pnode->nProcessQueueSize > nReceiveFloodSize;
  14. }
  15. WakeMessageHandler();    //唤醒消息处理线程

代码中WakeMessageHandler将唤醒msghand线程，告知其有新消息可以处理了。

  1. void CConnman::WakeMessageHandler()
  2. {
  3. {
  4. std::lock_guard<std::mutex> lock(mutexMsgProc);
  5. fMsgProcWake = true;
  6. }
  7. condMsgProc.notify_one();
  8. }

msghand线程被唤醒后，将从节点的缓冲区中取出消息并进行处理。处理完后又在条件变量上阻塞等待下一条消息的到来。这属于典型的线程间的同步模型，相信码农们已经非常熟悉了。

(2) 发送数据

当某个节点的套接字可写时将数据通过套接字发送出去：

  1.             if (sendSet)
  2. {
  3. LOCK(pnode->cs_vSend);
  4. size_t nBytes = SocketSendData(pnode);
  5. if (nBytes) {
  6. RecordBytesSent(nBytes);
  7. }
  8. }

 

下一小节在分析一下msghand线程是如何处理消息的，这也是两个peer节点交互流程的最后一块拼图。

3.3.4 消息处理线程

消息处理线程的处理逻辑其实非常简单：从节点的缓冲区中取出一个消息，处理，然后阻塞等待下一条消息。

  1.         for (CNode* pnode : vNodesCopy)
  2. {
  3. if (pnode->fDisconnect)
  4. continue;
  6. // Receive messages
  7. bool fMoreNodeWork = m_msgproc->ProcessMessages(pnode, flagInterruptMsgProc);
  8. fMoreWork |= (fMoreNodeWork && !pnode->fPauseSend);
  9. if (flagInterruptMsgProc)
  10. return;
  11. // Send messages
  12. {
  13. LOCK(pnode->cs_sendProcessing);
  14. m_msgproc->SendMessages(pnode, flagInterruptMsgProc);
  15. }
  17. if (flagInterruptMsgProc)
  18. return;
  19. }
  21. {
  22. LOCK(cs_vNodes);
  23. for (CNode* pnode : vNodesCopy)
  24. pnode->Release();
  25. }
  27. std::unique_lock<std::mutex> lock(mutexMsgProc);
  28. if (!fMoreWork) {
  29. condMsgProc.wait_until(lock, std::chrono::steady_clock::now() + std::chrono::milliseconds(100), [this] { return fMsgProcWake; });
  30. }
  31. fMsgProcWake = false;

注释中其实已经比较清楚了：PeerLogicValidation::ProcessMessgae()从节点的接收缓冲区中取消息并处理，PeerLogicValidation::SendMessage将节点发送缓冲区中的消息发送出去，最后在条件变量上阻塞等待下一条消息的到来。

ProcessMessage函数的代码如下：

  1. bool PeerLogicValidation::ProcessMessages(CNode* pfrom, std::atomic<bool>& interruptMsgProc)
  2. {
  3. const CChainParams& chainparams = Params();
  4. //
  5. // Message format
  6. // (4) message start
  7. // (12) command
  8. // (4) size
  9. // (4) checksum
  10. // (x) data
  11. //
  12. bool fMoreWork = false;
  14. if (!pfrom->vRecvGetData.empty())
  15. ProcessGetData(pfrom, chainparams.GetConsensus(), connman, interruptMsgProc);
  17. if (pfrom->fDisconnect)
  18. return false;
  20. // this maintains the order of responses
  21. if (!pfrom->vRecvGetData.empty()) return true;
  23. // Don’t bother if send buffer is too full to respond anyway
  24. if (pfrom->fPauseSend)
  25. return false;
  27. std::list<CNetMessage> msgs;
  28. {
  29. LOCK(pfrom->cs_vProcessMsg);
  30. if (pfrom->vProcessMsg.empty())
  31. return false;
  32. // Just take one message
  33. msgs.splice(msgs.begin(), pfrom->vProcessMsg, pfrom->vProcessMsg.begin());
  34. pfrom->nProcessQueueSize -= msgs.front().vRecv.size() + CMessageHeader::HEADER_SIZE;
  35. pfrom->fPauseRecv = pfrom->nProcessQueueSize > connman->GetReceiveFloodSize();
  36. fMoreWork = !pfrom->vProcessMsg.empty();
  37. }
  38. CNetMessage& msg(msgs.front());
  40. msg.SetVersion(pfrom->GetRecvVersion());
  41. // Scan for message start
  42. if (memcmp(msg.hdr.pchMessageStart, chainparams.MessageStart(), CMessageHeader::MESSAGE_START_SIZE) != 0) {
  43. LogPrint(BCLog::NET, “PROCESSMESSAGE: INVALID MESSAGESTART %s peer=%d\n”, SanitizeString(msg.hdr.GetCommand()), pfrom->GetId());
  44. pfrom->fDisconnect = true;
  45. return false;
  46. }
  48. // Read header
  49. CMessageHeader& hdr = msg.hdr;
  50. if (!hdr.IsValid(chainparams.MessageStart()))
  51. {
  52. LogPrint(BCLog::NET, “PROCESSMESSAGE: ERRORS IN HEADER %s peer=%d\n”, SanitizeString(hdr.GetCommand()), pfrom->GetId());
  53. return fMoreWork;
  54. }
  55. std::string strCommand = hdr.GetCommand();
  57. // Message size
  58. unsigned int nMessageSize = hdr.nMessageSize;
  60. // Checksum
  61. CDataStream& vRecv = msg.vRecv;
  62. const uint256& hash = msg.GetMessageHash();
  63. if (memcmp(hash.begin(), hdr.pchChecksum, CMessageHeader::CHECKSUM_SIZE) != 0)
  64. {
  65. LogPrint(BCLog::NET, “%s(%s, %u bytes): CHECKSUM ERROR expected %s was %s\n”, __func__,
  66. SanitizeString(strCommand), nMessageSize,
  67. HexStr(hash.begin(), hash.begin()+CMessageHeader::CHECKSUM_SIZE),
  68. HexStr(hdr.pchChecksum, hdr.pchChecksum+CMessageHeader::CHECKSUM_SIZE));
  69. return fMoreWork;
  70. }
  72. // Process message
  73. bool fRet = false;
  74. try
  75. {
  76. fRet = ProcessMessage(pfrom, strCommand, vRecv, msg.nTime, chainparams, connman, interruptMsgProc);
  77. if (interruptMsgProc)
  78. return false;
  79. if (!pfrom->vRecvGetData.empty())
  80. fMoreWork = true;
  81. }
  82. catch (const std::ios_base::failure& e)
  83. {
  84. connman->PushMessage(pfrom, CNetMsgMaker(INIT_PROTO_VERSION).Make(NetMsgType::REJECT, strCommand, REJECT_MALFORMED, std::string(“error parsing message”)));
  85. if (strstr(e.what(), “end of data”))
  86. {
  87. // Allow exceptions from under-length message on vRecv
  88. LogPrint(BCLog::NET, “%s(%s, %u bytes): Exception ‘%s’ caught, normally caused by a message being shorter than its stated length\n”, __func__, SanitizeString(strCommand), nMessageSize, e.what());
  89. }
  90. else if (strstr(e.what(), “size too large”))
  91. {
  92. // Allow exceptions from over-long size
  93. LogPrint(BCLog::NET, “%s(%s, %u bytes): Exception ‘%s’ caught\n”, __func__, SanitizeString(strCommand), nMessageSize, e.what());
  94. }
  95. else if (strstr(e.what(), “non-canonical ReadCompactSize()”))
  96. {
  97. // Allow exceptions from non-canonical encoding
  98. LogPrint(BCLog::NET, “%s(%s, %u bytes): Exception ‘%s’ caught\n”, __func__, SanitizeString(strCommand), nMessageSize, e.what());
  99. }
  100. else
  101. {
  102. PrintExceptionContinue(&e, “ProcessMessages()”);
  103. }
  104. }
  105. catch (const std::exception& e) {
  106. PrintExceptionContinue(&e, “ProcessMessages()”);
  107. } catch (…) {
  108. PrintExceptionContinue(nullptr, “ProcessMessages()”);
  109. }
  111. if (!fRet) {
  112. LogPrint(BCLog::NET, “%s(%s, %u bytes) FAILED peer=%d\n”, __func__, SanitizeString(strCommand), nMessageSize, pfrom->GetId());
  113. }
  115. LOCK(cs_main);
  116. SendRejectsAndCheckIfBanned(pfrom, connman);
  118. return fMoreWork;
  119. }

代码稍长，但逻辑实际上比较清晰：从节点消息缓冲区(vProcessMsg)中取出消息，然后读取消息头，消息校验和，消息长度等，对消息进行检查后，调用ProcessMessage消息处理消息：

ProcessMessage里有许多的if-else分支，针对不同的消息走不同的分支处理。这里就不在展开了，等分析具体的P2P协议消息时在回到这个函数里来看。

3.3.5 节点之间握手

前文提到过，当两个节点之间的网络连接建立起来以后，就需要按照比特币的P2P网络协议来进行通信。首先要做的就是两个节点间的握手。两个节点之间互发version消息，并向对方回以verack进行确认。

握手是在一个节点初始化的时候出发的，还记得前文提到的OpenNetworkConnection函数么，这个函数在生成一个新节点以后，还会对节点进行初始化：

    m_msgproc->InitializeNode(pnode);

握手消息version就是在这里发送出去的：

  1. void PeerLogicValidation::InitializeNode(CNode *pnode) {
  2. CAddress addr = pnode->addr;
  3. std::string addrName = pnode->GetAddrName();
  4. NodeId nodeid = pnode->GetId();
  5. {
  6. LOCK(cs_main);
  7. mapNodeState.emplace_hint(mapNodeState.end(), std::piecewise_construct, std::forward_as_tuple(nodeid), std::forward_as_tuple(addr, std::move(addrName)));
  8. }
  9. if(!pnode->fInbound)
  10. PushNodeVersion(pnode, connman, GetTime());
  11. }

PushNodeVersion将向peer发送version消息：

  1. static void PushNodeVersion(CNode *pnode, CConnman* connman, int64_t nTime)
  2. {
  3. ServiceFlags nLocalNodeServices = pnode->GetLocalServices();
  4. uint64_t nonce = pnode->GetLocalNonce();
  5. int nNodeStartingHeight = pnode->GetMyStartingHeight();
  6. NodeId nodeid = pnode->GetId();
  7. CAddress addr = pnode->addr;
  9. CAddress addrYou = (addr.IsRoutable() && !IsProxy(addr) ? addr : CAddress(CService(), addr.nServices));
  10. CAddress addrMe = CAddress(CService(), nLocalNodeServices);
  12. connman->PushMessage(pnode, CNetMsgMaker(INIT_PROTO_VERSION).Make(NetMsgType::VERSION, PROTOCOL_VERSION, (uint64_t)nLocalNodeServices, nTime, addrYou, addrMe,
  13. nonce, strSubVersion, nNodeStartingHeight, ::fRelayTxes));
  15. if (fLogIPs) {
  16. LogPrint(BCLog::NET, “send version message: version %d, blocks=%d, us=%s, them=%s, peer=%d\n”, PROTOCOL_VERSION, nNodeStartingHeight, addrMe.ToString(), addrYou.ToString(), nodeid);
  17. } else {
  18. LogPrint(BCLog::NET, “send version message: version %d, blocks=%d, us=%s, peer=%d\n”, PROTOCOL_VERSION, nNodeStartingHeight, addrMe.ToString(), nodeid);
  19. }
  20. }

结合前文描述的version消息，上面这段代码就很容易理解了。version消息将本节点的nLocalService，addrMe，addrYou，当前节点的区块链高度等信息发送给peer。

之后就是等待peer回以verack的确认消息的处理了。根据前文的分析，当节点收到peer的消息后，select函数将返回，套接字在可读描述符集合中将被置位，然后从套接字里读取数据，数据最终在PeerLogicValidation::ProcessMessage函数被消费掉，来看看一个节点收到version消息时是如何处理的：

  1.     else if (strCommand == NetMsgType::VERSION)
  2. {
  3. // Each connection can only send one version message
  4. if (pfrom->nVersion != 0)
  5. {
  6. connman->PushMessage(pfrom, CNetMsgMaker(INIT_PROTO_VERSION).Make(NetMsgType::REJECT, strCommand, REJECT_DUPLICATE, std::string(“Duplicate version message”)));
  7. LOCK(cs_main);
  8. Misbehaving(pfrom->GetId(), 1);
  9. return false;
  10. }
  12. int64_t nTime;
  13. CAddress addrMe;
  14. CAddress addrFrom;
  15. uint64_t nNonce = 1;
  16. uint64_t nServiceInt;
  17. ServiceFlags nServices;
  18. int nVersion;
  19. int nSendVersion;
  20. std::string strSubVer;
  21. std::string cleanSubVer;
  22. int nStartingHeight = -1;
  23. bool fRelay = true;
  25. vRecv >> nVersion >> nServiceInt >> nTime >> addrMe;
  26. nSendVersion = std::min(nVersion, PROTOCOL_VERSION);
  27. nServices = ServiceFlags(nServiceInt);
  28. if (!pfrom->fInbound)
  29. {
  30. connman->SetServices(pfrom->addr, nServices);
  31. }
  32. if (!pfrom->fInbound && !pfrom->fFeeler && !pfrom->m_manual_connection && !HasAllDesirableServiceFlags(nServices))
  33. {
  34. LogPrint(BCLog::NET, “peer=%d does not offer the expected services (%08x offered, %08x expected); disconnecting\n”, pfrom->GetId(), nServices, GetDesirableServiceFlags(nServices));
  35. connman->PushMessage(pfrom, CNetMsgMaker(INIT_PROTO_VERSION).Make(NetMsgType::REJECT, strCommand, REJECT_NONSTANDARD,
  36. strprintf(“Expected to offer services %08x”, GetDesirableServiceFlags(nServices))));
  37. pfrom->fDisconnect = true;
  38. return false;
  39. }
  41. if (nServices & ((1 << 7) | (1 << 5))) {
  42. if (GetTime() < 1533096000) {
  43. // Immediately disconnect peers that use service bits 6 or 8 until August 1st, 2018
  44. // These bits have been used as a flag to indicate that a node is running incompatible
  45. // consensus rules instead of changing the network magic, so we’re stuck disconnecting
  46. // based on these service bits, at least for a while.
  47. pfrom->fDisconnect = true;
  48. return false;
  49. }
  50. }
  52. if (nVersion < MIN_PEER_PROTO_VERSION)
  53. {
  54. // disconnect from peers older than this proto version
  55. LogPrint(BCLog::NET, “peer=%d using obsolete version %i; disconnecting\n”, pfrom->GetId(), nVersion);
  56. connman->PushMessage(pfrom, CNetMsgMaker(INIT_PROTO_VERSION).Make(NetMsgType::REJECT, strCommand, REJECT_OBSOLETE,
  57. strprintf(“Version must be %d or greater”, MIN_PEER_PROTO_VERSION)));
  58. pfrom->fDisconnect = true;
  59. return false;
  60. }
  62. if (nVersion == 10300)
  63. nVersion = 300;
  64. if (!vRecv.empty())
  65. vRecv >> addrFrom >> nNonce;
  66. if (!vRecv.empty()) {
  67. vRecv >> LIMITED_STRING(strSubVer, MAX_SUBVERSION_LENGTH);
  68. cleanSubVer = SanitizeString(strSubVer);
  69. }
  70. if (!vRecv.empty()) {
  71. vRecv >> nStartingHeight;
  72. }
  73. if (!vRecv.empty())
  74. vRecv >> fRelay;
  75. // Disconnect if we connected to ourself
  76. if (pfrom->fInbound && !connman->CheckIncomingNonce(nNonce))
  77. {
  78. LogPrintf(“connected to self at %s, disconnecting\n”, pfrom->addr.ToString());
  79. pfrom->fDisconnect = true;
  80. return true;
  81. }
  83. if (pfrom->fInbound && addrMe.IsRoutable())
  84. {
  85. SeenLocal(addrMe);
  86. }
  88. // Be shy and don’t send version until we hear
  89. if (pfrom->fInbound)
  90. PushNodeVersion(pfrom, connman, GetAdjustedTime());
  92. connman->PushMessage(pfrom, CNetMsgMaker(INIT_PROTO_VERSION).Make(NetMsgType::VERACK));
connman->PushMessage(pfrom, CNetMsgMaker(INIT_PROTO_VERSION).Make(NetMsgType::VERACK));

主要是对接收到的数据进行合法性检查，没问题了发送verack进行确认。对于verack的处理此处就不在展开，可以自行在ProcessMessage函数中去查看。

3.3.6 时序图

洋洋洒洒一大堆，很多读者可能还是有点云里雾里的感觉，这里再用时序图来对上面的过程做一个补充。

(1) 比特币P2P网络的初始化

(2) 连接到peer

4 小结

本文分析了比特币P2P网络的节点发现原理、节点之间连接的协议以及网络连接、节点间数据通信的源码实现。区块链的本质是建立在P2P网络上的一个分布式数据库，网络上的节点通过Pow工作量证明或Pos权益证明等算法达成共识。所以P2P网络以及其共识算法可以看做是区块链的基石，所以了解比特币区块链的P2P网络节点发现以及互联互通的原理和实现对学习区块链来说非常重要，同时对于像作者这样的新手来说，也是进入区块链学习的一个不错的切入点。

本文只是分析了节点是如何连接到发现的相邻节点上（对外），作为P2P网络，自己的节点当然也可以作为网络中的一个peer为其他节点服务。下一篇文章我们将分析一下比特币区块链是如何通过minipunp实现端口映射，让网络中的其他节点连接到自己。

 

参考文章《精通比特币》

—- 本文为原创文章，转载请记得注明出处。

相关文章：

比特币布道者

比特币的坚定信仰者！

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注