diff --git a/src/seeder/test/message_writer_tests.cpp b/src/seeder/test/message_writer_tests.cpp index 6284ff1d3..4bb2b20b7 100644 --- a/src/seeder/test/message_writer_tests.cpp +++ b/src/seeder/test/message_writer_tests.cpp @@ -1,94 +1,94 @@ // Copyright (c) 2020 The Bitcoin developers // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. #include #include #include #include #include #include #include #include #include BOOST_AUTO_TEST_SUITE(message_writer_tests) template static void CheckMessage(CDataStream &expectedMessage, std::string command, Args &&... args) { CDataStream message(SER_NETWORK, PROTOCOL_VERSION); MessageWriter::WriteMessage(message, command, std::forward(args)...); BOOST_CHECK_EQUAL(message.size(), expectedMessage.size()); for (size_t i = 0; i < message.size(); i++) { BOOST_CHECK_EQUAL(message[i], expectedMessage[i]); } } BOOST_AUTO_TEST_CASE(simple_header_and_payload_message_writer_test) { SelectParams(CBaseChainParams::MAIN); int64_t now = GetTime(); uint64_t nonce = 0; uint64_t serviceFlags = uint64_t(ServiceFlags(NODE_NETWORK)); CService service; CAddress addrTo(service, ServiceFlags(NODE_NETWORK)); CAddress addrFrom(service, ServiceFlags(NODE_NETWORK)); - std::string user_agent = "/bitcoin-cash-seeder:0.15/"; + std::string user_agent = "/Bitcoin ABC:0.0.0(seeder)/"; int start_height = 1; CDataStream versionPayload(SER_NETWORK, PROTOCOL_VERSION); versionPayload << PROTOCOL_VERSION << serviceFlags << now << addrTo << addrFrom << nonce << user_agent << start_height; CMessageHeader versionhdr(Params().NetMagic(), NetMsgType::VERSION, versionPayload.size()); uint256 hash = Hash(versionPayload); memcpy(versionhdr.pchChecksum, hash.begin(), CMessageHeader::CHECKSUM_SIZE); CDataStream expectedVersion(SER_NETWORK, PROTOCOL_VERSION); expectedVersion << versionhdr; expectedVersion += versionPayload; CheckMessage(expectedVersion, NetMsgType::VERSION, PROTOCOL_VERSION, serviceFlags, now, addrTo, addrFrom, nonce, user_agent, start_height); } BOOST_AUTO_TEST_CASE(header_empty_payload_message_writer_test) { SelectParams(CBaseChainParams::MAIN); CMessageHeader verackHeader(Params().NetMagic(), NetMsgType::VERACK, 0); CDataStream expectedVerack(SER_NETWORK, PROTOCOL_VERSION); // This is an empty payload, but is still necessary for the checksum std::vector payload; uint256 hash = Hash(payload); memcpy(verackHeader.pchChecksum, hash.begin(), CMessageHeader::CHECKSUM_SIZE); expectedVerack << verackHeader; CheckMessage(expectedVerack, NetMsgType::VERACK); } BOOST_AUTO_TEST_CASE(write_getheaders_message_test) { SelectParams(CBaseChainParams::MAIN); CDataStream payload(SER_NETWORK, PROTOCOL_VERSION); BlockHash bhash(uint256S( "0000000099f5509b5f36b1926bcf82b21d936ebeadee811030dfbbb7fae915d7")); std::vector vlocator(1, bhash); CBlockLocator locatorhash(vlocator); payload << locatorhash << uint256(); uint256 hash = Hash(payload); CMessageHeader msgHeader(Params().NetMagic(), NetMsgType::GETHEADERS, payload.size()); memcpy(msgHeader.pchChecksum, hash.begin(), CMessageHeader::CHECKSUM_SIZE); CDataStream expectedMsg(SER_NETWORK, PROTOCOL_VERSION); expectedMsg << msgHeader; expectedMsg += payload; CheckMessage(expectedMsg, NetMsgType::GETHEADERS, locatorhash, uint256()); } BOOST_AUTO_TEST_SUITE_END() diff --git a/src/seeder/test/p2p_messaging_tests.cpp b/src/seeder/test/p2p_messaging_tests.cpp index 72708309a..899818c0b 100644 --- a/src/seeder/test/p2p_messaging_tests.cpp +++ b/src/seeder/test/p2p_messaging_tests.cpp @@ -1,163 +1,163 @@ // Copyright (c) 2019 The Bitcoin developers // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include std::ostream &operator<<(std::ostream &os, const PeerMessagingState &state) { os << to_integral(state); return os; } namespace { class CSeederNodeTest : public CSeederNode { public: CSeederNodeTest(const CService &service, std::vector *vAddrIn) : CSeederNode(service, vAddrIn) {} void TestProcessMessage(const std::string &strCommand, CDataStream &message, PeerMessagingState expectedState) { PeerMessagingState ret = ProcessMessage(strCommand, message); BOOST_CHECK_EQUAL(ret, expectedState); } CDataStream getSendBuffer() { return vSend; } }; } // namespace static const uint16_t SERVICE_PORT = 18444; struct SeederTestingSetup { SeederTestingSetup() { SelectParams(CBaseChainParams::REGTEST); CNetAddr ip; ip.SetInternal("bitcoin.test"); CService service = {ip, SERVICE_PORT}; vAddr.emplace_back(service, ServiceFlags()); testNode = std::make_unique(service, &vAddr); } std::vector vAddr; std::unique_ptr testNode; }; BOOST_FIXTURE_TEST_SUITE(p2p_messaging_tests, SeederTestingSetup) static CDataStream CreateVersionMessage(int64_t now, CAddress addrTo, CAddress addrFrom, int32_t start_height, uint32_t nVersion, uint64_t nonce = 0, - std::string user_agent = "/bitcoin-cash-seeder:0.15/") { + std::string user_agent = "/Bitcoin ABC:0.0.0(seeder)/") { CDataStream payload(SER_NETWORK, 0); payload.SetVersion(nVersion); ServiceFlags serviceflags = ServiceFlags(NODE_NETWORK); payload << nVersion << uint64_t(serviceflags) << now << addrTo << addrFrom << nonce << user_agent << start_height; return payload; } static const int SEEDER_INIT_VERSION = 0; BOOST_AUTO_TEST_CASE(process_version_msg) { CService serviceFrom; CAddress addrFrom(serviceFrom, ServiceFlags(NODE_NETWORK)); CDataStream versionMessage = CreateVersionMessage( GetTime(), vAddr[0], addrFrom, GetRequireHeight(), INIT_PROTO_VERSION); // Verify the version is set as the initial value BOOST_CHECK_EQUAL(testNode->CSeederNode::GetClientVersion(), SEEDER_INIT_VERSION); testNode->TestProcessMessage(NetMsgType::VERSION, versionMessage, PeerMessagingState::AwaitingMessages); // Verify the version has been updated BOOST_CHECK_EQUAL(testNode->CSeederNode::GetClientVersion(), versionMessage.GetVersion()); } BOOST_AUTO_TEST_CASE(process_verack_msg) { CDataStream verackMessage(SER_NETWORK, 0); verackMessage.SetVersion(INIT_PROTO_VERSION); testNode->TestProcessMessage(NetMsgType::VERACK, verackMessage, PeerMessagingState::AwaitingMessages); // Seeder should respond with an ADDR message const CMessageHeader::MessageMagic netMagic = Params().NetMagic(); CMessageHeader header(netMagic); CDataStream sendBuffer = testNode->getSendBuffer(); sendBuffer >> header; BOOST_CHECK(header.IsValidWithoutConfig(netMagic)); BOOST_CHECK_EQUAL(header.GetCommand(), NetMsgType::GETADDR); // Next message should be GETHEADERS sendBuffer >> header; BOOST_CHECK(header.IsValidWithoutConfig(netMagic)); BOOST_CHECK_EQUAL(header.GetCommand(), NetMsgType::GETHEADERS); CBlockLocator locator; uint256 hashStop; sendBuffer >> locator >> hashStop; std::vector expectedLocator = { Params().Checkpoints().mapCheckpoints.rbegin()->second}; BOOST_CHECK(locator.vHave == expectedLocator); BOOST_CHECK(hashStop == uint256()); } static CDataStream CreateAddrMessage(std::vector sendAddrs, uint32_t nVersion = INIT_PROTO_VERSION) { CDataStream payload(SER_NETWORK, 0); payload.SetVersion(nVersion); payload << sendAddrs; return payload; } BOOST_AUTO_TEST_CASE(process_addr_msg) { // vAddrs starts with 1 entry. std::vector sendAddrs(ADDR_SOFT_CAP - 1, vAddr[0]); // Happy path // addrs are added normally to vAddr until ADDR_SOFT_CAP is reached. // Add addrs up to the soft cap. CDataStream addrMessage = CreateAddrMessage(sendAddrs); BOOST_CHECK_EQUAL(1, vAddr.size()); testNode->TestProcessMessage(NetMsgType::ADDR, addrMessage, PeerMessagingState::AwaitingMessages); BOOST_CHECK_EQUAL(ADDR_SOFT_CAP, vAddr.size()); // ADDR_SOFT_CAP is exceeded sendAddrs.resize(1); addrMessage = CreateAddrMessage(sendAddrs); testNode->TestProcessMessage(NetMsgType::ADDR, addrMessage, PeerMessagingState::Finished); BOOST_CHECK_EQUAL(ADDR_SOFT_CAP + 1, vAddr.size()); // Test the seeder's behavior after ADDR_SOFT_CAP addrs // Only one addr per ADDR message will be added, the rest are ignored size_t expectedSize = vAddr.size() + 1; for (size_t i = 1; i < 10; i++) { sendAddrs.resize(i, sendAddrs[0]); addrMessage = CreateAddrMessage(sendAddrs); testNode->TestProcessMessage(NetMsgType::ADDR, addrMessage, PeerMessagingState::Finished); BOOST_CHECK_EQUAL(expectedSize, vAddr.size()); ++expectedSize; } } BOOST_AUTO_TEST_SUITE_END()