Page MenuHomePhabricator
Differential D14750 Diff 42980 src/test/net_tests.cpp

Changeset View

Standalone View

View Options

src/test/net_tests.cpp

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines void AddNode(ConnectionType type) {
CAddress addr( CAddress addr(
CService(ip(GetRandInt(0xffffffff)), Params().GetDefaultPort()), CService(ip(GetRandInt(0xffffffff)), Params().GetDefaultPort()),
NODE_NONE); NODE_NONE);
return AddNode(addr, type); return AddNode(addr, type);
} }
void AddNode(const CAddress &addr, ConnectionType type) { void AddNode(const CAddress &addr, ConnectionType type) {
ServiceFlags services = NODE_NETWORK; CNode *pnode = new CNode(nodeid++, INVALID_SOCKET, addr,
if (type == ConnectionType::AVALANCHE_OUTBOUND) {
services = ServiceFlags(services | NODE_AVALANCHE);
}
PiRKAuthorUnsubmitted
Done
Inline Actions

The services flags turned out to not be needed in the test using this function, the connection type is enough.

PiRK: The services flags turned out to not be needed in the test using this function, the connection…
CNode *pnode = new CNode(nodeid++, services, INVALID_SOCKET, addr,
CalculateKeyedNetGroup(addr), CalculateKeyedNetGroup(addr),
/* nLocalHostNonceIn */ 0, /* nLocalHostNonceIn */ 0,
/* nLocalExtraEntropyIn */ 0, addr, /* nLocalExtraEntropyIn */ 0, addr,
/* pszDest */ "", type, /* pszDest */ "", type,
/* inbound_onion */ false); /* inbound_onion */ false);
LOCK(m_nodes_mutex); LOCK(m_nodes_mutex);
m_nodes.push_back(pnode); m_nodes.push_back(pnode);
▲ Show 20 Lines • Show All 185 Lines • ▼ Show 20 LinesBOOST_AUTO_TEST_CASE(cnode_simple_test) {
in_addr ipv4Addr; in_addr ipv4Addr;
ipv4Addr.s_addr = 0xa0b0c001; ipv4Addr.s_addr = 0xa0b0c001;
CAddress addr = CAddress(CService(ipv4Addr, 7777), NODE_NETWORK); CAddress addr = CAddress(CService(ipv4Addr, 7777), NODE_NETWORK);
std::string pszDest; std::string pszDest;
auto pnode1 = auto pnode1 =
std::make_unique<CNode>(id++, NODE_NETWORK, hSocket, addr, std::make_unique<CNode>(id++, hSocket, addr,
/* nKeyedNetGroupIn = */ 0, /* nKeyedNetGroupIn = */ 0,
/* nLocalHostNonceIn = */ 0, /* nLocalHostNonceIn = */ 0,
/* nLocalExtraEntropyIn */ 0, CAddress(), /* nLocalExtraEntropyIn */ 0, CAddress(),
pszDest, ConnectionType::OUTBOUND_FULL_RELAY, pszDest, ConnectionType::OUTBOUND_FULL_RELAY,
/* inbound_onion = */ false); /* inbound_onion = */ false);
BOOST_CHECK(pnode1->IsFullOutboundConn() == true); BOOST_CHECK(pnode1->IsFullOutboundConn() == true);
BOOST_CHECK(pnode1->IsManualConn() == false); BOOST_CHECK(pnode1->IsManualConn() == false);
BOOST_CHECK(pnode1->IsBlockOnlyConn() == false); BOOST_CHECK(pnode1->IsBlockOnlyConn() == false);
BOOST_CHECK(pnode1->IsFeelerConn() == false); BOOST_CHECK(pnode1->IsFeelerConn() == false);
BOOST_CHECK(pnode1->IsAddrFetchConn() == false); BOOST_CHECK(pnode1->IsAddrFetchConn() == false);
BOOST_CHECK(pnode1->IsInboundConn() == false); BOOST_CHECK(pnode1->IsInboundConn() == false);
BOOST_CHECK(pnode1->m_inbound_onion == false); BOOST_CHECK(pnode1->m_inbound_onion == false);
BOOST_CHECK_EQUAL(pnode1->ConnectedThroughNetwork(), Network::NET_IPV4); BOOST_CHECK_EQUAL(pnode1->ConnectedThroughNetwork(), Network::NET_IPV4);
auto pnode2 = std::make_unique<CNode>(id++, NODE_NETWORK, hSocket, addr, 1, auto pnode2 =
1, 1, CAddress(), pszDest, std::make_unique<CNode>(id++, hSocket, addr, 1, 1, 1, CAddress(),
ConnectionType::INBOUND, false); pszDest, ConnectionType::INBOUND, false);
BOOST_CHECK(pnode2->IsFullOutboundConn() == false); BOOST_CHECK(pnode2->IsFullOutboundConn() == false);
BOOST_CHECK(pnode2->IsManualConn() == false); BOOST_CHECK(pnode2->IsManualConn() == false);
BOOST_CHECK(pnode2->IsBlockOnlyConn() == false); BOOST_CHECK(pnode2->IsBlockOnlyConn() == false);
BOOST_CHECK(pnode2->IsFeelerConn() == false); BOOST_CHECK(pnode2->IsFeelerConn() == false);
BOOST_CHECK(pnode2->IsAddrFetchConn() == false); BOOST_CHECK(pnode2->IsAddrFetchConn() == false);
BOOST_CHECK(pnode2->IsInboundConn() == true); BOOST_CHECK(pnode2->IsInboundConn() == true);
BOOST_CHECK(pnode2->m_inbound_onion == false); BOOST_CHECK(pnode2->m_inbound_onion == false);
BOOST_CHECK_EQUAL(pnode2->ConnectedThroughNetwork(), Network::NET_IPV4); BOOST_CHECK_EQUAL(pnode2->ConnectedThroughNetwork(), Network::NET_IPV4);
auto pnode3 = std::make_unique<CNode>( auto pnode3 = std::make_unique<CNode>(
id++, NODE_NETWORK, hSocket, addr, 0, 0, 0, CAddress(), pszDest, id++, hSocket, addr, 0, 0, 0, CAddress(), pszDest,
ConnectionType::OUTBOUND_FULL_RELAY, false); ConnectionType::OUTBOUND_FULL_RELAY, false);
BOOST_CHECK(pnode3->IsFullOutboundConn() == true); BOOST_CHECK(pnode3->IsFullOutboundConn() == true);
BOOST_CHECK(pnode3->IsManualConn() == false); BOOST_CHECK(pnode3->IsManualConn() == false);
BOOST_CHECK(pnode3->IsBlockOnlyConn() == false); BOOST_CHECK(pnode3->IsBlockOnlyConn() == false);
BOOST_CHECK(pnode3->IsFeelerConn() == false); BOOST_CHECK(pnode3->IsFeelerConn() == false);
BOOST_CHECK(pnode3->IsAddrFetchConn() == false); BOOST_CHECK(pnode3->IsAddrFetchConn() == false);
BOOST_CHECK(pnode3->IsInboundConn() == false); BOOST_CHECK(pnode3->IsInboundConn() == false);
BOOST_CHECK(pnode3->m_inbound_onion == false); BOOST_CHECK(pnode3->m_inbound_onion == false);
BOOST_CHECK_EQUAL(pnode3->ConnectedThroughNetwork(), Network::NET_IPV4); BOOST_CHECK_EQUAL(pnode3->ConnectedThroughNetwork(), Network::NET_IPV4);
auto pnode4 = std::make_unique<CNode>(id++, NODE_NETWORK, hSocket, addr, 1, auto pnode4 =
1, 1, CAddress(), pszDest, std::make_unique<CNode>(id++, hSocket, addr, 1, 1, 1, CAddress(),
ConnectionType::INBOUND, true); pszDest, ConnectionType::INBOUND, true);
BOOST_CHECK(pnode4->IsFullOutboundConn() == false); BOOST_CHECK(pnode4->IsFullOutboundConn() == false);
BOOST_CHECK(pnode4->IsManualConn() == false); BOOST_CHECK(pnode4->IsManualConn() == false);
BOOST_CHECK(pnode4->IsBlockOnlyConn() == false); BOOST_CHECK(pnode4->IsBlockOnlyConn() == false);
BOOST_CHECK(pnode4->IsFeelerConn() == false); BOOST_CHECK(pnode4->IsFeelerConn() == false);
BOOST_CHECK(pnode4->IsAddrFetchConn() == false); BOOST_CHECK(pnode4->IsAddrFetchConn() == false);
BOOST_CHECK(pnode4->IsInboundConn() == true); BOOST_CHECK(pnode4->IsInboundConn() == true);
BOOST_CHECK(pnode4->m_inbound_onion == true); BOOST_CHECK(pnode4->m_inbound_onion == true);
BOOST_CHECK_EQUAL(pnode4->ConnectedThroughNetwork(), Network::NET_ONION); BOOST_CHECK_EQUAL(pnode4->ConnectedThroughNetwork(), Network::NET_ONION);
▲ Show 20 Lines • Show All 571 Lines • ▼ Show 20 Lines const CNetAddr mapLocalHost_entry = CNetAddr(raw_addr);
mapLocalHost[mapLocalHost_entry] = lsi; mapLocalHost[mapLocalHost_entry] = lsi;
} }
// create a peer with an IPv4 address // create a peer with an IPv4 address
in_addr ipv4AddrPeer; in_addr ipv4AddrPeer;
ipv4AddrPeer.s_addr = 0xa0b0c001; ipv4AddrPeer.s_addr = 0xa0b0c001;
CAddress addr = CAddress(CService(ipv4AddrPeer, 7777), NODE_NETWORK); CAddress addr = CAddress(CService(ipv4AddrPeer, 7777), NODE_NETWORK);
std::unique_ptr<CNode> pnode = std::make_unique<CNode>( std::unique_ptr<CNode> pnode = std::make_unique<CNode>(
0, NODE_NETWORK, INVALID_SOCKET, addr, /* nKeyedNetGroupIn */ 0, 0, INVALID_SOCKET, addr, /* nKeyedNetGroupIn */ 0,
/* nLocalHostNonceIn */ 0, /* nLocalExtraEntropyIn */ 0, CAddress{}, /* nLocalHostNonceIn */ 0, /* nLocalExtraEntropyIn */ 0, CAddress{},
/* pszDest */ std::string{}, ConnectionType::OUTBOUND_FULL_RELAY, /* pszDest */ std::string{}, ConnectionType::OUTBOUND_FULL_RELAY,
/* inbound_onion = */ false); /* inbound_onion = */ false);
pnode->fSuccessfullyConnected.store(true); pnode->fSuccessfullyConnected.store(true);
// the peer claims to be reaching us via IPv6 // the peer claims to be reaching us via IPv6
in6_addr ipv6AddrLocal; in6_addr ipv6AddrLocal;
memset(ipv6AddrLocal.s6_addr, 0, 16); memset(ipv6AddrLocal.s6_addr, 0, 16);
Show All 39 LinesBOOST_AUTO_TEST_CASE(get_local_addr_for_peer_port) {
peer_us_addr.s_addr = htonl(0x02030405); peer_us_addr.s_addr = htonl(0x02030405);
const CService peer_us{peer_us_addr, 20002}; const CService peer_us{peer_us_addr, 20002};
// Create a peer with a routable IPv4 address (outbound). // Create a peer with a routable IPv4 address (outbound).
in_addr peer_out_in_addr; in_addr peer_out_in_addr;
peer_out_in_addr.s_addr = htonl(0x01020304); peer_out_in_addr.s_addr = htonl(0x01020304);
CNode peer_out{ CNode peer_out{
/*id=*/0, /*id=*/0,
/*nLocalServicesIn=*/NODE_NETWORK,
/*hSocketIn=*/INVALID_SOCKET, /*hSocketIn=*/INVALID_SOCKET,
/*addrIn=*/CAddress{CService{peer_out_in_addr, 8333}, NODE_NETWORK}, /*addrIn=*/CAddress{CService{peer_out_in_addr, 8333}, NODE_NETWORK},
/*nKeyedNetGroupIn=*/0, /*nKeyedNetGroupIn=*/0,
/*nLocalHostNonceIn=*/0, /*nLocalHostNonceIn=*/0,
/*nLocalExtraEntropyIn=*/0, /*nLocalExtraEntropyIn=*/0,
/*addrBindIn=*/CAddress{}, /*addrBindIn=*/CAddress{},
/*addrNameIn=*/std::string{}, /*addrNameIn=*/std::string{},
/*conn_type_in=*/ConnectionType::OUTBOUND_FULL_RELAY, /*conn_type_in=*/ConnectionType::OUTBOUND_FULL_RELAY,
/*inbound_onion=*/false}; /*inbound_onion=*/false};
peer_out.fSuccessfullyConnected = true; peer_out.fSuccessfullyConnected = true;
peer_out.SetAddrLocal(peer_us); peer_out.SetAddrLocal(peer_us);
// Without the fix peer_us:8333 is chosen instead of the proper // Without the fix peer_us:8333 is chosen instead of the proper
// peer_us:bind_port. // peer_us:bind_port.
auto chosen_local_addr = GetLocalAddrForPeer(peer_out); auto chosen_local_addr = GetLocalAddrForPeer(peer_out);
BOOST_REQUIRE(chosen_local_addr); BOOST_REQUIRE(chosen_local_addr);
const CService expected{peer_us_addr, bind_port}; const CService expected{peer_us_addr, bind_port};
BOOST_CHECK(*chosen_local_addr == expected); BOOST_CHECK(*chosen_local_addr == expected);
// Create a peer with a routable IPv4 address (inbound). // Create a peer with a routable IPv4 address (inbound).
in_addr peer_in_in_addr; in_addr peer_in_in_addr;
peer_in_in_addr.s_addr = htonl(0x05060708); peer_in_in_addr.s_addr = htonl(0x05060708);
CNode peer_in{ CNode peer_in{
/*id=*/0, /*id=*/0,
/*nLocalServicesIn=*/NODE_NETWORK,
/*hSocketIn=*/INVALID_SOCKET, /*hSocketIn=*/INVALID_SOCKET,
/*addrIn=*/CAddress{CService{peer_in_in_addr, 8333}, NODE_NETWORK}, /*addrIn=*/CAddress{CService{peer_in_in_addr, 8333}, NODE_NETWORK},
/*nKeyedNetGroupIn=*/0, /*nKeyedNetGroupIn=*/0,
/*nLocalHostNonceIn=*/0, /*nLocalHostNonceIn=*/0,
/*nLocalExtraEntropyIn=*/0, /*nLocalExtraEntropyIn=*/0,
/*addrBindIn=*/CAddress{}, /*addrBindIn=*/CAddress{},
/*addrNameIn=*/std::string{}, /*addrNameIn=*/std::string{},
/*conn_type_in=*/ConnectionType::INBOUND, /*conn_type_in=*/ConnectionType::INBOUND,
Show All 19 Lines const std::vector<std::tuple<uint32_t, uint32_t, double>> testCases = {
AVALANCHE_STATISTICS_TIME_CONSTANT.count(), AVALANCHE_STATISTICS_TIME_CONSTANT.count(),
AVALANCHE_STATISTICS_DECAY_FACTOR}, AVALANCHE_STATISTICS_DECAY_FACTOR},
}; };
for (const auto &[step, tau, decayFactor] : testCases) { for (const auto &[step, tau, decayFactor] : testCases) {
in_addr ipv4Addr; in_addr ipv4Addr;
ipv4Addr.s_addr = 0xa0b0c001; ipv4Addr.s_addr = 0xa0b0c001;
CAddress addr = CAddress(CService(ipv4Addr, 7777), NODE_NETWORK); CAddress addr = CAddress(CService(ipv4Addr, 7777), NODE_NETWORK);
std::unique_ptr<CNode> pnode = std::make_unique<CNode>( std::unique_ptr<CNode> pnode = std::make_unique<CNode>(
0, NODE_NETWORK, INVALID_SOCKET, addr, 0, 0, 0, CAddress(), 0, INVALID_SOCKET, addr, 0, 0, 0, CAddress(), std::string{},
std::string{}, ConnectionType::OUTBOUND_FULL_RELAY, false); ConnectionType::OUTBOUND_FULL_RELAY, false);
pnode->m_avalanche_enabled = true; pnode->m_avalanche_enabled = true;
double previousScore = pnode->getAvailabilityScore(); double previousScore = pnode->getAvailabilityScore();
BOOST_CHECK_SMALL(previousScore, 1e-6); BOOST_CHECK_SMALL(previousScore, 1e-6);
// Check the statistics follow an exponential response for 1 to 10 tau // Check the statistics follow an exponential response for 1 to 10 tau
for (size_t i = 1; i <= 10; i++) { for (size_t i = 1; i <= 10; i++) {
for (uint32_t j = 0; j < tau; j += step) { for (uint32_t j = 0; j < tau; j += step) {
▲ Show 20 Lines • Show All 250 Lines • ▼ Show 20 LinesBOOST_AUTO_TEST_CASE(initial_advertise_from_version_message) {
peer_us_addr.s_addr = htonl(0x02030405); peer_us_addr.s_addr = htonl(0x02030405);
const CService peer_us{peer_us_addr, 20002}; const CService peer_us{peer_us_addr, 20002};
const CAddress addr_us{peer_us, NODE_NETWORK}; const CAddress addr_us{peer_us, NODE_NETWORK};
// Create a peer with a routable IPv4 address. // Create a peer with a routable IPv4 address.
in_addr peer_in_addr; in_addr peer_in_addr;
peer_in_addr.s_addr = htonl(0x01020304); peer_in_addr.s_addr = htonl(0x01020304);
CNode peer{/*id=*/0, CNode peer{/*id=*/0,
/*nLocalServicesIn=*/NODE_NETWORK,
/*hSocketIn=*/INVALID_SOCKET, /*hSocketIn=*/INVALID_SOCKET,
/*addrIn=*/CAddress{CService{peer_in_addr, 8333}, NODE_NETWORK}, /*addrIn=*/CAddress{CService{peer_in_addr, 8333}, NODE_NETWORK},
/*nKeyedNetGroupIn=*/0, /*nKeyedNetGroupIn=*/0,
/*nLocalHostNonceIn=*/0, /*nLocalHostNonceIn=*/0,
/*nLocalExtraEntropyIn=*/0, /*nLocalExtraEntropyIn=*/0,
/*addrBindIn=*/CAddress{}, /*addrBindIn=*/CAddress{},
/*addrNameIn=*/std::string{}, /*addrNameIn=*/std::string{},
/*conn_type_in=*/ConnectionType::OUTBOUND_FULL_RELAY, /*conn_type_in=*/ConnectionType::OUTBOUND_FULL_RELAY,
/*inbound_onion=*/false}; /*inbound_onion=*/false};
const uint64_t services{NODE_NETWORK}; const uint64_t services{NODE_NETWORK};
const int64_t time{0}; const int64_t time{0};
const CNetMsgMaker msg_maker{PROTOCOL_VERSION}; const CNetMsgMaker msg_maker{PROTOCOL_VERSION};
// Force CChainState::IsInitialBlockDownload() to return false. // Force CChainState::IsInitialBlockDownload() to return false.
// Otherwise PushAddress() isn't called by PeerManager::ProcessMessage(). // Otherwise PushAddress() isn't called by PeerManager::ProcessMessage().
TestChainState &chainstate = TestChainState &chainstate =
*static_cast<TestChainState *>(&m_node.chainman->ActiveChainstate()); *static_cast<TestChainState *>(&m_node.chainman->ActiveChainstate());
chainstate.JumpOutOfIbd(); chainstate.JumpOutOfIbd();
const Config &config = GetConfig(); const Config &config = GetConfig();
m_node.peerman->InitializeNode(config, peer, peer.GetLocalServices()); 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 = msg_maker.Make( const auto msg_version = msg_maker.Make(
NetMsgType::VERSION, PROTOCOL_VERSION, services, time, addr_us); NetMsgType::VERSION, PROTOCOL_VERSION, services, time, addr_us);
CDataStream msg_version_stream{msg_version.data, SER_NETWORK, CDataStream msg_version_stream{msg_version.data, SER_NETWORK,
PROTOCOL_VERSION}; PROTOCOL_VERSION};
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines