librats 1.0.2 → 2.1.4

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

@@ -0,0 +1,89 @@
+#pragma once
+
+/**
+ * @file reactor.h
+ * @brief Single-threaded event loop for the BitTorrent peer transport.
+ *
+ * BitTorrent peers speak a plaintext wire protocol that is unrelated to the
+ * node's Noise mesh, so rather than bend `transport::Reactor` (which is tied to
+ * the Noise handshake) we assemble a dedicated loop from the same reusable
+ * primitives: an IOPoller, a TimerQueue, an MPSC task queue and a Notifier
+ * self-pipe to break the poll wait.
+ *
+ * One thread owns the loop and therefore all protocol state hung off it — peers,
+ * pickers, torrents — so none of that needs locks. Other threads reach in only
+ * through post(), which enqueues a task and wakes the loop. Socket registration
+ * (add/modify/remove) and timers are reactor-thread-only; call them from a task
+ * if you are elsewhere.
+ */
+
+#include "librats/util/rats_export.h"
+#include "librats/core/io_poller.h"
+#include "librats/core/mpsc_queue.h"
+#include "librats/core/notifier.h"
+#include "librats/core/socket.h"
+#include "librats/core/timer_queue.h"
+#include "librats/core/types.h"
+
+#include <atomic>
+#include <chrono>
+#include <cstdint>
+#include <functional>
+#include <thread>
+#include <unordered_map>
+
+namespace librats::bittorrent {
+
+class RATS_API Reactor {
+public:
+    using Task          = std::function<void()>;
+    using IoCallback    = std::function<void(std::uint32_t events)>;
+    using TimerCallback = std::function<void()>;
+
+    Reactor();
+    ~Reactor();
+
+    Reactor(const Reactor&) = delete;
+    Reactor& operator=(const Reactor&) = delete;
+
+    /// Run the loop on a dedicated thread until stop().
+    void start();
+    /// Stop the loop and join its thread (if any). Idempotent.
+    void stop();
+    /// Run the loop on the calling thread until stop().
+    void run();
+    /// Run a single loop iteration: poll, dispatch I/O, run posted tasks and due
+    /// timers. Exposed for tests and for embedding in another loop.
+    void run_one(int timeout_ms);
+
+    bool running() const noexcept { return running_.load(); }
+    bool on_reactor_thread() const noexcept { return std::this_thread::get_id() == loop_thread_; }
+
+    /// Enqueue a task to run on the reactor thread. Thread-safe.
+    void post(Task task);
+
+    // ---- reactor-thread only ----
+    bool add(socket_t fd, std::uint32_t events, IoCallback cb);
+    bool modify(socket_t fd, std::uint32_t events);
+    void remove(socket_t fd);
+
+    TimerId schedule(std::chrono::milliseconds delay, TimerCallback cb);
+    void    cancel(TimerId id);
+
+private:
+    void dispatch_io();
+    void run_tasks();
+
+    std::unique_ptr<IOPoller>                    poller_;
+    TimerQueue                                   timers_;
+    MpscQueue<Task>                              tasks_;
+    Notifier                                     notifier_;
+    std::unordered_map<socket_t, IoCallback>     handlers_;
+    std::vector<Task>                            task_scratch_;
+
+    std::atomic<bool> running_{false};
+    std::thread       thread_;
+    std::thread::id   loop_thread_;
+};
+
+} // namespace librats::bittorrent

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

