librats 1.0.2 → 2.2.0

package/native-src/src/librats/dht/routing_table.h

@@ -0,0 +1,185 @@
+#pragma once
+
+/**
+ * @file routing_table.h
+ * @brief A Kademlia routing table with libtorrent-style dynamic buckets.
+ *
+ * Pure in-memory state — no sockets, no locks. It lives entirely on the DHT actor
+ * thread, so it never synchronises. It also never sends anything itself: liveness
+ * pings are issued by the owning Node, which reports the outcome back through
+ * node_seen() (it replied) / node_failed() (it timed out). That keeps the table a
+ * testable data structure and the I/O in one place.
+ *
+ * Buckets are an ordered list rooted at our own id: buckets_[0] is the *farthest*
+ * region of the keyspace and buckets_.back() the *closest* catch-all. When the last
+ * bucket overflows and a split would actually separate its contacts, a new bucket is
+ * appended and the contacts re-homed. Buckets near the top are larger (the extended
+ * routing table) because that is where the keyspace — and the first hop of almost any
+ * lookup — is densest, so more contacts there means fewer hops.
+ *
+ * Each bucket holds a *live* set — the contacts we route with, up to its size limit —
+ * plus a small *replacement cache* of standbys promoted the moment a live contact
+ * dies. Contact quality (RTT, failures, BEP 42 verification) lives on the NodeEntry
+ * and drives who gets kept, refreshed, or evicted, while a sub-prefix "spread" rule
+ * keeps a full bucket covering as many sub-branches as possible.
+ *
+ * Sybil/eclipse resistance (BEP 42). Admission is IP-diversity limited so no single
+ * operator can pack the table with contacts it controls and hijack lookups:
+ *   1. at most one contact per IP across the whole table, and
+ *   2. at most one contact per /24 (IPv4) or /64 (IPv6) within any single bucket.
+ * Only *public* addresses are constrained — private/loopback/CGNAT IPs can't be the
+ * source of a real Sybil attack and would wrongly collide on a LAN (this mirrors the
+ * BEP 42 exemption already applied by verify_node_id_for_ip). A per-IP count index
+ * (ip_count_) makes rule 1 an O(1) check; rule 2 is a small per-bucket scan.
+ */
+
+#include "librats/core/address.h"
+#include "librats/dht/id.h"
+#include "librats/dht/node_entry.h"
+
+#include <chrono>
+#include <cstddef>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace librats {
+namespace dht {
+
+class RoutingTable {
+public:
+    // Consecutive failures tolerated before a contact with no standby is dropped.
+    static constexpr uint8_t kMaxFailCount = 5;
+
+    // `extended` enables the larger top buckets (the extended routing table). On by
+    // default for production; tests that want uniform k-sized buckets pass false.
+    explicit RoutingTable(const NodeId& self, bool extended = true);
+
+    // -- insertion --------------------------------------------------------------
+
+    // We learned this node exists from someone else's reply. Recorded as unpinged
+    // (a candidate to verify); it can fill a live slot but never splits or evicts a
+    // confirmed contact. `verified` is the caller's BEP 42 verdict on the (id, ip)
+    // pair, used only as a tie-breaker between unpinged candidates.
+    void heard_about(const NodeId& id, const Address& endpoint, bool verified = false);
+
+    // This node replied to us: recorded as confirmed with its RTT. A confirmed
+    // contact may split a full bucket or displace a weaker one, but a healthy contact
+    // alone in its sub-prefix slot is only removed via node_failed(). Returns true if
+    // it ended up live.
+    bool node_seen(const NodeId& id, const Address& endpoint,
+                   uint16_t rtt = NodeEntry::kRttUnknown, bool verified = false);
+
+    // A query to this node timed out. Since this only fires after a real liveness
+    // check failed, the contact is replaced immediately if a standby is waiting;
+    // otherwise it's kept until it exhausts kMaxFailCount, then dropped.
+    void node_failed(const NodeId& id, const Address& endpoint);
+
+    // -- queries ----------------------------------------------------------------
+
+    // Up to `count` contacts closest to `target` (XOR metric), closest first. By
+    // default only confirmed contacts are returned (for answering queries); pass
+    // include_unconfirmed=true to also seed our own lookups from unpinged contacts.
+    std::vector<NodeEntry> find_closest(const NodeId& target, std::size_t count = kBucketSize,
+                                        bool include_unconfirmed = false) const;
+
+    // The live contact most in need of a liveness check: the least-recently-touched
+    // (a never-contacted contact sorts first). The chosen contact is stamped as touched
+    // at `now`, so successive refreshes rotate through different contacts instead of
+    // re-probing this one while its probe is still outstanding. nullopt when there are
+    // no live contacts.
+    std::optional<NodeEntry> next_to_refresh(std::chrono::steady_clock::time_point now);
+
+    std::size_t size() const;                 // number of live contacts
+    bool empty() const { return size() == 0; }
+    int bucket_count() const noexcept { return static_cast<int>(buckets_.size()); }
+
+    // A pretty, multi-line snapshot for periodic DEBUG logging: a header plus one row
+    // per bucket with its live/limit fill bar and best & worst contact. Pure formatting,
+    // no I/O — built only when actually logged (callers guard on the log level).
+    std::string describe() const;
+
+    // -- node id changes (BEP 42) ----------------------------------------------
+
+    const NodeId& self() const noexcept { return self_; }
+    void set_self(const NodeId& id);          // re-buckets every contact against the new id
+
+    // -- persistence ------------------------------------------------------------
+
+    std::vector<NodeEntry> good_contacts() const;                // confirmed live contacts, to save
+    void load_contacts(const std::vector<NodeEntry>& contacts);  // bulk restore, preserving quality
+
+    // -- diagnostics ------------------------------------------------------------
+
+    // True iff the per-IP index (ip_count_) matches a fresh count over the buckets.
+    // Cheap invariant used by tests to prove the IP accounting stays balanced across
+    // arbitrary add/evict/fail churn; not needed at runtime.
+    bool ip_index_consistent() const;
+
+private:
+    struct Bucket {
+        std::vector<NodeEntry> live;          // active contacts, up to bucket_limit(index)
+        std::vector<NodeEntry> replacements;  // standbys, up to kBucketSize
+    };
+
+    // The bucket `id` belongs to: its shared-prefix length with us, capped to the
+    // last (catch-all) bucket. buckets_ is never empty, so this is always valid.
+    int bucket_index(const NodeId& id) const noexcept;
+    // Live-set size limit for a bucket by position: larger near the top when the
+    // extended table is on, otherwise a flat kBucketSize.
+    int bucket_limit(int index) const noexcept;
+
+    // The one insertion path. `e` carries its own quality (pinged/confirmed via
+    // fail_count). Returns true if it ended up in a live set.
+    bool add_node(NodeEntry e);
+
+    // -- IP-diversity admission (Sybil/eclipse resistance) ----------------------
+
+    // May a genuinely new (not-already-known-by-id) contact `e` enter bucket `idx`?
+    // Enforces the two rules above for public IPs only; a same-endpoint contact that
+    // has quietly changed its id is evicted here as a poisoning signal. Non-public
+    // addresses are always admissible. Rare collision handling lives in this one place.
+    bool passes_ip_diversity(Bucket& b, int idx, const NodeEntry& e);
+
+    // Locate the contact currently at endpoint `ep` (ip+port) anywhere in the table.
+    // Only walked on a public-IP collision, so the O(table) cost is off the hot path.
+    struct Located { int bucket; bool live; std::size_t index; };
+    std::optional<Located> find_by_endpoint(const Address& ep);
+
+    // Keep ip_count_ in lock-step with the buckets. The invariant is simple and local:
+    // every push into a live/replacement set calls ip_track, every removal ip_untrack,
+    // and an in-place overwrite goes through assign() (untrack old + track new). Moves
+    // between the two sets are therefore self-balancing. Only public IPs are indexed.
+    void ip_track(const IpAddress& ip);
+    void ip_untrack(const IpAddress& ip);
+    void assign(NodeEntry& slot, const NodeEntry& e);  // overwrite a slot, keeping the index synced
+
+    // May the (full, last) bucket at `index` be split to fit a confirmed `e`?
+    bool can_split(int index, const NodeEntry& e) const;
+    // Append a bucket and re-home the old last bucket's contacts by shared prefix.
+    void split_bucket();
+    // Bucket `b` (index `index`, limit `limit`) is full and `e` is confirmed: free a
+    // slot by evicting the least valuable node while preserving sub-prefix spread.
+    bool replace_for_spread(Bucket& b, int index, int limit, const NodeEntry& e);
+    // Add/refresh a standby, evicting the worst one if the cache is full.
+    void stash_replacement(Bucket& b, const NodeEntry& entry);
+    // Spill live-set overflow into replacements and cap the cache (after a split).
+    void trim_to_limit(int index);
+    // Promote the best standbys into any free live slots a split opened up, so a
+    // parked contact isn't stuck (replacements are never pinged or refreshed).
+    void fill_from_replacements(int index);
+    // Drop trailing empty buckets, but always keep at least one.
+    void prune_empty_back();
+
+    NodeId self_;
+    bool extended_;
+    std::vector<Bucket> buckets_;  // [0] = farthest, back() = closest catch-all
+
+    // Count of live+replacement contacts per *public* IP across the whole table. Backs
+    // rule 1 (one contact per IP) as an O(1) lookup; kept balanced by ip_track/untrack.
+    std::unordered_map<IpAddress, int> ip_count_;
+};
+
+} // namespace dht
+} // namespace librats

