librats 1.0.2 → 2.2.0

package/native-src/src/librats/peer/peer_book.cpp

@@ -0,0 +1,181 @@
+#include "librats/peer/peer_book.h"
+#include "librats/util/fs.h"
+#include "librats/util/json.h"
+
+#include <algorithm>
+#include <unordered_set>
+
+namespace librats {
+
+namespace {
+
+// "best first" ordering: returns true if a ranks strictly before b.
+bool better(const PeerRecord& a, const PeerRecord& b) {
+    const bool ca = a.last_connected > 0, cb = b.last_connected > 0;
+    if (ca != cb)                            return ca;                          // ever-connected first
+    if (a.last_connected != b.last_connected) return a.last_connected > b.last_connected;
+    if (a.connect_count  != b.connect_count)  return a.connect_count  > b.connect_count;
+    if (a.fail_streak    != b.fail_streak)    return a.fail_streak    < b.fail_streak;
+    return a.last_seen > b.last_seen;
+}
+
+bool is_stale(const PeerRecord& r, uint64_t now, uint64_t max_age_secs) {
+    return max_age_secs > 0 && r.last_seen > 0 && now > r.last_seen && (now - r.last_seen) > max_age_secs;
+}
+
+} // namespace
+
+void PeerBook::load() {
+    const std::string text = read_file_text_cpp(path_);
+    if (text.empty()) return;
+
+    // Non-throwing parse: a malformed/legacy file simply yields no records
+    // rather than crashing startup.
+    const Json root = Json::parse(text, nullptr, /*allow_exceptions=*/false);
+    if (!root.is_array()) return;
+
+    std::lock_guard<std::mutex> lock(mutex_);
+    for (const auto& j : root) {
+        if (!j.is_object()) continue;
+        const std::string ip   = j.value("ip", std::string());
+        const uint16_t    port = static_cast<uint16_t>(j.value("port", 0));
+        const auto ipaddr = IpAddress::parse(ip);
+        if (!ipaddr || port == 0) continue;  // need a valid numeric ip + port
+
+        PeerRecord r;
+        r.address = Address{*ipaddr, port};
+        // Remaining metadata fields are optional; absent ones keep their defaults.
+        const std::string idhex = j.value("id", std::string());
+        if (!idhex.empty()) { if (auto id = PeerId::from_hex(idhex)) r.id = *id; }
+        r.first_seen     = j.value("first_seen",     uint64_t{0});
+        r.last_seen      = j.value("last_seen",      uint64_t{0});
+        r.last_connected = j.value("last_connected", uint64_t{0});
+        r.connect_count  = j.value("connect_count",  uint32_t{0});
+        r.fail_streak    = j.value("fail_streak",    uint32_t{0});
+        records_[r.address] = r;
+    }
+}
+
+void PeerBook::save() const {
+    Json arr = Json::array();
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        for (const auto& [key, r] : records_) {
+            Json j = Json::object();
+            j["ip"]             = r.address.ip.to_string();
+            j["port"]           = r.address.port;
+            if (!r.id.is_zero()) j["id"] = r.id.to_hex();  // omitted when never connected
+            j["first_seen"]     = r.first_seen;
+            j["last_seen"]      = r.last_seen;
+            j["last_connected"] = r.last_connected;
+            j["connect_count"]  = r.connect_count;
+            j["fail_streak"]    = r.fail_streak;
+            arr.push_back(std::move(j));
+        }
+    }
+    create_file(path_.c_str(), arr.dump(2).c_str());
+}
+
+void PeerBook::note_connected(const Address& address, const PeerId& id, uint64_t now) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    PeerRecord& r = records_[address];
+    if (r.first_seen == 0) r.first_seen = now;
+    r.address        = address;
+    if (!id.is_zero()) r.id = id;
+    r.last_seen      = now;
+    r.last_connected = now;
+    r.connect_count++;
+    r.fail_streak    = 0;
+}
+
+void PeerBook::note_failure(const Address& address, uint64_t /*now*/) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    auto it = records_.find(address);
+    if (it == records_.end()) return;  // only track failures for peers we already know
+    // Deliberately does NOT refresh last_seen: a peer that only ever fails must
+    // still age out (otherwise repeated give-ups would keep it forever "fresh").
+    it->second.fail_streak++;
+}
+
+void PeerBook::note_seen(const Address& address, uint64_t now) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    PeerRecord& r = records_[address];
+    if (r.first_seen == 0) r.first_seen = now;
+    r.address   = address;
+    r.last_seen = now;
+}
+
+bool PeerBook::remove(const Address& address) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return records_.erase(address) > 0;
+}
+
+std::vector<Address> PeerBook::best(size_t n, uint64_t now, uint64_t max_age_secs) const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    std::vector<const PeerRecord*> recs;
+    recs.reserve(records_.size());
+    for (const auto& [key, r] : records_)
+        if (!is_stale(r, now, max_age_secs)) recs.push_back(&r);
+
+    std::sort(recs.begin(), recs.end(),
+              [](const PeerRecord* a, const PeerRecord* b) { return better(*a, *b); });
+
+    std::vector<Address> out;
+    for (const PeerRecord* r : recs) {
+        if (out.size() >= n) break;
+        out.push_back(r->address);
+    }
+    return out;
+}
+
+size_t PeerBook::prune(uint64_t now, uint64_t max_age_secs, size_t max_size) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    const size_t before = records_.size();
+
+    if (max_age_secs > 0) {
+        for (auto it = records_.begin(); it != records_.end();) {
+            if (is_stale(it->second, now, max_age_secs)) it = records_.erase(it);
+            else ++it;
+        }
+    }
+
+    if (max_size > 0 && records_.size() > max_size) {
+        std::vector<const PeerRecord*> recs;
+        recs.reserve(records_.size());
+        for (const auto& [key, r] : records_) recs.push_back(&r);
+        std::sort(recs.begin(), recs.end(),
+                  [](const PeerRecord* a, const PeerRecord* b) { return better(*a, *b); });
+        std::unordered_set<Address> keep;
+        keep.reserve(max_size);
+        for (size_t i = 0; i < max_size; ++i) keep.insert(recs[i]->address);
+        for (auto it = records_.begin(); it != records_.end();) {
+            if (keep.count(it->first)) ++it;
+            else it = records_.erase(it);
+        }
+    }
+
+    return before - records_.size();
+}
+
+std::vector<Address> PeerBook::all() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    std::vector<Address> out;
+    out.reserve(records_.size());
+    for (const auto& [key, r] : records_) out.push_back(r.address);
+    return out;
+}
+
+std::vector<PeerRecord> PeerBook::records() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    std::vector<PeerRecord> out;
+    out.reserve(records_.size());
+    for (const auto& [key, r] : records_) out.push_back(r);
+    return out;
+}
+
+size_t PeerBook::size() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return records_.size();
+}
+
+} // namespace librats

package/native-src/src/librats/peer/peer_book.h

@@ -0,0 +1,88 @@
+#pragma once
+
+/**
+ * @file peer_book.h
+ * @brief Persistent address book of peers worth reconnecting to.
+ *
+ * Records every peer we have successfully connected to (and addresses we have
+ * learned), with light metadata: when we first/last saw it, when we last
+ * connected, how many times, and the current consecutive-failure streak. One
+ * ranked store serves BOTH needs at once — the "reconnect to recent peers"
+ * working set and the "remember everyone we ever met" archive. Callers query
+ * best() for the most promising addresses and rely on prune() to age out the
+ * long tail.
+ *
+ * Time is passed in (unix seconds) rather than read here, so the book stays a
+ * pure, testable data structure; the wall clock lives at the call site.
+ *
+ * Thread-safe. Backed by a human-readable JSON file: an array of objects, one
+ * per record, e.g.
+ *   [
+ *     {"ip":"127.0.0.1","port":4001,"id":"ab..","first_seen":1000,
+ *      "last_seen":2000,"last_connected":2000,"connect_count":2,"fail_streak":0}
+ *   ]
+ * The "id" field is omitted for peers we have only ever seen, never connected to.
+ */
+
+#include "librats/util/rats_export.h"
+#include "librats/core/address.h"
+#include "librats/peer/peer_id.h"
+
+#include <cstdint>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace librats {
+
+struct PeerRecord {
+    Address  address;
+    PeerId   id;                  ///< last known id (is_zero() if we never connected)
+    uint64_t first_seen     = 0;  ///< unix seconds first added/seen
+    uint64_t last_seen      = 0;  ///< unix seconds last seen (added / learned / connected)
+    uint64_t last_connected = 0;  ///< unix seconds of last successful connection (0 = never)
+    uint32_t connect_count  = 0;  ///< successful connections
+    uint32_t fail_streak    = 0;  ///< consecutive failed dials since the last success
+};
+
+class RATS_API PeerBook {
+public:
+    explicit PeerBook(std::string path) : path_(std::move(path)) {}
+
+    /// Load records from the backing file (no-op if it does not exist).
+    void load();
+    /// Persist the current records to the backing file.
+    void save() const;
+
+    /// A successful connection: refresh timestamps, bump connect_count, clear fails.
+    void note_connected(const Address& address, const PeerId& id, uint64_t now);
+    /// A failed dial to a known peer: bump its failure streak. Does NOT refresh
+    /// last_seen (so a peer that only ever fails still ages out). No-op if unknown.
+    void note_failure(const Address& address, uint64_t now);
+    /// Learned / manually added an address without (yet) connecting to it.
+    void note_seen(const Address& address, uint64_t now);
+
+    /// Remove an address entirely. Returns true if it was present.
+    bool remove(const Address& address);
+
+    /// Up to n most promising addresses (last seen within max_age_secs, or all if
+    /// max_age_secs == 0), best first: ever-connected before never-connected, then
+    /// most-recently-connected, then most connects, then fewest recent failures.
+    std::vector<Address> best(size_t n, uint64_t now, uint64_t max_age_secs) const;
+
+    /// Drop records last seen longer ago than max_age_secs (0 = no aging), then cap
+    /// to max_size (0 = no cap) keeping the best. Returns the number removed.
+    size_t prune(uint64_t now, uint64_t max_age_secs, size_t max_size);
+
+    std::vector<Address>    all() const;
+    std::vector<PeerRecord> records() const;
+    size_t                  size() const;
+
+private:
+    std::string                                 path_;
+    mutable std::mutex                          mutex_;
+    std::unordered_map<Address, PeerRecord> records_;  ///< keyed by the peer Address
+};
+
+} // namespace librats

package/native-src/src/librats/peer/peer_id.cpp

@@ -0,0 +1,72 @@
+#include "librats/peer/peer_id.h"
+
+extern "C" {
+#include "librats/crypto/sha256.h"
+}
+
+#include <cstring>
+
+namespace librats {
+
+namespace {
+constexpr char kHexDigits[] = "0123456789abcdef";
+
+int hex_value(char c) {
+    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;
+}
+} // namespace
+
+PeerId PeerId::from_public_key(const uint8_t* key, size_t len) {
+    PeerId id;
+    rats_sha256_hash(id.bytes_.data(), key, len);
+    return id;
+}
+
+std::optional<PeerId> PeerId::from_bytes(ByteView raw) {
+    if (raw.size() != kSize) return std::nullopt;
+    PeerId id;
+    std::memcpy(id.bytes_.data(), raw.data(), kSize);
+    return id;
+}
+
+std::optional<PeerId> PeerId::from_hex(std::string_view hex) {
+    if (hex.size() != kSize * 2) return std::nullopt;
+    PeerId id;
+    for (size_t i = 0; i < kSize; ++i) {
+        const int hi = hex_value(hex[2 * i]);
+        const int lo = hex_value(hex[2 * i + 1]);
+        if (hi < 0 || lo < 0) return std::nullopt;
+        id.bytes_[i] = static_cast<uint8_t>((hi << 4) | lo);
+    }
+    return id;
+}
+
+std::string PeerId::to_hex() const {
+    std::string out(kSize * 2, '0');
+    for (size_t i = 0; i < kSize; ++i) {
+        out[2 * i]     = kHexDigits[bytes_[i] >> 4];
+        out[2 * i + 1] = kHexDigits[bytes_[i] & 0x0F];
+    }
+    return out;
+}
+
+std::string PeerId::short_hex() const {
+    return to_hex().substr(0, 8);
+}
+
+bool PeerId::is_zero() const noexcept {
+    for (uint8_t b : bytes_) if (b != 0) return false;
+    return true;
+}
+
+size_t PeerId::Hash::operator()(const PeerId& id) const noexcept {
+    // The bytes are already a uniform hash; fold the first word into size_t.
+    size_t h = 0;
+    std::memcpy(&h, id.bytes_.data(), sizeof(h));
+    return h;
+}
+
+} // namespace librats