@@ -0,0 +1,72 @@
+#include "librats/bittorrent/resume_data.h"
+
+#include "librats/bittorrent/bencode.h"
+
+#include <cstring>
+
+namespace librats::bittorrent {
+
+namespace {
+constexpr char kFormatTag[] = "librats resume";
+
+const librats::BencodeValue* find(const librats::BencodeValue& d, const char* key) {
+    return d.find(key);
+}
+} // namespace
+
+Bytes ResumeData::encode() const {
+    librats::BencodeValue d = librats::BencodeValue::create_dict();
+    d["format"]     = librats::BencodeValue(std::string(kFormatTag));
+    d["version"]    = librats::BencodeValue(std::int64_t(1));
+    d["info-hash"]  = librats::BencodeValue(std::string(reinterpret_cast<const char*>(info_hash.data()), info_hash.size()));
+    d["name"]       = librats::BencodeValue(name);
+    d["save-path"]  = librats::BencodeValue(save_path);
+    d["num-pieces"] = librats::BencodeValue(std::int64_t(have.size()));
+    d["pieces"]     = librats::BencodeValue(std::string(reinterpret_cast<const char*>(have.data()), have.data_size()));
+    d["uploaded"]   = librats::BencodeValue(std::int64_t(total_uploaded));
+    d["downloaded"] = librats::BencodeValue(std::int64_t(total_downloaded));
+    if (!info_dict.empty())
+        d["info"] = librats::BencodeValue(std::string(reinterpret_cast<const char*>(info_dict.data()), info_dict.size()));
+    return d.encode();
+}
+
+std::optional<ResumeData> ResumeData::decode(const Bytes& data) {
+    try {
+        librats::BencodeValue d = librats::BencodeDecoder::decode(data.data(), data.size());
+        if (!d.is_dict()) return std::nullopt;
+        const auto* fmt = find(d, "format");
+        if (!fmt || !fmt->is_string() || fmt->as_string() != kFormatTag) return std::nullopt;
+
+        ResumeData rd;
+        if (const auto* ih = find(d, "info-hash"); ih && ih->is_string() && ih->as_string().size() == 20)
+            std::memcpy(rd.info_hash.data(), ih->as_string().data(), 20);
+        if (const auto* n = find(d, "name"); n && n->is_string()) rd.name = n->as_string();
+        if (const auto* sp = find(d, "save-path"); sp && sp->is_string()) rd.save_path = sp->as_string();
+        if (const auto* up = find(d, "uploaded"); up && up->is_integer()) rd.total_uploaded = std::uint64_t(up->as_integer());
+        if (const auto* dn = find(d, "downloaded"); dn && dn->is_integer()) rd.total_downloaded = std::uint64_t(dn->as_integer());
+
+        std::int64_t num_pieces = 0;
+        if (const auto* np = find(d, "num-pieces"); np && np->is_integer() && np->as_integer() >= 0)
+            num_pieces = np->as_integer();
+        if (const auto* p = find(d, "pieces"); p && p->is_string()) {
+            const std::string& bytes = p->as_string();
+            // `num-pieces` is attacker-controlled and drives Bitfield::assign's
+            // allocation independently of the `pieces` string length. A tiny file
+            // claiming billions of pieces would allocate gigabytes (C4). A valid
+            // record always has exactly ceil(num_pieces/8) bytes of bitfield, so
+            // reject anything that doesn't match rather than trusting the count.
+            if (std::uint64_t((num_pieces + 7) / 8) != bytes.size()) return std::nullopt;
+            rd.have.assign(reinterpret_cast<const std::uint8_t*>(bytes.data()),
+                           bytes.size(), std::size_t(num_pieces));
+        }
+
+        if (const auto* info = find(d, "info"); info && info->is_string())
+            rd.info_dict.assign(info->as_string().begin(), info->as_string().end());
+
+        return rd;
+    } catch (const std::exception&) {
+        return std::nullopt;
+    }
+}
+
+} // namespace librats::bittorrent

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

@@ -0,0 +1,41 @@
+#pragma once
+
+/**
+ * @file resume_data.h
+ * @brief Fast-resume state: what a torrent needs to pick up where it left off
+ *        without re-hashing every piece on disk.
+ *
+ * It is a small bencoded record — the have-bitfield, transfer totals, save path
+ * and (optionally) the verbatim info dictionary so a magnet-started torrent can
+ * resume without re-fetching metadata. On load the engine *trusts* the recorded
+ * bitfield (skipping the hash check for those pieces); the verbatim info section,
+ * if present, is re-hashed against the info-hash before it is believed.
+ */
+
+#include "librats/util/rats_export.h"
+#include "librats/bittorrent/bitfield.h"
+#include "librats/bittorrent/types.h"
+#include "librats/core/bytes.h"
+
+#include <cstdint>
+#include <optional>
+#include <string>
+
+namespace librats::bittorrent {
+
+struct RATS_API ResumeData {
+    InfoHash      info_hash{};
+    std::string   name;
+    std::string   save_path;
+    Bitfield      have;                  ///< pieces already on disk
+    std::uint64_t total_uploaded   = 0;
+    std::uint64_t total_downloaded = 0;
+    Bytes         info_dict;             ///< optional verbatim info section
+
+    /// Serialise to the on-disk bencoded form.
+    Bytes encode() const;
+    /// Parse it back. nullopt if it isn't a librats resume record.
+    static std::optional<ResumeData> decode(const Bytes& data);
+};
+
+} // namespace librats::bittorrent

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

