librats 1.0.2 → 2.2.0

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

@@ -0,0 +1,103 @@
+#include "librats/dht/dht_runner.h"
+#include "librats/dht/node.h"
+#include "librats/dht/udp_transport.h"
+#include "librats/dht/log.h"
+
+#include <chrono>
+#include <utility>
+
+namespace librats {
+namespace dht {
+
+namespace {
+constexpr int kRecvTimeoutMs = 100;                          // loop responsiveness
+constexpr std::chrono::milliseconds kTickInterval{1000};     // Node maintenance cadence
+}
+
+DhtRunner::DhtRunner(Node& node, UdpTransport& transport)
+    : node_(node), transport_(transport) {}
+
+DhtRunner::~DhtRunner() {
+    stop();
+}
+
+void DhtRunner::start(std::function<void()> on_loop_entry) {
+    if (running_.exchange(true)) return;
+    thread_ = std::thread([this, on_loop_entry = std::move(on_loop_entry)] {
+        if (on_loop_entry) on_loop_entry();
+        loop();
+    });
+}
+
+void DhtRunner::stop() {
+    // Flip the flag under the queue mutex, so post() can never slip a task past a
+    // concurrent stop() and leave it queued to a loop that is already gone.
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        if (!running_.exchange(false)) return;
+    }
+    wakeup_.signal();  // wake the loop now instead of waiting out the recv timeout
+    if (thread_.joinable()) thread_.join();
+}
+
+bool DhtRunner::post(std::function<void()> task) {
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        // Refuse once stopped: no one is left to drain the queue.
+        if (!running_.load()) return false;
+        tasks_.push_back(std::move(task));
+    }
+    // The task is queued before we signal, so whenever a wakeup byte exists the task is
+    // already visible to drain_tasks() — the loop can never block past a pending task.
+    wakeup_.signal();
+    return true;
+}
+
+void DhtRunner::set_periodic(std::chrono::milliseconds interval, std::function<void()> fn) {
+    periodic_interval_ = interval;
+    periodic_fn_       = std::move(fn);
+}
+
+void DhtRunner::loop() {
+    const auto start = std::chrono::steady_clock::now();
+    auto last_tick = start;
+    auto last_periodic = start;  // first periodic fires one full interval in, not at t=0
+    while (running_.load()) {
+        Address from;
+        // recv() returns early (as nullopt) the moment post()/stop() signals the wakeup
+        // pipe, so a posted task runs without waiting out kRecvTimeoutMs.
+        auto data = transport_.recv(kRecvTimeoutMs, from, wakeup_.fd());
+        const auto now = std::chrono::steady_clock::now();
+
+        // Consume the wakeup byte(s) before processing, so the next recv() blocks again.
+        // Draining here (not after drain_tasks) means any task posted during processing
+        // leaves an un-drained byte that wakes the following recv() — no lost wakeups.
+        wakeup_.drain();
+
+        if (data) node_.on_datagram(*data, from, now);
+
+        drain_tasks();
+
+        if (now - last_tick >= kTickInterval) {
+            node_.tick(now);
+            last_tick = now;
+        }
+
+        if (periodic_fn_ && periodic_interval_.count() > 0 && now - last_periodic >= periodic_interval_) {
+            periodic_fn_();
+            last_periodic = now;
+        }
+    }
+}
+
+void DhtRunner::drain_tasks() {
+    std::vector<std::function<void()>> pending;
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        pending.swap(tasks_);
+    }
+    for (auto& task : pending) task();
+}
+
+} // namespace dht
+} // namespace librats

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