package/native-src/src/librats/peer/peer_id.h

@@ -0,0 +1,62 @@
+#pragma once
+
+/**
+ * @file peer_id.h
+ * @brief Self-certifying peer identity.
+ *
+ * A PeerId is the SHA-256 of a peer's static (Noise) public key. Because the
+ * Noise XX handshake proves possession of that key, a completed handshake also
+ * proves the remote's PeerId — identity is cryptographically bound to the key
+ * and cannot be forged (libp2p uses the same self-certifying scheme).
+ *
+ * This is a value type: cheap to copy, hashable, and ordered, so it slots
+ * straight into unordered_map / set as a key.
+ */
+
+#include "librats/util/rats_export.h"
+#include "librats/core/bytes.h"
+
+#include <array>
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <string_view>
+
+namespace librats {
+
+class RATS_API PeerId {
+public:
+    static constexpr size_t kSize = 32;  ///< SHA-256 digest length
+
+    PeerId() = default;
+
+    /// Derive the PeerId from a raw static public key (SHA-256 of the key).
+    static PeerId from_public_key(const uint8_t* key, size_t len);
+    static PeerId from_public_key(ByteView key) { return from_public_key(key.data(), key.size()); }
+
+    /// Wrap raw 32 id-bytes verbatim (NOT hashed). nullopt unless exactly kSize.
+    static std::optional<PeerId> from_bytes(ByteView raw);
+
+    /// Parse a 64-char lowercase/uppercase hex string. nullopt if malformed.
+    static std::optional<PeerId> from_hex(std::string_view hex);
+
+    std::string to_hex() const;
+    std::string short_hex() const;  ///< first 8 hex chars, for logs
+
+    const std::array<uint8_t, kSize>& bytes() const noexcept { return bytes_; }
+    bool is_zero() const noexcept;
+
+    bool operator==(const PeerId& o) const noexcept { return bytes_ == o.bytes_; }
+    bool operator!=(const PeerId& o) const noexcept { return bytes_ != o.bytes_; }
+    bool operator<(const PeerId& o) const noexcept { return bytes_ < o.bytes_; }
+
+    /// Hash functor for use as an unordered_map/set key.
+    struct Hash {
+        size_t operator()(const PeerId& id) const noexcept;
+    };
+
+private:
+    std::array<uint8_t, kSize> bytes_{};
+};
+
+} // namespace librats

package/native-src/src/librats/peer/peer_info.h

@@ -0,0 +1,37 @@
+#pragma once
+
+/**
+ * @file peer_info.h
+ * @brief Addressing/metadata for a peer — the shareable, persistable identity.
+ *
+ * PeerInfo is the "where / what" of a peer, kept separate from the live
+ * transport (Connection) and from the raw identity (PeerId). It is a value type:
+ * snapshotted into callbacks and into the PeerTable without touching live state.
+ */
+
+#include "librats/core/types.h"   // ConnRole
+#include "librats/core/address.h"
+#include "librats/peer/peer_id.h"
+
+#include <vector>
+
+namespace librats {
+
+/// Transports a peer says it accepts, as a bitmask (see IdentifyMessage). Kept
+/// separate from `transport`, which is the one this connection actually uses.
+enum PeerTransports : uint8_t {
+    PeerTransportNone = 0,
+    PeerTransportTcp  = 1 << 0,
+    PeerTransportUdp  = 1 << 1,
+};
+
+struct PeerInfo {
+    PeerId               id;
+    std::vector<Address> addresses;                 ///< known dialable addresses
+    ConnRole             direction = ConnRole::Outbound;
+    TransportKind        transport = TransportKind::Tcp;  ///< wire this connection runs on
+    uint8_t              supported_transports = PeerTransportNone;  ///< what the peer advertised
+    std::string          agent_version;             ///< optional remote agent string
+};
+
+} // namespace librats

