Page MenuHomePhabricator
Differential D19057 Diff 57171 src/test/net_tests.cpp

Changeset View

Standalone View

View Options

src/test/net_tests.cpp

Show First 20 Lines • Show All 582 Lines • ▼ Show 20 LinesBOOST_AUTO_TEST_CASE(cnetaddr_basic) {
BOOST_CHECK_EQUAL(addr.ToString(), "esffpvrt3wpeaygy.internal"); BOOST_CHECK_EQUAL(addr.ToString(), "esffpvrt3wpeaygy.internal");
// Totally bogus // Totally bogus
BOOST_CHECK(!addr.SetSpecial("totally bogus")); BOOST_CHECK(!addr.SetSpecial("totally bogus"));
} }
BOOST_AUTO_TEST_CASE(cnetaddr_serialize_v1) { BOOST_AUTO_TEST_CASE(cnetaddr_serialize_v1) {
CNetAddr addr; CNetAddr addr;
CDataStream s(SER_NETWORK, PROTOCOL_VERSION); DataStream s{};
const auto ser_params{CAddress::V1_NETWORK};
s << addr; s << WithParams(ser_params, addr);
BOOST_CHECK_EQUAL(HexStr(s), "00000000000000000000000000000000"); BOOST_CHECK_EQUAL(HexStr(s), "00000000000000000000000000000000");
s.clear(); s.clear();
BOOST_REQUIRE(LookupHost("1.2.3.4", addr, false)); BOOST_REQUIRE(LookupHost("1.2.3.4", addr, false));
s << addr; s << WithParams(ser_params, addr);
BOOST_CHECK_EQUAL(HexStr(s), "00000000000000000000ffff01020304"); BOOST_CHECK_EQUAL(HexStr(s), "00000000000000000000ffff01020304");
s.clear(); s.clear();
BOOST_REQUIRE( BOOST_REQUIRE(
LookupHost("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b", addr, false)); LookupHost("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b", addr, false));
s << addr; s << WithParams(ser_params, addr);
BOOST_CHECK_EQUAL(HexStr(s), "1a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b"); BOOST_CHECK_EQUAL(HexStr(s), "1a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b");
s.clear(); s.clear();
BOOST_REQUIRE(addr.SetSpecial("6hzph5hv6337r6p2.onion")); BOOST_REQUIRE(addr.SetSpecial("6hzph5hv6337r6p2.onion"));
s << addr; s << WithParams(ser_params, addr);
BOOST_CHECK_EQUAL(HexStr(s), "fd87d87eeb43f1f2f3f4f5f6f7f8f9fa"); BOOST_CHECK_EQUAL(HexStr(s), "fd87d87eeb43f1f2f3f4f5f6f7f8f9fa");
s.clear(); s.clear();
BOOST_REQUIRE(addr.SetSpecial( BOOST_REQUIRE(addr.SetSpecial(
"pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion")); "pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion"));
s << addr; s << WithParams(ser_params, addr);
BOOST_CHECK_EQUAL(HexStr(s), "00000000000000000000000000000000"); BOOST_CHECK_EQUAL(HexStr(s), "00000000000000000000000000000000");
s.clear(); s.clear();
addr.SetInternal("a"); addr.SetInternal("a");
s << addr; s << WithParams(ser_params, addr);
BOOST_CHECK_EQUAL(HexStr(s), "fd6b88c08724ca978112ca1bbdcafac2"); BOOST_CHECK_EQUAL(HexStr(s), "fd6b88c08724ca978112ca1bbdcafac2");
s.clear(); s.clear();
} }
BOOST_AUTO_TEST_CASE(cnetaddr_serialize_v2) { BOOST_AUTO_TEST_CASE(cnetaddr_serialize_v2) {
CNetAddr addr; CNetAddr addr;
CDataStream s(SER_NETWORK, PROTOCOL_VERSION); DataStream s{};
// Add ADDRV2_FORMAT to the version so that the CNetAddr const auto ser_params{CAddress::V2_NETWORK};
// serialize method produces an address in v2 format.
s.SetVersion(s.GetVersion() | ADDRV2_FORMAT);
s << addr; s << WithParams(ser_params, addr);
BOOST_CHECK_EQUAL(HexStr(s), "021000000000000000000000000000000000"); BOOST_CHECK_EQUAL(HexStr(s), "021000000000000000000000000000000000");
s.clear(); s.clear();
BOOST_REQUIRE(LookupHost("1.2.3.4", addr, false)); BOOST_REQUIRE(LookupHost("1.2.3.4", addr, false));
s << addr; s << WithParams(ser_params, addr);
BOOST_CHECK_EQUAL(HexStr(s), "010401020304"); BOOST_CHECK_EQUAL(HexStr(s), "010401020304");
s.clear(); s.clear();
BOOST_REQUIRE( BOOST_REQUIRE(
LookupHost("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b", addr, false)); LookupHost("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b", addr, false));
s << addr; s << WithParams(ser_params, addr);
BOOST_CHECK_EQUAL(HexStr(s), "02101a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b"); BOOST_CHECK_EQUAL(HexStr(s), "02101a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b");
s.clear(); s.clear();
BOOST_REQUIRE(addr.SetSpecial("6hzph5hv6337r6p2.onion")); BOOST_REQUIRE(addr.SetSpecial("6hzph5hv6337r6p2.onion"));
s << addr; s << WithParams(ser_params, addr);
BOOST_CHECK_EQUAL(HexStr(s), "030af1f2f3f4f5f6f7f8f9fa"); BOOST_CHECK_EQUAL(HexStr(s), "030af1f2f3f4f5f6f7f8f9fa");
s.clear(); s.clear();
BOOST_REQUIRE(addr.SetSpecial( BOOST_REQUIRE(addr.SetSpecial(
"kpgvmscirrdqpekbqjsvw5teanhatztpp2gl6eee4zkowvwfxwenqaid.onion")); "kpgvmscirrdqpekbqjsvw5teanhatztpp2gl6eee4zkowvwfxwenqaid.onion"));
s << addr; s << WithParams(ser_params, addr);
BOOST_CHECK_EQUAL( BOOST_CHECK_EQUAL(
HexStr(s), HexStr(s),
"042053cd5648488c4707914182655b7664034e09e66f7e8cbf1084e654eb56c5bd88"); "042053cd5648488c4707914182655b7664034e09e66f7e8cbf1084e654eb56c5bd88");
s.clear(); s.clear();
BOOST_REQUIRE(addr.SetInternal("a")); BOOST_REQUIRE(addr.SetInternal("a"));
s << addr; s << WithParams(ser_params, addr);
BOOST_CHECK_EQUAL(HexStr(s), "0210fd6b88c08724ca978112ca1bbdcafac2"); BOOST_CHECK_EQUAL(HexStr(s), "0210fd6b88c08724ca978112ca1bbdcafac2");
s.clear(); s.clear();
} }
BOOST_AUTO_TEST_CASE(cnetaddr_unserialize_v2) { BOOST_AUTO_TEST_CASE(cnetaddr_unserialize_v2) {
CNetAddr addr; CNetAddr addr;
CDataStream s(SER_NETWORK, PROTOCOL_VERSION); DataStream s{};
// Add ADDRV2_FORMAT to the version so that the CNetAddr const auto ser_params{CAddress::V2_NETWORK};
// unserialize method expects an address in v2 format.
s.SetVersion(s.GetVersion() | ADDRV2_FORMAT);
// Valid IPv4. // Valid IPv4.
s << Span{ParseHex("01" // network type (IPv4) s << Span{ParseHex("01" // network type (IPv4)
"04" // address length "04" // address length
"01020304")}; // address "01020304")}; // address
s >> addr; s >> WithParams(ser_params, addr);
BOOST_CHECK(addr.IsValid()); BOOST_CHECK(addr.IsValid());
BOOST_CHECK(addr.IsIPv4()); BOOST_CHECK(addr.IsIPv4());
BOOST_CHECK(addr.IsAddrV1Compatible()); BOOST_CHECK(addr.IsAddrV1Compatible());
BOOST_CHECK_EQUAL(addr.ToString(), "1.2.3.4"); BOOST_CHECK_EQUAL(addr.ToString(), "1.2.3.4");
BOOST_REQUIRE(s.empty()); BOOST_REQUIRE(s.empty());
// Invalid IPv4, valid length but address itself is shorter. // Invalid IPv4, valid length but address itself is shorter.
s << Span{ParseHex("01" // network type (IPv4) s << Span{ParseHex("01" // network type (IPv4)
"04" // address length "04" // address length
"0102")}; // address "0102")}; // address
BOOST_CHECK_EXCEPTION(s >> addr, std::ios_base::failure, BOOST_CHECK_EXCEPTION(s >> WithParams(ser_params, addr),
HasReason("end of data")); std::ios_base::failure, HasReason("end of data"));
BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input. BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
s.clear(); s.clear();
// Invalid IPv4, with bogus length. // Invalid IPv4, with bogus length.
s << Span{ParseHex("01" // network type (IPv4) s << Span{ParseHex("01" // network type (IPv4)
"05" // address length "05" // address length
"01020304")}; // address "01020304")}; // address
BOOST_CHECK_EXCEPTION( BOOST_CHECK_EXCEPTION(
s >> addr, std::ios_base::failure, s >> WithParams(ser_params, addr), std::ios_base::failure,
HasReason("BIP155 IPv4 address with length 5 (should be 4)")); HasReason("BIP155 IPv4 address with length 5 (should be 4)"));
BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input. BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
s.clear(); s.clear();
// Invalid IPv4, with extreme length. // Invalid IPv4, with extreme length.
s << Span{ParseHex("01" // network type (IPv4) s << Span{ParseHex("01" // network type (IPv4)
"fd0102" // address length (513 as CompactSize) "fd0102" // address length (513 as CompactSize)
"01020304")}; // address "01020304")}; // address
BOOST_CHECK_EXCEPTION(s >> addr, std::ios_base::failure, BOOST_CHECK_EXCEPTION(s >> WithParams(ser_params, addr),
std::ios_base::failure,
HasReason("Address too long: 513 > 512")); HasReason("Address too long: 513 > 512"));
BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input. BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
s.clear(); s.clear();
// Valid IPv6. // Valid IPv6.
s << Span{ParseHex("02" // network type (IPv6) s << Span{ParseHex("02" // network type (IPv6)
"10" // address length "10" // address length
"0102030405060708090a0b0c0d0e0f10")}; // address "0102030405060708090a0b0c0d0e0f10")}; // address
s >> addr; s >> WithParams(ser_params, addr);
BOOST_CHECK(addr.IsValid()); BOOST_CHECK(addr.IsValid());
BOOST_CHECK(addr.IsIPv6()); BOOST_CHECK(addr.IsIPv6());
BOOST_CHECK(addr.IsAddrV1Compatible()); BOOST_CHECK(addr.IsAddrV1Compatible());
BOOST_CHECK_EQUAL(addr.ToString(), "102:304:506:708:90a:b0c:d0e:f10"); BOOST_CHECK_EQUAL(addr.ToString(), "102:304:506:708:90a:b0c:d0e:f10");
BOOST_REQUIRE(s.empty()); BOOST_REQUIRE(s.empty());
// Valid IPv6, contains embedded "internal". // Valid IPv6, contains embedded "internal".
s << Span{ s << Span{
ParseHex("02" // network type (IPv6) ParseHex("02" // network type (IPv6)
"10" // address length "10" // address length
"fd6b88c08724ca978112ca1bbdcafac2")}; // address: 0xfd + "fd6b88c08724ca978112ca1bbdcafac2")}; // address: 0xfd +
// sha256("bitcoin")[0:5] // sha256("bitcoin")[0:5]
// + sha256(name)[0:10] // + sha256(name)[0:10]
s >> addr; s >> WithParams(ser_params, addr);
BOOST_CHECK(addr.IsInternal()); BOOST_CHECK(addr.IsInternal());
BOOST_CHECK(addr.IsAddrV1Compatible()); BOOST_CHECK(addr.IsAddrV1Compatible());
BOOST_CHECK_EQUAL(addr.ToString(), "zklycewkdo64v6wc.internal"); BOOST_CHECK_EQUAL(addr.ToString(), "zklycewkdo64v6wc.internal");
BOOST_REQUIRE(s.empty()); BOOST_REQUIRE(s.empty());
// Invalid IPv6, with bogus length. // Invalid IPv6, with bogus length.
s << Span{ParseHex("02" // network type (IPv6) s << Span{ParseHex("02" // network type (IPv6)
"04" // address length "04" // address length
"00")}; // address "00")}; // address
BOOST_CHECK_EXCEPTION( BOOST_CHECK_EXCEPTION(
s >> addr, std::ios_base::failure, s >> WithParams(ser_params, addr), std::ios_base::failure,
HasReason("BIP155 IPv6 address with length 4 (should be 16)")); HasReason("BIP155 IPv6 address with length 4 (should be 16)"));
BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input. BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
s.clear(); s.clear();
// Invalid IPv6, contains embedded IPv4. // Invalid IPv6, contains embedded IPv4.
s << Span{ParseHex("02" // network type (IPv6) s << Span{ParseHex("02" // network type (IPv6)
"10" // address length "10" // address length
"00000000000000000000ffff01020304")}; // address "00000000000000000000ffff01020304")}; // address
s >> addr; s >> WithParams(ser_params, addr);
BOOST_CHECK(!addr.IsValid()); BOOST_CHECK(!addr.IsValid());
BOOST_REQUIRE(s.empty()); BOOST_REQUIRE(s.empty());
// Invalid IPv6, contains embedded TORv2. // Invalid IPv6, contains embedded TORv2.
s << Span{ParseHex("02" // network type (IPv6) s << Span{ParseHex("02" // network type (IPv6)
"10" // address length "10" // address length
"fd87d87eeb430102030405060708090a")}; // address "fd87d87eeb430102030405060708090a")}; // address
s >> addr; s >> WithParams(ser_params, addr);
BOOST_CHECK(!addr.IsValid()); BOOST_CHECK(!addr.IsValid());
BOOST_REQUIRE(s.empty()); BOOST_REQUIRE(s.empty());
// Valid TORv2. // Valid TORv2.
s << Span{ParseHex("03" // network type (TORv2) s << Span{ParseHex("03" // network type (TORv2)
"0a" // address length "0a" // address length
"f1f2f3f4f5f6f7f8f9fa")}; // address "f1f2f3f4f5f6f7f8f9fa")}; // address
s >> addr; s >> WithParams(ser_params, addr);
BOOST_CHECK(addr.IsValid()); BOOST_CHECK(addr.IsValid());
BOOST_CHECK(addr.IsTor()); BOOST_CHECK(addr.IsTor());
BOOST_CHECK(addr.IsAddrV1Compatible()); BOOST_CHECK(addr.IsAddrV1Compatible());
BOOST_CHECK_EQUAL(addr.ToString(), "6hzph5hv6337r6p2.onion"); BOOST_CHECK_EQUAL(addr.ToString(), "6hzph5hv6337r6p2.onion");
BOOST_REQUIRE(s.empty()); BOOST_REQUIRE(s.empty());
// Invalid TORv2, with bogus length. // Invalid TORv2, with bogus length.
s << Span{ParseHex("03" // network type (TORv2) s << Span{ParseHex("03" // network type (TORv2)
"07" // address length "07" // address length
"00")}; // address "00")}; // address
BOOST_CHECK_EXCEPTION( BOOST_CHECK_EXCEPTION(
s >> addr, std::ios_base::failure, s >> WithParams(ser_params, addr), std::ios_base::failure,
HasReason("BIP155 TORv2 address with length 7 (should be 10)")); HasReason("BIP155 TORv2 address with length 7 (should be 10)"));
BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input. BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
s.clear(); s.clear();
// Valid TORv3. // Valid TORv3.
s << Span{ParseHex("04" // network type (TORv3) s << Span{ParseHex("04" // network type (TORv3)
"20" // address length "20" // address length
"79bcc625184b05194975c28b66b66b04" // address "79bcc625184b05194975c28b66b66b04" // address
"69f7f6556fb1ac3189a79b40dda32f1f")}; "69f7f6556fb1ac3189a79b40dda32f1f")};
s >> addr; s >> WithParams(ser_params, addr);
BOOST_CHECK(addr.IsValid()); BOOST_CHECK(addr.IsValid());
BOOST_CHECK(addr.IsTor()); BOOST_CHECK(addr.IsTor());
BOOST_CHECK(!addr.IsAddrV1Compatible()); BOOST_CHECK(!addr.IsAddrV1Compatible());
BOOST_CHECK_EQUAL( BOOST_CHECK_EQUAL(
addr.ToString(), addr.ToString(),
"pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion"); "pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion");
BOOST_REQUIRE(s.empty()); BOOST_REQUIRE(s.empty());
// Invalid TORv3, with bogus length. // Invalid TORv3, with bogus length.
s << Span{ParseHex("04" // network type (TORv3) s << Span{ParseHex("04" // network type (TORv3)
"00" // address length "00" // address length
"00" // address "00" // address
)}; )};
BOOST_CHECK_EXCEPTION( BOOST_CHECK_EXCEPTION(
s >> addr, std::ios_base::failure, s >> WithParams(ser_params, addr), std::ios_base::failure,
HasReason("BIP155 TORv3 address with length 0 (should be 32)")); HasReason("BIP155 TORv3 address with length 0 (should be 32)"));
BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input. BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
s.clear(); s.clear();
// Valid I2P. // Valid I2P.
s << Span{ParseHex("05" // network type (I2P) s << Span{ParseHex("05" // network type (I2P)
"20" // address length "20" // address length
"a2894dabaec08c0051a481a6dac88b64" // address "a2894dabaec08c0051a481a6dac88b64" // address
"f98232ae42d4b6fd2fa81952dfe36a87")}; "f98232ae42d4b6fd2fa81952dfe36a87")};
s >> addr; s >> WithParams(ser_params, addr);
BOOST_CHECK(addr.IsValid()); BOOST_CHECK(addr.IsValid());
BOOST_CHECK(addr.IsI2P()); BOOST_CHECK(addr.IsI2P());
BOOST_CHECK(!addr.IsAddrV1Compatible()); BOOST_CHECK(!addr.IsAddrV1Compatible());
BOOST_CHECK_EQUAL( BOOST_CHECK_EQUAL(
addr.ToString(), addr.ToString(),
"ukeu3k5oycgaauneqgtnvselmt4yemvoilkln7jpvamvfx7dnkdq.b32.i2p"); "ukeu3k5oycgaauneqgtnvselmt4yemvoilkln7jpvamvfx7dnkdq.b32.i2p");
BOOST_REQUIRE(s.empty()); BOOST_REQUIRE(s.empty());
// Invalid I2P, with bogus length. // Invalid I2P, with bogus length.
s << Span{ParseHex("05" // network type (I2P) s << Span{ParseHex("05" // network type (I2P)
"03" // address length "03" // address length
"00" // address "00" // address
)}; )};
BOOST_CHECK_EXCEPTION( BOOST_CHECK_EXCEPTION(
s >> addr, std::ios_base::failure, s >> WithParams(ser_params, addr), std::ios_base::failure,
HasReason("BIP155 I2P address with length 3 (should be 32)")); HasReason("BIP155 I2P address with length 3 (should be 32)"));
BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input. BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
s.clear(); s.clear();
// Valid CJDNS. // Valid CJDNS.
s << Span{ParseHex("06" // network type (CJDNS) s << Span{ParseHex("06" // network type (CJDNS)
"10" // address length "10" // address length
"fc000001000200030004000500060007" // address "fc000001000200030004000500060007" // address
)}; )};
s >> addr; s >> WithParams(ser_params, addr);
BOOST_CHECK(addr.IsValid()); BOOST_CHECK(addr.IsValid());
BOOST_CHECK(addr.IsCJDNS()); BOOST_CHECK(addr.IsCJDNS());
BOOST_CHECK(!addr.IsAddrV1Compatible()); BOOST_CHECK(!addr.IsAddrV1Compatible());
BOOST_CHECK_EQUAL(addr.ToString(), "fc00:1:2:3:4:5:6:7"); BOOST_CHECK_EQUAL(addr.ToString(), "fc00:1:2:3:4:5:6:7");
BOOST_REQUIRE(s.empty()); BOOST_REQUIRE(s.empty());
// Invalid CJDNS, with bogus length. // Invalid CJDNS, with bogus length.
s << Span{ParseHex("06" // network type (CJDNS) s << Span{ParseHex("06" // network type (CJDNS)
"01" // address length "01" // address length
"00" // address "00" // address
)}; )};
BOOST_CHECK_EXCEPTION( BOOST_CHECK_EXCEPTION(
s >> addr, std::ios_base::failure, s >> WithParams(ser_params, addr), std::ios_base::failure,
HasReason("BIP155 CJDNS address with length 1 (should be 16)")); HasReason("BIP155 CJDNS address with length 1 (should be 16)"));
BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input. BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
s.clear(); s.clear();
// Unknown, with extreme length. // Unknown, with extreme length.
s << Span{ParseHex("aa" // network type (unknown) s << Span{ParseHex("aa" // network type (unknown)
"fe00000002" // address length (CompactSize's MAX_SIZE) "fe00000002" // address length (CompactSize's MAX_SIZE)
"01020304050607" // address "01020304050607" // address
)}; )};
BOOST_CHECK_EXCEPTION(s >> WithParams(ser_params, addr),
BOOST_CHECK_EXCEPTION(s >> addr, std::ios_base::failure, std::ios_base::failure,
HasReason("Address too long: 33554432 > 512")); HasReason("Address too long: 33554432 > 512"));
BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input. BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
s.clear(); s.clear();
// Unknown, with reasonable length. // Unknown, with reasonable length.
s << Span{ParseHex("aa" // network type (unknown) s << Span{ParseHex("aa" // network type (unknown)
"04" // address length "04" // address length
"01020304" // address "01020304" // address
)}; )};
s >> addr; s >> WithParams(ser_params, addr);
BOOST_CHECK(!addr.IsValid()); BOOST_CHECK(!addr.IsValid());
BOOST_REQUIRE(s.empty()); BOOST_REQUIRE(s.empty());
// Unknown, with zero length. // Unknown, with zero length.
s << Span{ParseHex("aa" // network type (unknown) s << Span{ParseHex("aa" // network type (unknown)
"00" // address length "00" // address length
"" // address "" // address
)}; )};
s >> addr; s >> WithParams(ser_params, addr);
BOOST_CHECK(!addr.IsValid()); BOOST_CHECK(!addr.IsValid());
BOOST_REQUIRE(s.empty()); BOOST_REQUIRE(s.empty());
} }
// prior to PR #14728, this test triggers an undefined behavior // prior to PR #14728, this test triggers an undefined behavior
BOOST_AUTO_TEST_CASE(ipv4_peer_with_ipv6_addrMe_test) { BOOST_AUTO_TEST_CASE(ipv4_peer_with_ipv6_addrMe_test) {
// set up local addresses; all that's necessary to reproduce the bug is // set up local addresses; all that's necessary to reproduce the bug is
// that a normal IPv4 address is among the entries, but if this address is // that a normal IPv4 address is among the entries, but if this address is
▲ Show 20 Lines • Show All 415 Lines • ▼ Show 20 LinesBOOST_AUTO_TEST_CASE(initial_advertise_from_version_message) {
m_node.peerman->InitializeNode(config, peer, NODE_NETWORK); m_node.peerman->InitializeNode(config, peer, NODE_NETWORK);
std::atomic<bool> interrupt_dummy{false}; std::atomic<bool> interrupt_dummy{false};
std::chrono::microseconds time_received_dummy{0}; std::chrono::microseconds time_received_dummy{0};
const auto msg_version = const auto msg_version =
msg_maker.Make(NetMsgType::VERSION, PROTOCOL_VERSION, services, time, msg_maker.Make(NetMsgType::VERSION, PROTOCOL_VERSION, services, time,
services, peer_us); services, WithParams(CAddress::V1_NETWORK, peer_us));
CDataStream msg_version_stream{msg_version.data, SER_NETWORK, CDataStream msg_version_stream{msg_version.data, SER_NETWORK,
PROTOCOL_VERSION}; PROTOCOL_VERSION};
m_node.peerman->ProcessMessage(config, peer, NetMsgType::VERSION, m_node.peerman->ProcessMessage(config, peer, NetMsgType::VERSION,
msg_version_stream, time_received_dummy, msg_version_stream, time_received_dummy,
interrupt_dummy); interrupt_dummy);
const auto msg_verack = msg_maker.Make(NetMsgType::VERACK); const auto msg_verack = msg_maker.Make(NetMsgType::VERACK);
Show All 10 LinesBOOST_AUTO_TEST_CASE(initial_advertise_from_version_message) {
const CService expected{peer_us_addr, bind_port}; const CService expected{peer_us_addr, bind_port};
bool sent{false}; bool sent{false};
const auto CaptureMessageOrig = CaptureMessage; const auto CaptureMessageOrig = CaptureMessage;
CaptureMessage = CaptureMessage =
[&sent, &expected](const CAddress &addr, const std::string &msg_type, [&sent, &expected](const CAddress &addr, const std::string &msg_type,
Span<const uint8_t> data, bool is_incoming) -> void { Span<const uint8_t> data, bool is_incoming) -> void {
if (!is_incoming && msg_type == "addr") { if (!is_incoming && msg_type == "addr") {
CDataStream s(data, SER_NETWORK, PROTOCOL_VERSION); DataStream s{data};
std::vector<CAddress> addresses; std::vector<CAddress> addresses;
s >> addresses; s >> WithParams(CAddress::V1_NETWORK, addresses);
for (const auto &deserialized_addr : addresses) { for (const auto &deserialized_addr : addresses) {
if (deserialized_addr == expected) { if (deserialized_addr == expected) {
sent = true; sent = true;
return; return;
} }
} }
} }
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines