librats 1.0.2 → 2.2.0

package/native-src/src/librats/bittorrent/bitfield.cpp

@@ -0,0 +1,97 @@
+#include "librats/bittorrent/bitfield.h"
+
+#include <algorithm>
+#include <array>
+
+namespace librats::bittorrent {
+
+namespace {
+
+/// 256-entry popcount table, built once. Reading a table beats per-bit work and
+/// keeps count() branch-free and portable across compilers (no C++20 std::popcount).
+const std::array<std::uint8_t, 256>& popcount_table() {
+    static const std::array<std::uint8_t, 256> table = [] {
+        std::array<std::uint8_t, 256> t{};
+        for (int i = 0; i < 256; ++i) {
+            std::uint8_t bits = 0;
+            for (int b = i; b; b >>= 1) bits += b & 1;
+            t[std::size_t(i)] = bits;
+        }
+        return t;
+    }();
+    return table;
+}
+
+} // namespace
+
+void Bitfield::resize(std::size_t bits, bool value) {
+    const std::size_t old_bits  = bits_;
+    const std::size_t new_bytes = (bits + 7) / 8;
+
+    // resize() fills only the *newly appended* bytes with the fill value.
+    bytes_.resize(new_bytes, value ? 0xFFu : 0x00u);
+    bits_ = bits;
+
+    // When growing with value=true, the spare bits left over in the old (partial)
+    // last byte were trailing zeros and weren't touched by resize() — set them.
+    if (value && bits > old_bits) {
+        const std::size_t old_byte_end = (old_bits + 7) / 8 * 8;  // bit just past old last byte
+        for (std::size_t i = old_bits; i < (std::min)(bits, old_byte_end); ++i) set(i);
+    }
+    clear_trailing_bits();
+}
+
+void Bitfield::assign(const std::uint8_t* data, std::size_t bytes, std::size_t bits) {
+    bytes_.assign(data, data + bytes);
+    bytes_.resize((bits + 7) / 8, 0x00u);  // tolerate a short/long wire buffer
+    bits_ = bits;
+    clear_trailing_bits();
+}
+
+void Bitfield::clear_trailing_bits() noexcept {
+    const std::size_t rem = bits_ & 7;
+    if (rem != 0 && !bytes_.empty()) {
+        bytes_.back() &= std::uint8_t(0xFFu << (8 - rem));  // keep the top `rem` bits
+    }
+}
+
+std::size_t Bitfield::count() const noexcept {
+    // Spare bits are always zero, so whole-byte popcount is exact.
+    const auto& tbl = popcount_table();
+    std::size_t n = 0;
+    for (std::uint8_t b : bytes_) n += tbl[b];
+    return n;
+}
+
+bool Bitfield::all_set() const noexcept {
+    return find_first_unset() == bits_;
+}
+
+bool Bitfield::none_set() const noexcept {
+    for (std::uint8_t b : bytes_) if (b != 0) return false;
+    return true;
+}
+
+void Bitfield::set_all() noexcept {
+    std::fill(bytes_.begin(), bytes_.end(), 0xFFu);
+    clear_trailing_bits();
+}
+
+void Bitfield::clear_all() noexcept {
+    std::fill(bytes_.begin(), bytes_.end(), 0x00u);
+}
+
+std::size_t Bitfield::find_first_unset() const noexcept {
+    for (std::size_t bi = 0; bi < bytes_.size(); ++bi) {
+        if (bytes_[bi] == 0xFFu) continue;            // fully set byte — skip fast
+        const std::size_t base = bi * 8;
+        for (std::size_t k = 0; k < 8; ++k) {
+            const std::size_t idx = base + k;
+            if (idx >= bits_) return bits_;
+            if (!get(idx)) return idx;
+        }
+    }
+    return bits_;
+}
+
+} // namespace librats::bittorrent

package/native-src/src/librats/bittorrent/bitfield.h

