addrman.h

Go to the documentation of this file.

// Copyright (c) 2012 Pieter Wuille
// Copyright (c) 2012-present The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_ADDRMAN_H
#define BITCOIN_ADDRMAN_H
 
#include <netaddress.h>
#include <netgroup.h>
#include <protocol.h>
#include <streams.h>
#include <util/time.h>
 
#include <cstdint>
#include <memory>
#include <optional>
#include <unordered_set>
#include <utility>
#include <vector>
 
static constexpr uint32_t ADDRMAN_TRIED_BUCKETS_PER_GROUP{8};
static constexpr uint32_t ADDRMAN_NEW_BUCKETS_PER_SOURCE_GROUP{64};
static constexpr int32_t ADDRMAN_NEW_BUCKETS_PER_ADDRESS{8};
static constexpr auto ADDRMAN_HORIZON{30 * 24h};
static constexpr int32_t ADDRMAN_RETRIES{3};
static constexpr int32_t ADDRMAN_MAX_FAILURES{10};
static constexpr auto ADDRMAN_MIN_FAIL{7 * 24h};
static constexpr auto ADDRMAN_REPLACEMENT{4h};
static constexpr size_t ADDRMAN_SET_TRIED_COLLISION_SIZE{10};
static constexpr auto ADDRMAN_TEST_WINDOW{40min};
 
class InvalidAddrManVersionError : public std::ios_base::failure
{
public:
    InvalidAddrManVersionError(std::string msg) : std::ios_base::failure(msg) { }
};
 
class AddrManImpl;
class AddrInfo;
 
static constexpr int32_t DEFAULT_ADDRMAN_CONSISTENCY_CHECKS{0};
 
struct AddressPosition {
    // Whether the address is in the new or tried table
    const bool tried;
 
    // Addresses in the tried table should always have a multiplicity of 1.
    // Addresses in the new table can have multiplicity between 1 and
    // ADDRMAN_NEW_BUCKETS_PER_ADDRESS
    const int multiplicity;
 
    // If the address is in the new table, the bucket and position are
    // populated based on the first source who sent the address.
    // In certain edge cases, this may not be where the address is currently
    // located.
    const int bucket;
    const int position;
 
    bool operator==(AddressPosition other) {
        return std::tie(tried, multiplicity, bucket, position) ==
               std::tie(other.tried, other.multiplicity, other.bucket, other.position);
    }
    explicit AddressPosition(bool tried_in, int multiplicity_in, int bucket_in, int position_in)
        : tried{tried_in}, multiplicity{multiplicity_in}, bucket{bucket_in}, position{position_in} {}
};
 
class AddrMan
{
protected:
    const std::unique_ptr<AddrManImpl> m_impl;
 
public:
    explicit AddrMan(const NetGroupManager& netgroupman, bool deterministic, int32_t consistency_check_ratio);
 
    ~AddrMan();
 
    template <typename Stream>
    void Serialize(Stream& s_) const;
 
    template <typename Stream>
    void Unserialize(Stream& s_);
 
    size_t Size(std::optional<Network> net = std::nullopt, std::optional<bool> in_new = std::nullopt) const;
 
    bool Add(const std::vector<CAddress>& vAddr, const CNetAddr& source, std::chrono::seconds time_penalty = 0s);
 
    bool Good(const CService& addr, NodeSeconds time = Now<NodeSeconds>());
 
    void Attempt(const CService& addr, bool fCountFailure, NodeSeconds time = Now<NodeSeconds>());
 
    void ResolveCollisions();
 
    std::pair<CAddress, NodeSeconds> SelectTriedCollision();
 
    std::pair<CAddress, NodeSeconds> Select(bool new_only = false, const std::unordered_set<Network>& networks = {}) const;
 
    std::vector<CAddress> GetAddr(size_t max_addresses, size_t max_pct, std::optional<Network> network, bool filtered = true) const;
 
    std::vector<std::pair<AddrInfo, AddressPosition>> GetEntries(bool from_tried) const;
 
    void Connected(const CService& addr, NodeSeconds time = Now<NodeSeconds>());
 
    void SetServices(const CService& addr, ServiceFlags nServices);
 
    std::optional<AddressPosition> FindAddressEntry(const CAddress& addr);
};
 
#endif // BITCOIN_ADDRMAN_H