package/native-src/src/librats/dht/rpc_manager.cpp

@@ -0,0 +1,127 @@
+#include "librats/dht/rpc_manager.h"
+#include "librats/dht/krpc.h"
+#include "librats/dht/log.h"
+
+#include <vector>
+
+namespace librats {
+namespace dht {
+
+namespace {
+
+// Transaction ids are 2-byte strings on the wire.
+std::string txn_to_string(uint16_t t) {
+    std::string s(2, '\0');
+    s[0] = static_cast<char>((t >> 8) & 0xff);
+    s[1] = static_cast<char>(t & 0xff);
+    return s;
+}
+
+bool string_to_txn(const std::string& s, uint16_t& out) {
+    if (s.size() != 2) return false;
+    out = static_cast<uint16_t>((static_cast<uint8_t>(s[0]) << 8) | static_cast<uint8_t>(s[1]));
+    return true;
+}
+
+} // namespace
+
+uint16_t RpcManager::next_txn() {
+    // Random, unpredictable transaction ids. A counter is trivially predictable, so an off-path
+    // attacker could forge replies to our queries; with a random id it must guess a
+    // 16-bit value *and* spoof the exact endpoint we queried (handle_response checks
+    // both). pending_ is keyed by txn, so re-draw on the rare collision with an id
+    // still in flight — 65536 ids vastly exceed what we ever have outstanding.
+    std::uniform_int_distribution<uint32_t> draw(0, 0xffff);
+    for (int i = 0; i < 65536; ++i) {
+        const uint16_t t = static_cast<uint16_t>(draw(rng_));
+        if (pending_.find(t) == pending_.end()) return t;
+    }
+    return static_cast<uint16_t>(draw(rng_));  // table full — unreachable in practice
+}
+
+bool RpcManager::invoke(KrpcMessage& msg, const Address& to, const ObserverPtr& obs, TimePoint now) {
+    const uint16_t t = next_txn();
+    msg.transaction_id = txn_to_string(t);
+
+    const std::vector<uint8_t> data = KrpcProtocol::encode_message(msg);
+    if (data.empty()) return false;
+
+    transport_.send(to, data);
+    obs->txn_ = t;
+    pending_[t] = Pending{obs, to, now};
+    LOG_DEBUG("dht.rpc", "→ " << KrpcProtocol::query_type_to_string(msg.query_type)
+                         << " to " << to.to_string() << " [txn " << t << "]");
+    return true;
+}
+
+void RpcManager::send_oneshot(KrpcMessage& msg, const Address& to) {
+    msg.transaction_id = txn_to_string(next_txn());  // the peer may echo it; we don't track the reply
+    const std::vector<uint8_t> data = KrpcProtocol::encode_message(msg);
+    if (!data.empty()) {
+        transport_.send(to, data);
+        LOG_DEBUG("dht.rpc", "→ " << KrpcProtocol::query_type_to_string(msg.query_type)
+                             << " to " << to.to_string() << " (oneshot)");
+    }
+}
+
+bool RpcManager::handle_response(const KrpcMessage& msg, const Address& from, TimePoint now) {
+    uint16_t t;
+    if (!string_to_txn(msg.transaction_id, t)) return false;
+
+    auto it = pending_.find(t);
+    if (it == pending_.end()) return false;          // unknown / already resolved
+    if (it->second.endpoint != from) {               // anti-spoof: not from whom we queried
+        LOG_DEBUG("dht.rpc", "dropped reply [txn " << t << "]: from " << from.to_string()
+                             << " != queried " << it->second.endpoint.to_string());
+        return false;
+    }
+
+    const ObserverPtr obs = it->second.obs;          // keep alive across the callback
+    const auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - it->second.sent).count();
+    const uint16_t rtt = elapsed < 0 ? 0 : (elapsed > 0xfffe ? uint16_t(0xfffe) : uint16_t(elapsed));
+    pending_.erase(it);
+
+    if (msg.type == KrpcMessageType::Error) {
+        // A peer that explicitly rejected us is alive but refused — a different signal from
+        // silence, so log it distinctly even though it drives the same failed-query path.
+        LOG_DEBUG("dht.rpc", "<- error from " << from.to_string() << " [txn " << t << "]: "
+                             << static_cast<int>(msg.error_code) << ' ' << msg.error_message);
+        obs->on_timeout(now);  // an error is a failed query
+    } else {
+        // The success half of the → query pair, carrying the round-trip we just measured.
+        LOG_DEBUG("dht.rpc", "<- response from " << from.to_string() << " (" << short_hex(msg.response_id)
+                             << ") [txn " << t << "] " << rtt << "ms");
+        obs->on_response(msg, rtt, now);
+    }
+    return true;
+}
+
+void RpcManager::tick(TimePoint now) {
+    // Collect first (callbacks mutate pending_), and keep the observers alive while we call them.
+    std::vector<ObserverPtr> shorts, fulls;
+    for (auto& [t, p] : pending_) {
+        const auto elapsed = now - p.sent;
+        if (elapsed >= kFullTimeout)
+            fulls.push_back(p.obs);
+        else if (elapsed >= kShortTimeout && !p.obs->has(Observer::kShortTimeout))
+            shorts.push_back(p.obs);
+    }
+
+    for (auto& o : shorts) o->on_short_timeout(now);          // keeps the pending entry
+    for (auto& o : fulls) {
+        // Only the *full* timeout is logged (a query truly gave up) — short timeouts just
+        // widen the branch factor and fire constantly, so they stay silent.
+        LOG_DEBUG("dht.rpc", "timeout " << short_hex(o->id()) << ' ' << o->endpoint().to_string());
+        cancel(o.get());
+        o->on_timeout(now);
+    }
+}
+
+void RpcManager::cancel(Observer* obs) {
+    if (!obs) return;
+    auto it = pending_.find(obs->txn_);
+    if (it != pending_.end() && it->second.obs.get() == obs) pending_.erase(it);
+}
+
+} // namespace dht
+} // namespace librats

package/native-src/src/librats/dht/rpc_manager.h

@@ -0,0 +1,77 @@
+#pragma once
+
+/**
+ * @file rpc_manager.h
+ * @brief Tracks outstanding DHT queries: transaction ids, timeouts, anti-spoofing.
+ *
+ * One unified place for every query the node sends — lookups, liveness pings,
+ * bootstrap — each represented by an Observer. invoke() stamps a transaction id,
+ * encodes and sends the message, and remembers it; handle_response() matches a reply
+ * back to its observer (only if it came from the very endpoint we queried) and
+ * dispatches it; tick() ages out the silent ones with a two-level timeout.
+ *
+ * Single-threaded actor: no locks, and time is passed in rather than read from a
+ * clock, so behaviour is fully deterministic and testable.
+ */
+
+#include "librats/core/address.h"
+#include "librats/dht/observer.h"
+#include "librats/dht/transport.h"
+
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <random>
+#include <unordered_map>
+
+namespace librats {
+struct KrpcMessage;
+
+namespace dht {
+
+class RpcManager {
+public:
+    // After the short timeout we free the query's concurrency slot but keep waiting;
+    // after the full timeout we give up on it.
+    static constexpr std::chrono::milliseconds kShortTimeout{2000};
+    static constexpr std::chrono::milliseconds kFullTimeout{15000};
+
+    explicit RpcManager(Transport& transport)
+        : transport_(transport), rng_(std::random_device{}()) {}
+
+    // Stamp a transaction id on `msg`, send it to `to`, and register `obs` to receive
+    // the outcome. Returns false if the message could not be encoded.
+    bool invoke(KrpcMessage& msg, const Address& to, const ObserverPtr& obs, TimePoint now);
+
+    // Send a query we don't track the reply to (e.g. announce_peer). Fire-and-forget.
+    void send_oneshot(KrpcMessage& msg, const Address& to);
+
+    // Route a reply/error back to its observer. Returns true only if it matched an
+    // outstanding query AND arrived from the endpoint we queried (anti-spoofing);
+    // unmatched or spoofed replies are ignored.
+    bool handle_response(const KrpcMessage& msg, const Address& from, TimePoint now);
+
+    // Fire short/full timeouts for queries that have gone quiet. Call periodically.
+    void tick(TimePoint now);
+
+    // Forget the in-flight query for `obs`, if any (the traversal is abandoning it).
+    void cancel(Observer* obs);
+
+    std::size_t outstanding() const noexcept { return pending_.size(); }
+
+private:
+    struct Pending {
+        ObserverPtr obs;
+        Address     endpoint;
+        TimePoint   sent;
+    };
+
+    uint16_t next_txn();
+
+    Transport& transport_;
+    std::unordered_map<uint16_t, Pending> pending_;
+    std::mt19937 rng_;  // seeds unpredictable transaction ids (anti-spoofing)
+};
+
+} // namespace dht
+} // namespace librats

package/native-src/src/librats/dht/storage.cpp

@@ -0,0 +1,92 @@
+#include "librats/dht/storage.h"
+#include "librats/crypto/sha1.h"
+
+#include <algorithm>
+#include <random>
+
+namespace librats {
+namespace dht {
+
+// ---- TokenManager ----------------------------------------------------------
+
+void TokenManager::maybe_rotate(TimePointSys now) {
+    if (!initialized_) {
+        std::random_device rd;
+        for (auto& b : secret_) b = static_cast<uint8_t>(rd());
+        prev_secret_ = secret_;
+        rotated_at_ = now;
+        initialized_ = true;
+        return;
+    }
+    if (now - rotated_at_ >= kRotateInterval) {
+        prev_secret_ = secret_;
+        std::random_device rd;
+        for (auto& b : secret_) b = static_cast<uint8_t>(rd());
+        rotated_at_ = now;
+    }
+}
+
+std::string TokenManager::compute(const Address& querier, const InfoHash& info_hash,
+                                  const std::array<uint8_t, 16>& secret) const {
+    // Port is deliberately excluded — a NAT may show a different source port on the
+    // follow-up announce, but the address stays the same.
+    const ByteView ip = querier.ip.bytes();
+    std::vector<uint8_t> data;
+    data.reserve(secret.size() + ip.size() + info_hash.size());
+    data.insert(data.end(), secret.begin(), secret.end());
+    data.insert(data.end(), ip.begin(), ip.end());
+    data.insert(data.end(), info_hash.begin(), info_hash.end());
+    return SHA1::hash_bytes(data);
+}
+
+std::string TokenManager::generate(const Address& querier, const InfoHash& info_hash, TimePointSys now) {
+    maybe_rotate(now);
+    return compute(querier, info_hash, secret_);
+}
+
+bool TokenManager::verify(const Address& querier, const InfoHash& info_hash,
+                          const std::string& token, TimePointSys now) {
+    if (token.empty()) return false;
+    maybe_rotate(now);
+    return token == compute(querier, info_hash, secret_)
+        || token == compute(querier, info_hash, prev_secret_);
+}
+
+// ---- PeerStore -------------------------------------------------------------
+
+void PeerStore::store(const InfoHash& info_hash, const Address& peer, TimePointSys now) {
+    auto& peers = table_[info_hash];
+    for (auto& e : peers) {
+        if (e.peer == peer) {  // already known → just refresh its timestamp
+            e.added = now;
+            return;
+        }
+    }
+    peers.push_back({peer, now});
+    if (peers.size() > kMaxPeersPerHash) peers.erase(peers.begin());  // drop the oldest
+}
+
+std::vector<Address> PeerStore::get(const InfoHash& info_hash, std::size_t max) const {
+    std::vector<Address> out;
+    auto it = table_.find(info_hash);
+    if (it == table_.end()) return out;
+    for (const auto& e : it->second) {
+        out.push_back(e.peer);
+        if (out.size() >= max) break;
+    }
+    return out;
+}
+
+void PeerStore::expire(TimePointSys now) {
+    for (auto it = table_.begin(); it != table_.end();) {
+        auto& peers = it->second;
+        peers.erase(std::remove_if(peers.begin(), peers.end(),
+                        [&](const Entry& e) { return now - e.added > kPeerTtl; }),
+                    peers.end());
+        if (peers.empty()) it = table_.erase(it);
+        else ++it;
+    }
+}
+
+} // namespace dht
+} // namespace librats