package/native-src/src/librats/peer/peer_table.cpp

@@ -0,0 +1,170 @@
+#include "librats/peer/peer_table.h"
+
+#include <algorithm>  // std::find
+#include <mutex>      // std::unique_lock (shared_lock comes from <shared_mutex>)
+
+namespace librats {
+
+namespace {
+
+/// How much a transport is worth when two connections to the same peer have to be
+/// ranked. Both ends see the same pair of transports and apply the same order, so
+/// they converge on the same survivor without exchanging a word.
+///
+///   Udp   — one socket, one NAT mapping, a source port that can be dialed back
+///           (see dialer.h). The best link there is.
+///   Tcp   — a direct link all the same, just a less useful one to a NAT.
+///   Relay — not a direct link at all: every byte costs a third node bandwidth and
+///           a round trip. Ranked last here for completeness; in practice a relayed
+///           link is settled before this by the rule in add(), which lets ANY direct
+///           link beat it regardless of role.
+int transport_rank(TransportKind t) noexcept {
+    switch (t) {
+        case TransportKind::Udp:   return 2;
+        case TransportKind::Tcp:   return 1;
+        case TransportKind::Relay: return 0;
+    }
+    return 0;
+}
+
+} // namespace
+
+PeerTable::AddOutcome PeerTable::add(const PeerInfo& info, PeerRoute route,
+                                             bool prefer_outbound) {
+    std::unique_lock<std::shared_mutex> lock(mutex_);
+    auto [it, inserted] = peers_.try_emplace(info.id, Entry{info, route});
+    if (inserted) {
+        count_.fetch_add(1, std::memory_order_relaxed);
+        return {AddResult::NewPeer, std::nullopt};
+    }
+
+    Entry& cur = it->second;
+    if (cur.route == route) {            // same connection re-registering: refresh only
+        cur.info = info;
+        return {AddResult::Updated, std::nullopt};
+    }
+
+    // A different connection already serves this peer, and exactly one may survive.
+    // Both ends resolve the same pair, so every rule here must read something that
+    // looks identical from either side. Timing does not qualify — "whichever arrived
+    // first" gets a different answer at each end, and two ends that each keep the
+    // link the other just dropped are left with no link at all.
+    //
+    //   one relayed, one not ⇒ not a race at all but an upgrade (or a late relay
+    //                        arriving under a direct link): the direct one wins,
+    //                        whatever the roles. Ranked FIRST, ahead of the role
+    //                        rule, because a relayed link that won on role would
+    //                        keep costing a third node bandwidth for the life of a
+    //                        peer we can reach ourselves. Both ends see the same
+    //                        pair of transports, so both reach this same verdict.
+    //   opposite roles     ⇒ cross-connect: keep the link started by the smaller id
+    //                        (prefer_outbound, opposite at each end by construction).
+    //   different wires    ⇒ a dial race whose attempts both got through. Both ends
+    //                        see the transports and rank them by the same explicit
+    //                        order (transport_rank above), so neither can rank the
+    //                        same pair differently.
+    //   same role and wire ⇒ a reconnect, not a simultaneous pair: the old link is
+    //                        stale or already dead, so the newcomer is the live one.
+    const bool cur_relayed = cur.info.transport == TransportKind::Relay;
+    const bool new_relayed = info.transport == TransportKind::Relay;
+
+    bool keep_new = true;
+    if (cur_relayed != new_relayed) {
+        keep_new = !new_relayed;
+    } else if (cur.info.direction != info.direction) {
+        const ConnRole survivor = prefer_outbound ? ConnRole::Outbound : ConnRole::Inbound;
+        keep_new = (info.direction == survivor);
+    } else if (cur.info.transport != info.transport) {
+        keep_new = transport_rank(info.transport) > transport_rank(cur.info.transport);
+    }
+
+    if (keep_new) {
+        const PeerRoute loser = cur.route;
+        cur = Entry{info, route};
+        return {AddResult::Replaced, loser};
+    }
+    return {AddResult::Rejected, route};  // existing wins; caller closes the new connection
+}
+
+std::vector<Address> PeerTable::add_addresses(const PeerId& id, PeerRoute route,
+                                              const std::vector<Address>& addresses) {
+    std::vector<Address> added;
+    std::unique_lock<std::shared_mutex> lock(mutex_);
+    auto it = peers_.find(id);
+    if (it == peers_.end() || it->second.route != route) return added;
+
+    std::vector<Address>& known = it->second.info.addresses;
+    for (const Address& addr : addresses) {
+        if (known.size() >= kMaxAddressesPerPeer) break;
+        if (std::find(known.begin(), known.end(), addr) != known.end()) continue;  // dedup
+        known.push_back(addr);
+        added.push_back(addr);
+    }
+    return added;
+}
+
+std::optional<PeerTable::Destination> PeerTable::destination(const PeerId& id) const {
+    std::shared_lock<std::shared_mutex> lock(mutex_);
+    auto it = peers_.find(id);
+    if (it == peers_.end()) return std::nullopt;
+    return Destination{it->second.route, it->second.writable, it->second.owed};
+}
+
+bool PeerTable::all_writable() const {
+    std::shared_lock<std::shared_mutex> lock(mutex_);
+    for (const auto& [id, entry] : peers_)
+        if (!entry.writable) return false;
+    return true;
+}
+
+void PeerTable::set_writable(const PeerId& id, PeerRoute route, bool writable) {
+    std::unique_lock<std::shared_mutex> lock(mutex_);
+    auto it = peers_.find(id);
+    if (it == peers_.end() || it->second.route != route) return;
+    it->second.writable = writable;
+}
+
+void PeerTable::set_supported_transports(const PeerId& id, PeerRoute route, uint8_t mask) {
+    std::unique_lock<std::shared_mutex> lock(mutex_);
+    auto it = peers_.find(id);
+    if (it == peers_.end() || it->second.route != route) return;
+    it->second.info.supported_transports = mask;
+}
+
+bool PeerTable::remove(const PeerId& id, PeerRoute route) {
+    std::unique_lock<std::shared_mutex> lock(mutex_);
+    auto it = peers_.find(id);
+    if (it == peers_.end() || it->second.route != route) return false;
+    peers_.erase(it);
+    count_.fetch_sub(1, std::memory_order_relaxed);
+    return true;
+}
+
+std::optional<PeerRoute> PeerTable::route(const PeerId& id) const {
+    std::shared_lock<std::shared_mutex> lock(mutex_);
+    auto it = peers_.find(id);
+    if (it == peers_.end()) return std::nullopt;
+    return it->second.route;
+}
+
+std::optional<PeerInfo> PeerTable::info(const PeerId& id) const {
+    std::shared_lock<std::shared_mutex> lock(mutex_);
+    auto it = peers_.find(id);
+    if (it == peers_.end()) return std::nullopt;
+    return it->second.info;
+}
+
+bool PeerTable::contains(const PeerId& id) const {
+    std::shared_lock<std::shared_mutex> lock(mutex_);
+    return peers_.find(id) != peers_.end();
+}
+
+std::vector<PeerInfo> PeerTable::snapshot() const {
+    std::shared_lock<std::shared_mutex> lock(mutex_);
+    std::vector<PeerInfo> out;
+    out.reserve(peers_.size());
+    for (const auto& [id, entry] : peers_) out.push_back(entry.info);
+    return out;
+}
+
+} // namespace librats