Page MenuHomePhabricator
Differential D4439 Diff 14109 src/seeder/test/seeder_tests.cpp

Changeset View

Standalone View

View Options

src/seeder/test/seeder_tests.cpp

// Copyright (c) 2019 The Bitcoin developers // Copyright (c) 2019 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying // Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php. // file COPYING or http://www.opensource.org/licenses/mit-license.php.
#define BOOST_TEST_MODULE Bitcoin Seeder Test Suite #define BOOST_TEST_MODULE Bitcoin Seeder Test Suite
#include <chainparamsconstants.h>
#include <hash.h> #include <hash.h>
#include <netbase.h> #include <netbase.h>
#include <protocol.h> #include <protocol.h>
#include <seeder/bitcoin.h> #include <seeder/bitcoin.h>
#include <seeder/db.h> #include <seeder/db.h>
#include <seeder/dns.h> #include <seeder/dns.h>
#include <serialize.h> #include <serialize.h>
#include <streams.h> #include <streams.h>
Show All 18 Lines
const int BUFFER_LENGTH = 512; const int BUFFER_LENGTH = 512;
const int QNAME_BUFFER_LENGTH = 256; const int QNAME_BUFFER_LENGTH = 256;
const int SIZE_OF_QTYPE = 2; const int SIZE_OF_QTYPE = 2;
const int SIZE_OF_QCLASS = 2; const int SIZE_OF_QCLASS = 2;
const unsigned short MAINNET_PORT = 8333; const unsigned short MAINNET_PORT = 8333;
const std::string VERACK_COMMAND = "verack"; const std::string VERACK_COMMAND = "verack";
const std::string VERSION_COMMAND = "version"; const std::string VERSION_COMMAND = "version";
const std::string ADDR_COMMAND = "addr"; const std::string ADDR_COMMAND = "addr";
const std::string NOTFOUND_COMMAND = "notfound";
const std::string SENDHEADERS_COMMAND = "sendheaders";
const std::string HEADERS_COMMAND = "headers";
const std::string SEED = "seed.bitcoinabc.org"; const std::string SEED = "seed.bitcoinabc.org";
// Builds dummy DNS query message // Builds dummy DNS query message
std::array<uint8_t, BUFFER_LENGTH> CreateDNSQuestion(const std::string &qname) { std::array<uint8_t, BUFFER_LENGTH> CreateDNSQuestion(const std::string &qname) {
std::stringstream querryhex; std::stringstream querryhex;
querryhex.clear(); querryhex.clear();
querryhex << std::hex << std::setfill('0'); querryhex << std::hex << std::setfill('0');
Show All 39 Linespublic:
bool TestProcessMessage(const std::string &strCommand) { bool TestProcessMessage(const std::string &strCommand) {
if (strCommand == VERSION_COMMAND) { if (strCommand == VERSION_COMMAND) {
CreateVersionMessage(); CreateVersionMessage();
return CSeederNode::ProcessMessage(VERSION_COMMAND, message); return CSeederNode::ProcessMessage(VERSION_COMMAND, message);
} else if (strCommand == VERACK_COMMAND) { } else if (strCommand == VERACK_COMMAND) {
CreateVerackMessage(); CreateVerackMessage();
return CSeederNode::ProcessMessage(VERACK_COMMAND, message); return CSeederNode::ProcessMessage(VERACK_COMMAND, message);
} else { } else if (strCommand == ADDR_COMMAND) {
// strCommand == ADDR_COMMAND
CreateAddrMessage(); CreateAddrMessage();
return CSeederNode::ProcessMessage(ADDR_COMMAND, message); return CSeederNode::ProcessMessage(ADDR_COMMAND, message);
} else if (strCommand == NOTFOUND_COMMAND) {
CreateAddrMessage();
return CSeederNode::ProcessMessage(NOTFOUND_COMMAND, message);
} else {
// strCommand == HEADERS_COMMAND
CreateHeadersMessage();
return CSeederNode::ProcessMessage(HEADERS_COMMAND, message);
} }
} }
void setVersion(int32_t version) { nVersion = version; } void setVersion(int32_t version) { nVersion = version; }
size_t getAddrListSize() { return vAddr.size(); } size_t getAddrListSize() { return vAddr.size(); }
private: private:
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines void CreateAddrMessage() {
message.erase(message.begin(), message.end()); message.erase(message.begin(), message.end());
message += payload; message += payload;
header.nMessageSize = payload.size(); header.nMessageSize = payload.size();
uint256 hash = Hash(payload.begin(), payload.end()); uint256 hash = Hash(payload.begin(), payload.end());
memcpy(header.pchChecksum, &hash, header.CHECKSUM_SIZE); memcpy(header.pchChecksum, &hash, header.CHECKSUM_SIZE);
} }
void CreateNotFoundMessage() {
CDataStream payload(SER_NETWORK, 0);
payload.SetVersion(nVersion);
payload << static_cast<uint8_t>(1);
payload << static_cast<uint32_t>(MSG_BLOCK)
<< ChainParamsConstants::MAINNET_DEFAULT_ASSUME_VALID;
message.erase(message.begin(), message.end());
message += payload;
header.nMessageSize = payload.size();
uint256 hash = Hash(payload.begin(), payload.end());
memcpy(header.pchChecksum, &hash, header.CHECKSUM_SIZE);
}
void CreateHeadersMessage() {
CDataStream payload(SER_NETWORK, 0);
payload.SetVersion(nVersion);
payload << static_cast<uint8_t>(1);
uint256 garbageHash = Hash(payload.begin(), payload.end());
// The actual header can be garbage data, Seeder only cares that it got
// a specific type of message.
payload << nVersion;
// prev_block
payload << garbageHash;
// merkle_root
payload << garbageHash;
// timestamp
payload << static_cast<uint32_t>(0);
// bits
payload << static_cast<uint32_t>(0);
// nonce
payload << static_cast<uint32_t>(0);
// txn_count
payload << static_cast<uint8_t>(0);
message.erase(message.begin(), message.end());
message += payload;
header.nMessageSize = payload.size();
uint256 hash = Hash(payload.begin(), payload.end());
memcpy(header.pchChecksum, &hash, header.CHECKSUM_SIZE);
}
std::vector<CAddress> vAddr; std::vector<CAddress> vAddr;
int32_t nVersion; int32_t nVersion;
CDataStream message; CDataStream message;
CMessageHeader header; CMessageHeader header;
}; };
BOOST_AUTO_TEST_CASE(parse_name_simple) { BOOST_AUTO_TEST_CASE(parse_name_simple) {
const std::string messageQName = "www.mydomain.com"; const std::string messageQName = "www.mydomain.com";
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 LinesBOOST_AUTO_TEST_CASE(seeder_node_tests) {
testNode.setVersion(10300); testNode.setVersion(10300);
ret = testNode.TestProcessMessage(VERSION_COMMAND); ret = testNode.TestProcessMessage(VERSION_COMMAND);
BOOST_CHECK_EQUAL(ret, false); BOOST_CHECK_EQUAL(ret, false);
testNode.setVersion(106); testNode.setVersion(106);
ret = testNode.TestProcessMessage(VERSION_COMMAND); ret = testNode.TestProcessMessage(VERSION_COMMAND);
BOOST_CHECK_EQUAL(ret, false); BOOST_CHECK_EQUAL(ret, false);
testNode.setVersion(209);
ret = testNode.TestProcessMessage(NOTFOUND_COMMAND);
BOOST_CHECK_EQUAL(ret, false);
BOOST_CHECK_EQUAL(100000, testNode.GetBan());
ret = testNode.TestProcessMessage(HEADERS_COMMAND);
BOOST_CHECK_EQUAL(ret, false);
} }
BOOST_AUTO_TEST_SUITE_END() BOOST_AUTO_TEST_SUITE_END()