@@ -0,0 +1,76 @@
+#pragma once
+
+/**
+ * @file bitfield.h
+ * @brief A compact, wire-compatible bit set — the BitTorrent "bitfield".
+ *
+ * Bits are packed MSB-first within each byte (bit @c i lives in byte @c i/8 at
+ * mask @c 0x80>>(i%8)), which is exactly the on-wire layout of the BEP 3
+ * `bitfield` message. So data()/data_size() can be sent verbatim and assign()
+ * ingests a received message with no conversion. Spare bits in the final byte
+ * are always kept zero, which lets count()/none_set() scan whole bytes safely.
+ *
+ * Owned by a single torrent on the network thread — deliberately not thread-safe.
+ */
+
+#include "librats/util/rats_export.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+namespace librats::bittorrent {
+
+class RATS_API Bitfield {
+public:
+    Bitfield() = default;
+    explicit Bitfield(std::size_t bits, bool value = false) { resize(bits, value); }
+
+    /// Resize to @p bits bits; any newly added bits take @p value. Existing bits preserved.
+    void resize(std::size_t bits, bool value = false);
+
+    /// Ingest a received wire bitfield: @p bytes raw bytes interpreted as @p bits bits.
+    /// Spare bits beyond @p bits are cleared so the invariant holds.
+    void assign(const std::uint8_t* data, std::size_t bytes, std::size_t bits);
+
+    void clear() noexcept { bytes_.clear(); bits_ = 0; }
+
+    std::size_t size()      const noexcept { return bits_; }
+    std::size_t num_bytes() const noexcept { return bytes_.size(); }
+    bool        empty()     const noexcept { return bits_ == 0; }
+
+    bool get(std::size_t i) const noexcept {
+        return (bytes_[i >> 3] & (0x80u >> (i & 7))) != 0;
+    }
+    bool operator[](std::size_t i) const noexcept { return get(i); }
+
+    void set(std::size_t i) noexcept   { bytes_[i >> 3] |=  std::uint8_t(0x80u >> (i & 7)); }
+    void reset(std::size_t i) noexcept { bytes_[i >> 3] &= std::uint8_t(~(0x80u >> (i & 7))); }
+    void set(std::size_t i, bool v) noexcept { if (v) set(i); else reset(i); }
+
+    std::size_t count()    const noexcept;  ///< number of set bits
+    bool        all_set()  const noexcept;
+    bool        none_set() const noexcept;
+    void        set_all()   noexcept;
+    void        clear_all() noexcept;
+
+    /// First index whose bit is 0, or size() if all bits are set. Answers
+    /// "what is the first piece I still need?".
+    std::size_t find_first_unset() const noexcept;
+
+    const std::uint8_t* data()      const noexcept { return bytes_.data(); }
+    std::size_t         data_size() const noexcept { return bytes_.size(); }
+
+    bool operator==(const Bitfield& o) const noexcept {
+        return bits_ == o.bits_ && bytes_ == o.bytes_;
+    }
+    bool operator!=(const Bitfield& o) const noexcept { return !(*this == o); }
+
+private:
+    void clear_trailing_bits() noexcept;  ///< keep the spare bits of the last byte zero
+
+    std::vector<std::uint8_t> bytes_;
+    std::size_t               bits_ = 0;
+};
+
+} // namespace librats::bittorrent

package/native-src/src/librats/bittorrent/byte_io.h

