Connections and transport

4251            break;
4252        }
4253    }
4254    return found != nullptr && NodeFullyConnected(found) && func(found);
4255}
4256
4257CSipHasher CConnman::GetDeterministicRandomizer(uint64_t id) const
4258{
4259    return CSipHasher(nSeed0, nSeed1).Write(id);
4260}
4261
4262uint64_t CConnman::CalculateKeyedNetGroup(const CNetAddr& address) const
4263{
4264    std::vector<unsigned char> vchNetGroup(m_netgroupman.GetGroup(address));
4265
4266    return GetDeterministicRandomizer(RANDOMIZER_ID_NETGROUP).Write(vchNetGroup).Finalize();
4267}
4268
4269void CConnman::PerformReconnections()
4270{
4271    AssertLockNotHeld(m_nodes_mutex);
4272    AssertLockNotHeld(m_reconnections_mutex);
4273    AssertLockNotHeld(m_unused_i2p_sessions_mutex);
4274    while (true) {
4275        // Move first element of m_reconnections to todo (avoiding an allocation inside the lock).
4276        decltype(m_reconnections) todo;
4277        {
4278            LOCK(m_reconnections_mutex);
4279            if (m_reconnections.empty()) break;
4280            todo.splice(todo.end(), m_reconnections, m_reconnections.begin());
4281        }
4282
4283        auto& item = *todo.begin();
4284        OpenNetworkConnection(item.addr_connect,
4285                              // We only reconnect if the first attempt to connect succeeded at
4286                              // connection time, but then failed after the CNode object was
4287                              // created. Since we already know connecting is possible, do not
4288                              // count failure to reconnect.
4289                              /*fCountFailure=*/false,
4290                              std::move(item.grant),
4291                              item.destination.empty() ? nullptr : item.destination.c_str(),
4292                              item.conn_type,
4293                              item.use_v2transport,
4294                              item.proxy_override);
4295    }
4296}
4297
4298void CConnman::ASMapHealthCheck()
4299{
4300    const std::vector<CAddress> v4_addrs{GetAddressesUnsafe(/*max_addresses=*/0, /*max_pct=*/0, Network::NET_IPV4, /*filtered=*/false)};
4301    const std::vector<CAddress> v6_addrs{GetAddressesUnsafe(/*max_addresses=*/0, /*max_pct=*/0, Network::NET_IPV6, /*filtered=*/false)};
4302    std::vector<CNetAddr> clearnet_addrs;
4303    clearnet_addrs.reserve(v4_addrs.size() + v6_addrs.size());
4304    std::transform(v4_addrs.begin(), v4_addrs.end(), std::back_inserter(clearnet_addrs),
4305        [](const CAddress& addr) { return static_cast<CNetAddr>(addr); });
4306    std::transform(v6_addrs.begin(), v6_addrs.end(), std::back_inserter(clearnet_addrs),
4307        [](const CAddress& addr) { return static_cast<CNetAddr>(addr); });
4308    m_netgroupman.ASMapHealthCheck(clearnet_addrs);
4309}
4310
4311// Dump binary message to file, with timestamp.
4312static void CaptureMessageToFile(const CAddress& addr,
4313                                 const std::string& msg_type,
4314                                 std::span<const unsigned char> data,
4315                                 bool is_incoming)
4316{
4317    // Note: This function captures the message at the time of processing,
4318    // not at socket receive/send time.
4319    // This ensures that the messages are always in order from an application
4320    // layer (processing) perspective.
4321    auto now = GetTime<std::chrono::microseconds>();
4322
4323    // Windows folder names cannot include a colon
4324    std::string clean_addr = addr.ToStringAddrPort();
4325    std::replace(clean_addr.begin(), clean_addr.end(), ':', '_');
4326
4327    fs::path base_path = gArgs.GetDataDirNet() / "message_capture" / fs::u8path(clean_addr);
4328    fs::create_directories(base_path);
4329
4330    fs::path path = base_path / (is_incoming ? "msgs_recv.dat" : "msgs_sent.dat");
4331    AutoFile f{fsbridge::fopen(path, "ab")};
4332
4333    ser_writedata64(f, now.count());
4334    f << std::span{msg_type};
4335    for (auto i = msg_type.length(); i < CMessageHeader::MESSAGE_TYPE_SIZE; ++i) {
4336        f << uint8_t{'\0'};
4337    }
4338    uint32_t size = data.size();
4339    ser_writedata32(f, size);
4340    f << data;
4341
4342    if (f.fclose() != 0) {
4343        throw std::ios_base::failure(
4344            strprintf("Error closing %s after write, file contents are likely incomplete", fs::PathToString(path)));
4345    }
4346}
4347
4348std::function<void(const CAddress& addr,
4349                   const std::string& msg_type,
4350                   std::span<const unsigned char> data,
4351                   bool is_incoming)>
4352    CaptureMessage = CaptureMessageToFile;
4353