package/native-src/src/librats/dht/storage.h

@@ -0,0 +1,74 @@
+#pragma once
+
+/**
+ * @file storage.h
+ * @brief Server-side DHT state: announce write-tokens and the announced-peer table (BEP 5).
+ *
+ * Both are pure data driven by the node's incoming-query handlers, with time passed
+ * in so they're deterministic and lock-free (single actor thread).
+ */
+
+#include "librats/core/address.h"
+#include "librats/dht/id.h"
+
+#include <array>
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace librats {
+namespace dht {
+
+using TimePointSys = std::chrono::steady_clock::time_point;
+
+// Write tokens (BEP 5). A token is handed out with every get_peers reply and must be
+// presented back on announce_peer — proving the announcer can actually receive at the
+// address it claims. token = SHA1(secret || querier_ip || info_hash): unforgeable
+// (the secret is private) and bound to both the address and the info-hash, so it can't
+// be replayed for a different peer or torrent. The secret rotates periodically; the
+// previous one stays valid across a single rotation so tokens don't expire abruptly.
+class TokenManager {
+public:
+    static constexpr std::chrono::minutes kRotateInterval{5};
+
+    std::string generate(const Address& querier, const InfoHash& info_hash, TimePointSys now);
+    bool verify(const Address& querier, const InfoHash& info_hash,
+                const std::string& token, TimePointSys now);
+
+private:
+    void maybe_rotate(TimePointSys now);
+    std::string compute(const Address& querier, const InfoHash& info_hash,
+                        const std::array<uint8_t, 16>& secret) const;
+
+    std::array<uint8_t, 16> secret_{};
+    std::array<uint8_t, 16> prev_secret_{};
+    TimePointSys rotated_at_{};
+    bool initialized_ = false;
+};
+
+// The peers that announced themselves under each info-hash, so we can answer
+// get_peers. Peers expire after kPeerTtl; each info-hash is capped to bound memory.
+class PeerStore {
+public:
+    static constexpr std::chrono::minutes kPeerTtl{30};
+    static constexpr std::size_t kMaxPeersPerHash = 128;
+
+    void store(const InfoHash& info_hash, const Address& peer, TimePointSys now);
+    std::vector<Address> get(const InfoHash& info_hash, std::size_t max = kMaxPeersPerHash) const;
+    void expire(TimePointSys now);
+
+    std::size_t hash_count() const noexcept { return table_.size(); }
+
+private:
+    struct Entry {
+        Address      peer;
+        TimePointSys added;
+    };
+    std::map<InfoHash, std::vector<Entry>> table_;
+};
+
+} // namespace dht
+} // namespace librats

package/native-src/src/librats/dht/transport.h

@@ -0,0 +1,27 @@
+#pragma once
+
+/**
+ * @file transport.h
+ * @brief The outbound datagram sink the DHT sends through.
+ *
+ * The real implementation (Phase 5) owns a UDP socket; tests substitute a mock that
+ * just records what was sent. Sending is fire-and-forget and must never block — the
+ * whole DHT runs on one actor thread.
+ */
+
+#include "librats/core/address.h"
+
+#include <cstdint>
+#include <vector>
+
+namespace librats {
+namespace dht {
+
+class Transport {
+public:
+    virtual ~Transport() = default;
+    virtual void send(const Address& to, const std::vector<uint8_t>& datagram) = 0;
+};
+
+} // namespace dht
+} // namespace librats