@@ -0,0 +1,58 @@
+#pragma once
+
+/**
+ * @file byte_io.h
+ * @brief Big-endian (network order) integer read/write helpers for the BitTorrent wire.
+ *
+ * The BitTorrent peer protocol, the BEP 15 UDP tracker protocol and extension
+ * messages are all big-endian. These tiny inline helpers keep (de)serialisation
+ * obvious and endianness-correct, without sprinkling htonl/ntohl or manual shifts
+ * across the codebase.
+ */
+
+#include "librats/core/bytes.h"
+
+#include <cstddef>
+#include <cstdint>
+
+namespace librats::bittorrent {
+
+inline std::uint16_t read_u16_be(const std::uint8_t* p) noexcept {
+    return std::uint16_t(std::uint16_t(p[0]) << 8 | std::uint16_t(p[1]));
+}
+inline std::uint32_t read_u32_be(const std::uint8_t* p) noexcept {
+    return std::uint32_t(p[0]) << 24 | std::uint32_t(p[1]) << 16
+         | std::uint32_t(p[2]) << 8  | std::uint32_t(p[3]);
+}
+inline std::uint64_t read_u64_be(const std::uint8_t* p) noexcept {
+    return std::uint64_t(read_u32_be(p)) << 32 | read_u32_be(p + 4);
+}
+
+inline void write_u16_be(std::uint8_t* p, std::uint16_t v) noexcept {
+    p[0] = std::uint8_t(v >> 8);
+    p[1] = std::uint8_t(v);
+}
+inline void write_u32_be(std::uint8_t* p, std::uint32_t v) noexcept {
+    p[0] = std::uint8_t(v >> 24);
+    p[1] = std::uint8_t(v >> 16);
+    p[2] = std::uint8_t(v >> 8);
+    p[3] = std::uint8_t(v);
+}
+inline void write_u64_be(std::uint8_t* p, std::uint64_t v) noexcept {
+    write_u32_be(p,     std::uint32_t(v >> 32));
+    write_u32_be(p + 4, std::uint32_t(v));
+}
+
+// Append helpers — grow a Bytes buffer with one big-endian value.
+inline void append_u8(Bytes& b, std::uint8_t v) { b.push_back(v); }
+inline void append_u16_be(Bytes& b, std::uint16_t v) {
+    std::uint8_t t[2]; write_u16_be(t, v); b.insert(b.end(), t, t + 2);
+}
+inline void append_u32_be(Bytes& b, std::uint32_t v) {
+    std::uint8_t t[4]; write_u32_be(t, v); b.insert(b.end(), t, t + 4);
+}
+inline void append_u64_be(Bytes& b, std::uint64_t v) {
+    std::uint8_t t[8]; write_u64_be(t, v); b.insert(b.end(), t, t + 8);
+}
+
+} // namespace librats::bittorrent

package/native-src/src/librats/bittorrent/choker.cpp

@@ -0,0 +1,25 @@
+#include "librats/bittorrent/choker.h"
+
+#include <algorithm>
+
+namespace librats::bittorrent {
+
+std::vector<const void*> Choker::select(std::vector<Candidate> candidates,
+                                        const void* optimistic) const {
+    // Highest score first; stable so equal-score peers keep a deterministic order.
+    std::stable_sort(candidates.begin(), candidates.end(),
+                     [](const Candidate& a, const Candidate& b) { return a.score > b.score; });
+
+    std::vector<const void*> chosen;
+    const std::size_t take = (std::min)(slots_, candidates.size());
+    chosen.reserve(take + 1);
+    for (std::size_t i = 0; i < take; ++i) chosen.push_back(candidates[i].peer);
+
+    if (optimistic &&
+        std::find(chosen.begin(), chosen.end(), optimistic) == chosen.end()) {
+        chosen.push_back(optimistic);
+    }
+    return chosen;
+}
+
+} // namespace librats::bittorrent

package/native-src/src/librats/bittorrent/choker.h

@@ -0,0 +1,46 @@
+#pragma once
+
+/**
+ * @file choker.h
+ * @brief The unchoke decision — who we upload to.
+ *
+ * BitTorrent reciprocates: a leecher unchokes the peers that feed it fastest
+ * (tit-for-tat), a seed spreads its slots by upload rate. The Choker is a pure
+ * policy over a list of *interested* candidates scored by the caller (recent
+ * bytes received from them, or served to them when seeding): it returns the
+ * subset to unchoke — the top `slots` by score, plus an optional optimistic
+ * unchoke that gets a chance regardless of score so newcomers can bootstrap.
+ *
+ * Stateless and side-effect-free, so the Torrent can recompute it each round and
+ * apply the diff against current choke state.
+ */
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+namespace librats::bittorrent {
+
+class Choker {
+public:
+    explicit Choker(std::size_t upload_slots = 4) : slots_(upload_slots) {}
+
+    void        set_slots(std::size_t slots) noexcept { slots_ = slots; }
+    std::size_t slots() const noexcept { return slots_; }
+
+    struct Candidate {
+        const void*   peer  = nullptr;  ///< opaque peer identity
+        std::uint64_t score = 0;        ///< higher = more deserving of a slot
+    };
+
+    /// Choose who to unchoke. Pass only *interested* peers. The result holds the
+    /// top `slots` by score; if @p optimistic is non-null it is always included
+    /// (an extra slot if it didn't already make the cut).
+    std::vector<const void*> select(std::vector<Candidate> candidates,
+                                    const void* optimistic = nullptr) const;
+
+private:
+    std::size_t slots_;
+};
+
+} // namespace librats::bittorrent