@@ -0,0 +1,48 @@
+#include "librats/bittorrent/store_buffer.h"
+
+#include <algorithm>
+
+namespace librats::bittorrent {
+
+void StoreBuffer::insert(std::uint32_t piece, std::uint32_t offset, const Bytes& data) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    blocks_[{piece, offset}] = data;
+}
+
+void StoreBuffer::erase(std::uint32_t piece, std::uint32_t offset) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    blocks_.erase({piece, offset});
+}
+
+void StoreBuffer::overlay(std::uint32_t piece, std::uint32_t offset, Bytes& out) const {
+    if (out.empty()) return;
+    const std::uint64_t read_begin = offset;
+    const std::uint64_t read_end   = offset + out.size();
+
+    std::lock_guard<std::mutex> lock(mutex_);
+    // Walk only this piece's entries: keys in [(piece,0), (piece+1,0)).
+    auto it  = blocks_.lower_bound({piece, 0});
+    auto end = (piece == UINT32_MAX) ? blocks_.end() : blocks_.lower_bound({piece + 1, 0});
+    for (; it != end; ++it) {
+        const std::uint64_t blk_begin = it->first.second;
+        const std::uint64_t blk_end   = blk_begin + it->second.size();
+        const std::uint64_t from = (std::max)(read_begin, blk_begin);
+        const std::uint64_t to   = (std::min)(read_end, blk_end);
+        if (from >= to) continue;  // no intersection
+        std::copy(it->second.begin() + std::ptrdiff_t(from - blk_begin),
+                  it->second.begin() + std::ptrdiff_t(to - blk_begin),
+                  out.begin() + std::ptrdiff_t(from - read_begin));
+    }
+}
+
+bool StoreBuffer::empty() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return blocks_.empty();
+}
+
+std::size_t StoreBuffer::size() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return blocks_.size();
+}
+
+} // namespace librats::bittorrent

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

@@ -0,0 +1,47 @@
+#pragma once
+
+/**
+ * @file store_buffer.h
+ * @brief In-RAM cache of blocks whose disk write is still in flight.
+ *
+ * When a block is handed to the disk for writing it is also parked here, keyed
+ * by (piece, offset within piece). A read or hash issued before that write
+ * reaches the platter is then satisfied from RAM by overlaying these bytes onto
+ * whatever the disk returned — so the engine never reads stale data for a block
+ * it has already accepted. The entry is dropped once the write completes.
+ *
+ * Thread-safe: writers insert/erase from disk-worker threads while readers
+ * overlay; all access is guarded by an internal mutex.
+ */
+
+#include "librats/core/bytes.h"
+
+#include <cstdint>
+#include <map>
+#include <mutex>
+
+namespace librats::bittorrent {
+
+class StoreBuffer {
+public:
+    /// Park a pending block. Replaces any existing entry at the same key.
+    void insert(std::uint32_t piece, std::uint32_t offset, const Bytes& data);
+
+    /// Drop a block once its write has landed on disk.
+    void erase(std::uint32_t piece, std::uint32_t offset);
+
+    /// Overlay any parked bytes for @p piece that intersect
+    /// [@p offset, @p offset + out.size()) onto @p out (indexed from @p offset).
+    void overlay(std::uint32_t piece, std::uint32_t offset, Bytes& out) const;
+
+    bool        empty() const;
+    std::size_t size()  const;
+
+private:
+    using Key = std::pair<std::uint32_t, std::uint32_t>;  // (piece, offset)
+
+    mutable std::mutex   mutex_;
+    std::map<Key, Bytes> blocks_;
+};
+
+} // namespace librats::bittorrent