@@ -0,0 +1,71 @@
+#pragma once
+
+/**
+ * @file dht_runner.h
+ * @brief The single thread that drives a dht::Node over a real socket.
+ *
+ * This is where real time and threading enter the otherwise pure, single-threaded
+ * Node. The loop pumps incoming datagrams into Node::on_datagram, runs Node::tick on
+ * a fixed cadence, and executes tasks posted from other threads — all on this one
+ * thread, so the Node itself never needs a lock. External callers must reach the Node
+ * through post() rather than touching it directly.
+ */
+
+#include "librats/core/wakeup_pipe.h"
+
+#include <atomic>
+#include <chrono>
+#include <functional>
+#include <mutex>
+#include <thread>
+#include <vector>
+
+namespace librats {
+namespace dht {
+
+class Node;
+class UdpTransport;
+
+class DhtRunner {
+public:
+    DhtRunner(Node& node, UdpTransport& transport);
+    ~DhtRunner();
+
+    DhtRunner(const DhtRunner&) = delete;
+    DhtRunner& operator=(const DhtRunner&) = delete;
+
+    // `on_loop_entry`, if given, runs on the loop thread before anything else does —
+    // the hook for marking that thread as such (see DhtClient), so even the very first
+    // callback it runs is already recognisable.
+    void start(std::function<void()> on_loop_entry = {});
+    void stop();
+
+    // Run `task` on the loop thread. The only safe way to touch the Node from outside.
+    // Returns false (dropping the task) once the runner is stopped: nothing would ever
+    // run it, so a caller must not be left believing it was queued.
+    bool post(std::function<void()> task);
+
+    // Register a callback invoked on the loop thread every `interval` (e.g. persisting
+    // the routing table). The first invocation is one interval after start(), never at
+    // t=0. Must be set before start(); call with a null fn to disable. The runner stays
+    // oblivious to what the work is — the I/O concern lives in the caller.
+    void set_periodic(std::chrono::milliseconds interval, std::function<void()> fn);
+
+private:
+    void loop();
+    void drain_tasks();
+
+    Node&         node_;
+    UdpTransport& transport_;
+    std::thread   thread_;
+    std::atomic<bool> running_{false};
+    std::mutex    mutex_;
+    std::vector<std::function<void()>> tasks_;
+    WakeupPipe    wakeup_;  // lets post()/stop() interrupt the recv() wait immediately
+
+    std::chrono::milliseconds          periodic_interval_{0};  // 0 = disabled
+    std::function<void()>              periodic_fn_;
+};
+
+} // namespace dht
+} // namespace librats

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

@@ -0,0 +1,42 @@
+#include "librats/dht/dos_blocker.h"
+#include "librats/dht/log.h"
+
+namespace librats {
+namespace dht {
+
+bool DosBlocker::allow(const IpAddress& ip, TimePoint now) {
+    Entry& e = table_[ip];
+
+    if (e.banned_until > now) return false;  // still serving a ban
+
+    if (now - e.window_start >= kWindow) {   // start of a fresh window
+        e.window_start = now;
+        e.count = 0;
+    }
+
+    if (++e.count > kMaxPerWindow) {
+        e.banned_until = now + kBanDuration;
+        // Logged once at the ban transition only — the top-of-function early return keeps
+        // every subsequent packet from this IP from re-logging. DEBUG (not WARN) on purpose:
+        // a spoofed-source flood could otherwise turn one ban per IP into log amplification.
+        LOG_DEBUG("dht", "rate-limit ban: " << ip.to_string() << " (" << e.count << " queries in window)");
+        return false;
+    }
+
+    if (table_.size() > kMaxTracked) prune(now);
+    return true;
+}
+
+void DosBlocker::prune(TimePoint now) {
+    // Drop idle, unbanned entries; they carry no state worth keeping.
+    for (auto it = table_.begin(); it != table_.end();) {
+        const Entry& e = it->second;
+        if (e.banned_until <= now && now - e.window_start >= kWindow)
+            it = table_.erase(it);
+        else
+            ++it;
+    }
+}
+
+} // namespace dht
+} // namespace librats

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

@@ -0,0 +1,47 @@
+#pragma once
+
+/**
+ * @file dos_blocker.h
+ * @brief Per-IP flood protection for the DHT's incoming path.
+ *
+ * A peer is allowed a burst of packets per short window; cross the threshold and it's
+ * banned for a while. Cheap and bounded — a single counter + two timestamps per IP,
+ * with the tracking table capped. Consulted before any incoming packet is processed.
+ */
+
+#include "librats/core/ip_address.h"
+#include "librats/dht/observer.h"  // for TimePoint
+
+#include <chrono>
+#include <cstddef>
+#include <unordered_map>
+
+namespace librats {
+namespace dht {
+
+class DosBlocker {
+public:
+    static constexpr int kMaxPerWindow = 50;                 // packets per window before a ban
+    static constexpr std::chrono::seconds kWindow{10};
+    static constexpr std::chrono::minutes kBanDuration{5};
+    static constexpr std::size_t kMaxTracked = 2000;         // cap the per-IP table
+
+    // True if a packet from `ip` should be processed; false if it's being rate-limited.
+    bool allow(const IpAddress& ip, TimePoint now);
+
+    std::size_t tracked() const noexcept { return table_.size(); }
+
+private:
+    struct Entry {
+        int       count = 0;
+        TimePoint window_start{};
+        TimePoint banned_until{};
+    };
+
+    void prune(TimePoint now);
+
+    std::unordered_map<IpAddress, Entry> table_;
+};
+
+} // namespace dht
+} // namespace librats

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

@@ -0,0 +1,52 @@
+#include "librats/dht/find_peers.h"
+#include "librats/dht/krpc.h"
+
+#include <algorithm>
+#include <utility>
+
+namespace librats {
+namespace dht {
+
+FindPeers::FindPeers(RoutingTable& table, RpcManager& rpc, const NodeId& self,
+                     const InfoHash& info_hash, PeersCallback on_peers, DoneCallback on_done)
+    : Traversal(table, rpc, self, info_hash),
+      on_peers_(std::move(on_peers)),
+      on_done_(std::move(on_done)) {}
+
+void FindPeers::got_peers(const std::vector<Address>& peers) {
+    std::vector<Address> fresh;
+    for (const auto& p : peers) {
+        if (std::find(peers_.begin(), peers_.end(), p) == peers_.end()) {
+            peers_.push_back(p);
+            fresh.push_back(p);
+        }
+    }
+    if (!fresh.empty() && on_peers_) on_peers_(fresh);
+}
+
+void FindPeers::got_token(const NodeId& id, const std::string& token) {
+    if (token.empty()) return;
+    tokens_.emplace(id, token);  // first token from a node wins
+}
+
+bool FindPeers::invoke(const ObserverPtr& o, TimePoint now) {
+    KrpcMessage msg = KrpcProtocol::create_get_peers_query(/*txn set by rpc*/ "", self_, target());
+    msg.want = want_;  // BEP 32: ask for our own family's nodes
+    return rpc_.invoke(msg, o->endpoint(), o, now);
+}
+
+ObserverPtr FindPeers::make_observer(const NodeId& id, const Address& ep) {
+    return std::make_shared<FindPeersObserver>(*this, id, ep);
+}
+
+void FindPeers::on_complete() {
+    if (on_done_) on_done_(peers_);
+}
+
+void FindPeersObserver::parse_reply(const KrpcMessage& msg) {
+    if (!msg.token.empty()) owner_.got_token(msg.response_id, msg.token);
+    if (!msg.peers.empty()) owner_.got_peers(msg.peers);
+}
+
+} // namespace dht
+} // namespace librats

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

@@ -0,0 +1,73 @@
+#pragma once
+
+/**
+ * @file find_peers.h
+ * @brief get_peers lookup: find the peers announced under an info-hash (BEP 5).
+ *
+ * An iterative lookup toward the info-hash. Along the way it collects peer
+ * endpoints from "values" replies (delivered incrementally, then once more in full
+ * on completion) and the write tokens nodes hand out — the tokens are what an
+ * announce needs, so Announce builds directly on this.
+ */
+
+#include "librats/dht/id.h"
+#include "librats/dht/observer.h"
+#include "librats/dht/traversal.h"
+
+#include <functional>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace librats {
+struct KrpcMessage;
+
+namespace dht {
+
+class FindPeers : public Traversal {
+public:
+    // Called with each batch of newly-discovered peers as the lookup runs.
+    using PeersCallback = std::function<void(const std::vector<Address>&)>;
+    // Called once when the lookup converges, with every peer found.
+    using DoneCallback  = std::function<void(const std::vector<Address>&)>;
+
+    FindPeers(RoutingTable& table, RpcManager& rpc, const NodeId& self, const InfoHash& info_hash,
+              PeersCallback on_peers, DoneCallback on_done);
+
+    void got_peers(const std::vector<Address>& peers);          // from a values reply
+    void got_token(const NodeId& id, const std::string& token); // from a node's reply
+
+    // BEP 32: which node families to ask for ("n4" / "n6"). Empty = unspecified.
+    void set_want(std::vector<std::string> want) { want_ = std::move(want); }
+
+protected:
+    bool invoke(const ObserverPtr& o, TimePoint now) override;
+    ObserverPtr make_observer(const NodeId& id, const Address& ep) override;
+    void on_complete() override;
+    const char* name() const override { return "find_peers"; }
+
+    // The write token each responding node gave us, keyed by node id (Announce reads
+    // this). std::map avoids needing a NodeId hash; the map only ever holds ~k entries.
+    std::map<NodeId, std::string> tokens_;
+
+private:
+    PeersCallback on_peers_;
+    DoneCallback  on_done_;
+    std::vector<Address> peers_;        // all unique peers found
+    std::vector<std::string> want_;     // BEP 32 family hint for our queries
+};
+
+class FindPeersObserver : public TraversalObserver {
+public:
+    FindPeersObserver(FindPeers& owner, const NodeId& id, const Address& ep)
+        : TraversalObserver(owner, id, ep), owner_(owner) {}
+
+protected:
+    void parse_reply(const KrpcMessage& msg) override;
+
+private:
+    FindPeers& owner_;
+};
+
+} // namespace dht
+} // namespace librats

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

@@ -0,0 +1,167 @@
+#pragma once
+
+/**
+ * @file id.h
+ * @brief The 160-bit Kademlia identifier and the pure functions over it.
+ *
+ * `NodeId` and `InfoHash` share one 160-bit keyspace (BEP 5). Everything here is a
+ * header-only, allocation-free leaf primitive — XOR distance, closeness ordering,
+ * k-bucket placement, and hex/wire conversions — so the comparators used in the
+ * routing table and lookup hot paths can be inlined.
+ */
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <string>
+
+#if defined(_MSC_VER)
+#include <intrin.h>  // _BitScanReverse for count_leading_zeros
+#endif
+
+namespace librats {
+namespace dht {
+
+// Count leading zero bits of a non-zero 32-bit word. One hardware instruction where
+// available; a portable loop otherwise. Precondition: x != 0.
+inline int count_leading_zeros32(uint32_t x) noexcept {
+#if defined(__GNUC__) || defined(__clang__)
+    return __builtin_clz(x);
+#elif defined(_MSC_VER)
+    unsigned long idx;
+    _BitScanReverse(&idx, x);
+    return 31 - static_cast<int>(idx);
+#else
+    int n = 0;
+    while ((x & 0x80000000u) == 0) { ++n; x <<= 1; }
+    return n;
+#endif
+}
+
+// 160-bit identifier space shared by node ids and info-hashes (Kademlia / BEP 5).
+inline constexpr std::size_t kIdSize      = 20;   // 160 bits
+inline constexpr std::size_t kBucketSize  = 8;    // "k": max contacts kept per bucket
+inline constexpr std::size_t kAlpha       = 3;    // lookup concurrency (branch factor)
+inline constexpr int         kDefaultPort = 6881; // standard BitTorrent DHT port
+inline constexpr int         kBucketCount = static_cast<int>(kIdSize) * 8;  // 160
+
+using NodeId   = std::array<uint8_t, kIdSize>;
+using InfoHash = NodeId;  // same keyspace, named for intent at call sites
+
+// Hash functor for using a NodeId/InfoHash as an unordered_map/set key. A node id is
+// already a uniformly-distributed 160-bit value (a SHA-1 digest or random id), so the
+// fastest sound hash is to reinterpret its leading bytes as size_t — no mixing needed.
+// This mirrors libtorrent's std::hash<digest32<N>> (sha1_hash.hpp). Note: most DHT
+// id-keyed tables (write tokens, the peer store) deliberately stay std::map — they're
+// small/cold and ordered is fine; reach for this only on hot, large id sets.
+struct NodeIdHash {
+    std::size_t operator()(const NodeId& id) const noexcept {
+        std::size_t h;
+        std::memcpy(&h, id.data(), sizeof(h));
+        return h;
+    }
+};
+
+// XOR distance metric d(a, b) = a ^ b (Kademlia).
+inline NodeId distance(const NodeId& a, const NodeId& b) noexcept {
+    NodeId d;
+    for (std::size_t i = 0; i < kIdSize; ++i) d[i] = a[i] ^ b[i];
+    return d;
+}
+
+// True iff `a` is strictly closer to `target` than `b` under the XOR metric.
+// Compares a^target against b^target as 160-bit big-endian numbers without
+// materialising either distance — this is the lookup/sort comparator.
+inline bool closer_to(const NodeId& a, const NodeId& b, const NodeId& target) noexcept {
+    for (std::size_t i = 0; i < kIdSize; ++i) {
+        const uint8_t da = a[i] ^ target[i];
+        const uint8_t db = b[i] ^ target[i];
+        if (da != db) return da < db;
+    }
+    return false;  // equal distance is not "strictly closer"
+}
+
+// Number of leading bits `a` and `b` share — equivalently, the count of leading
+// zeros of (a ^ b). 0 means they differ in the very first bit (farthest apart);
+// kBucketCount (160) is returned only when the ids are identical. This is the raw
+// keyspace primitive; the routing table caps it to its current bucket count to get
+// an actual bucket index (RoutingTable::bucket_index).
+inline int shared_prefix_bits(const NodeId& a, const NodeId& b) noexcept {
+    // Process the 160 bits four bytes at a time (kIdSize == 20 == 5 words). Each word
+    // is assembled big-endian so its most significant bit is the earliest id bit, then
+    // a single count-leading-zeros pins the first differing bit. Bit-identical to the
+    // byte-at-a-time form, ~4x faster: the common case is one word load + one CLZ.
+    for (std::size_t i = 0; i < kIdSize; i += 4) {
+        const uint32_t d = (static_cast<uint32_t>(a[i]     ^ b[i])     << 24)
+                         | (static_cast<uint32_t>(a[i + 1] ^ b[i + 1]) << 16)
+                         | (static_cast<uint32_t>(a[i + 2] ^ b[i + 2]) << 8)
+                         |  static_cast<uint32_t>(a[i + 3] ^ b[i + 3]);
+        if (d != 0) return static_cast<int>(i) * 8 + count_leading_zeros32(d);
+    }
+    return kBucketCount;  // identical ids share the whole 160-bit prefix
+}
+
+// Read `n` bits from `id` starting at bit index `start` (MSB-first: bit 0 is the top
+// bit of id[0]), returned right-aligned. Bits past the end of the id read as 0. Used
+// to classify a node by the handful of sub-prefix bits that follow a bucket's shared
+// prefix, so `n` is always small (<= 7).
+inline uint32_t bits_at(const NodeId& id, int start, int n) noexcept {
+    uint32_t v = 0;
+    for (int k = 0; k < n; ++k) {
+        const int bit = start + k;
+        const int b = (bit >= 0 && bit < kBucketCount)
+                          ? ((id[bit >> 3] >> (7 - (bit & 7))) & 1)
+                          : 0;
+        v = (v << 1) | static_cast<uint32_t>(b);
+    }
+    return v;
+}
+
+// Lowercase 40-char hex. to_hex / from_hex are exact inverses for valid input.
+inline std::string to_hex(const NodeId& id) {
+    static constexpr char kDigits[] = "0123456789abcdef";
+    std::string out(kIdSize * 2, '0');
+    for (std::size_t i = 0; i < kIdSize; ++i) {
+        out[i * 2]     = kDigits[id[i] >> 4];
+        out[i * 2 + 1] = kDigits[id[i] & 0x0f];
+    }
+    return out;
+}
+
+// Parse 40 hex chars. Returns a zero-filled id if the input isn't exactly 40 valid
+// hex characters, so a malformed string can never be mistaken for a real id.
+inline NodeId from_hex(const std::string& hex) {
+    NodeId id{};
+    if (hex.size() != kIdSize * 2) return id;
+    const auto nibble = [](char c) -> int {
+        if (c >= '0' && c <= '9') return c - '0';
+        if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+        if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+        return -1;
+    };
+    for (std::size_t i = 0; i < kIdSize; ++i) {
+        const int hi = nibble(hex[i * 2]);
+        const int lo = nibble(hex[i * 2 + 1]);
+        if (hi < 0 || lo < 0) return NodeId{};
+        id[i] = static_cast<uint8_t>((hi << 4) | lo);
+    }
+    return id;
+}
+
+// Raw 20-byte wire form, as carried in KRPC messages. Inverses of each other.
+inline std::string to_bytes(const NodeId& id) {
+    return std::string(reinterpret_cast<const char*>(id.data()), kIdSize);
+}
+
+// Returns a zero-filled id if `bytes` isn't exactly 20 bytes.
+inline NodeId from_bytes(const std::string& bytes) {
+    NodeId id{};
+    if (bytes.size() != kIdSize) return id;
+    std::copy(bytes.begin(), bytes.end(), id.begin());
+    return id;
+}
+
+} // namespace dht
+} // namespace librats