librats 1.0.2 → 2.1.4

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

@@ -0,0 +1,260 @@
+#pragma once
+
+/**
+ * @file torrent.h
+ * @brief One active torrent: ties the piece picker, peers, disk and choker
+ *        together and drives a download (or seed) to completion.
+ *
+ * A Torrent is a PeerConnection::Observer — every wire event lands here and is
+ * turned into picker/disk work. The flow is event-driven, not polled:
+ *
+ *   peer unchokes / has new pieces → refill its request pipeline
+ *   block arrives                  → write to disk → (piece done) hash & verify
+ *   piece verified                 → mark have, announce `have` to peers
+ *   peer interested                → recompute the choker and (un)choke
+ *
+ * A 1 s tick only handles periodic chores (connect more peers, re-run the
+ * choker). All of this runs on the reactor thread, so there are no locks.
+ *
+ * Connections are owned by the host (Client); the Torrent holds raw pointers it
+ * learns at handshake and drops at close.
+ */
+
+#include "librats/util/rats_export.h"
+#include "librats/bittorrent/choker.h"
+#include "librats/bittorrent/disk_io.h"
+#include "librats/bittorrent/extensions.h"
+#include "librats/bittorrent/peer_connection.h"
+#include "librats/bittorrent/peer_list.h"
+#include "librats/bittorrent/piece_picker.h"
+#include "librats/bittorrent/reactor.h"
+#include "librats/bittorrent/resume_data.h"
+#include "librats/bittorrent/torrent_info.h"
+#include "librats/bittorrent/tracker.h"
+#include "librats/bittorrent/types.h"
+#include "librats/core/types.h"
+
+#include <atomic>
+#include <chrono>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+namespace librats::bittorrent {
+
+class Torrent;
+
+/// What a Torrent needs from its owning Client: outgoing connects and our id.
+class RATS_API TorrentHost {
+public:
+    virtual ~TorrentHost() = default;
+    virtual void          connect_peer(Torrent& torrent, const std::string& ip, std::uint16_t port) = 0;
+    virtual const PeerId& peer_id() const = 0;
+    virtual std::uint16_t listen_port() const = 0;
+    /// Discover peers for @p info_hash via the DHT (if the host has one); each
+    /// found peer is delivered to @p on_peer on the reactor thread. Default no-op.
+    virtual void find_peers_via_dht(const InfoHash& /*info_hash*/,
+                                    std::function<void(const std::string& ip, std::uint16_t port)> /*on_peer*/) {}
+    /// Announce ourselves to the DHT for @p info_hash on @p port so other clients
+    /// doing get_peers can find us (BEP 5). Default no-op (no DHT attached).
+    virtual void announce_to_dht(const InfoHash& /*info_hash*/, std::uint16_t /*port*/) {}
+};
+
+class RATS_API Torrent final : public PeerConnection::Observer {
+public:
+    enum class State { Stopped, Metadata, Checking, Downloading, Seeding };
+
+    Torrent(Reactor& reactor, TorrentHost& host, TorrentInfo info, std::string save_path);
+    ~Torrent() override;
+
+    Torrent(const Torrent&) = delete;
+    Torrent& operator=(const Torrent&) = delete;
+
+    void start();
+    void stop();
+
+    /// Pause a running torrent: drop its peers and stop dialing/serving, but keep
+    /// the piece picker and disk state so resume() does not re-hash. No-op if not
+    /// running or already paused.
+    void pause();
+    /// Resume a paused torrent: start reconnecting to peers again. No-op if not
+    /// running or not paused.
+    void resume();
+    bool is_paused() const noexcept { return paused_; }
+
+    /// Queue a peer to connect to (deduplicated). Connects promptly if running.
+    void add_peer(const std::string& ip, std::uint16_t port);
+
+    // ---- info / progress ----
+    const InfoHash&    info_hash()   const { return info_.info_hash(); }
+    const TorrentInfo& torrent_info()const { return info_; }
+    std::uint32_t      num_pieces()  const { return info_.num_pieces(); }
+    State              state()       const noexcept { return state_; }
+    bool               is_complete() const { return picker_ && picker_->is_finished(); }
+    double             progress()    const;
+    std::size_t        num_peers()   const noexcept { return peers_.size(); }
+    /// Total block requests currently in flight across all peers.
+    std::size_t        num_outstanding_requests() const noexcept;
+    /// Override how long a peer may hold requests without delivering before it is
+    /// snubbed and its blocks freed. Defaults to kRequestTimeout (30 s).
+    void               set_request_timeout(std::chrono::milliseconds t) noexcept { request_timeout_ = t; }
+    std::uint64_t      bytes_downloaded() const noexcept { return bytes_downloaded_; }
+    std::uint64_t      bytes_uploaded()   const noexcept { return bytes_uploaded_; }
+
+    /// True once we hold the full metadata (always true unless started from a magnet).
+    bool has_metadata() const noexcept { return has_metadata_; }
+
+    /// Fired once when a download reaches 100% (not for torrents that start complete).
+    void set_complete_callback(std::function<void()> cb) { on_complete_ = std::move(cb); }
+    /// Fired once when metadata is obtained for a magnet torrent (with the completed info).
+    void set_metadata_callback(std::function<void(const TorrentInfo&)> cb) { on_metadata_ = std::move(cb); }
+
+    // ---- fast resume ----
+    /// Apply saved resume state. Call before start(): the recorded have-bitfield
+    /// is trusted (those pieces skip the hash check), and an embedded info dict
+    /// completes a magnet torrent. Ignored if the info-hash doesn't match.
+    void       load_resume_data(const ResumeData& rd);
+    /// Load resume state from the default on-disk path (see default_resume_path).
+    /// Like load_resume_data(), call before start(). Returns false if no resume
+    /// file exists or it fails to decode.
+    bool       try_load_resume_data();
+    ResumeData generate_resume_data() const;
+    /// Write resume data to @p path (default: {save_path}/.resume/{info_hash}.resume).
+    bool save_resume_data() const;
+    bool save_resume_data(const std::string& path) const;
+
+    /// Called by the host when an outgoing connect attempt fails.
+    void on_connect_failed(const std::string& ip, std::uint16_t port);
+
+    // ---- PeerConnection::Observer ----
+    void on_handshake(PeerConnection&, const InfoHash&, const PeerId&) override;
+    void on_bitfield(PeerConnection&, const Bitfield&) override;
+    void on_have(PeerConnection&, std::uint32_t piece) override;
+    void on_choke(PeerConnection&, bool peer_choking) override;
+    void on_interest(PeerConnection&, bool peer_interested) override;
+    void on_request(PeerConnection&, std::uint32_t piece, std::uint32_t offset, std::uint32_t length) override;
+    void on_piece(PeerConnection&, std::uint32_t piece, std::uint32_t offset, ByteView data) override;
+    void on_extended(PeerConnection&, std::uint8_t ext_id, ByteView payload) override;
+    void on_closed(PeerConnection&, const std::string& reason) override;
+
+private:
+    /// Post @p fn to the reactor, guarded by alive_ so it is dropped if this
+    /// torrent has since been destroyed. Disk and tracker completions run on their
+    /// own worker threads and marshal back through here; a completion that a worker
+    /// posts while stop() is joining it can land in the reactor queue *after* the
+    /// torrent is erased, so the raw `this` those callbacks capture would dangle
+    /// (use-after-free). The guard is the only thing keeping that pointer live-safe.
+    void post(std::function<void()> fn);
+
+    void on_check_complete(Bitfield have);
+
+    // Extension protocol / metadata (BEP 10 / BEP 9).
+    void send_extended_handshake(PeerConnection& pc);
+    void handle_ext_handshake(PeerConnection& pc, ByteView payload);
+    void handle_ut_metadata(PeerConnection& pc, ByteView payload);
+    void ensure_metadata_buffer(std::uint32_t total_size);
+    void request_metadata(PeerConnection& pc);
+    void on_metadata_piece(std::uint32_t piece, std::uint32_t total_size, ByteView block);
+    void try_complete_metadata();
+    void promote_to_downloading();
+    void schedule_tick();
+    void tick();
+    void try_connect();
+    void update_interest(PeerConnection& pc);
+    void refill(PeerConnection& pc);
+    void recompute_choker();
+    /// Rotate the optimistic-unchoke slot to give a currently-choked interested
+    /// peer a chance to prove itself (so newcomers can bootstrap). ~30 s cadence.
+    void rotate_optimistic();
+    void handle_pex(PeerConnection& pc, ByteView payload);
+    void send_pex();
+    std::optional<ext::PexPeer> dialable(PeerConnection& pc) const;
+    void           announce_trackers(TrackerEvent event);
+    TrackerRequest make_tracker_request(TrackerEvent event) const;
+    std::string    default_resume_path() const;
+    /// Free blocks stuck on peers that have made no progress within
+    /// kRequestTimeout so other peers can re-request them (prevents a silent /
+    /// keep-alive-only peer from stalling pieces forever). Runs on the 1 s tick.
+    void check_request_timeouts();
+    /// Refill every peer whose pipeline has room (used to resume requesting once
+    /// disk write backpressure clears).
+    void refill_all();
+    void on_block_written(PieceBlock block, bool ok);
+    void verify_piece(std::uint32_t piece);
+    void on_piece_hashed(std::uint32_t piece, bool ok, std::array<std::uint8_t, 20> hash);
+    bool alive(PeerConnection* pc) const;
+    void remove_peer(PeerConnection* pc);
+
+    static constexpr int         kPipelineDepth = 16;
+    static constexpr std::size_t kMaxPeers      = 50;
+    /// A peer that holds outstanding requests but delivers no block for this long
+    /// is snubbed: its blocks are freed for other peers. Kept well under the 120 s
+    /// idle timeout so a keep-alive-only peer can't stall pieces indefinitely.
+    static constexpr std::chrono::seconds kRequestTimeout{30};
+    std::chrono::milliseconds request_timeout_{kRequestTimeout};
+    /// Stop requesting new blocks while the disk has more than this many bytes of
+    /// writes still pending, so a fast swarm can't grow the write queue without
+    /// bound when the disk is slow (D-2). Requesting resumes as the queue drains.
+    static constexpr std::size_t kDiskWriteHighWater = 32 * 1024 * 1024;
+
+    /// Liveness token shared with every reactor task this torrent posts (directly
+    /// or via a disk/tracker completion poster). Cleared in the destructor; the
+    /// shared_ptr keeps the flag readable after the torrent is gone, so a task
+    /// still queued on the reactor drops itself instead of touching freed memory.
+    std::shared_ptr<std::atomic<bool>> alive_ = std::make_shared<std::atomic<bool>>(true);
+
+    Reactor&                     reactor_;
+    TorrentHost&                 host_;
+    TorrentInfo                  info_;
+    std::string                  save_path_;
+    std::unique_ptr<PiecePicker>     picker_;
+    std::unique_ptr<DiskIo>          disk_;
+    std::unique_ptr<TrackerAnnouncer> trackers_;
+    Choker                           choker_;
+    State                        state_   = State::Stopped;
+    bool                         running_ = false;
+    bool                         paused_  = false;
+    bool                         has_metadata_ = false;
+    bool                         completed_announced_ = false;
+    bool                         write_stalled_ = false;  ///< requesting paused for disk backpressure
+    Bitfield                     resume_have_;   ///< trusted have-set from resume data
+
+    std::vector<PeerConnection*>                            peers_;
+    std::unordered_map<PeerConnection*, int>                outstanding_;
+    /// Time of the last progress with each peer (a block received, or the moment
+    /// we started waiting on a fresh batch). Drives the request-timeout snub.
+    std::unordered_map<PeerConnection*, std::chrono::steady_clock::time_point> request_time_;
+    std::unordered_map<PeerConnection*, std::uint64_t>      recent_down_;  // bytes recv this choke window (leech score)
+    std::unordered_map<PeerConnection*, std::uint64_t>      recent_up_;    // bytes served this choke window (seed score)
+    PeerConnection*                                         optimistic_ = nullptr;  // current optimistic-unchoke peer
+    std::unordered_set<PeerConnection*>                     seed_peers_;   // counted via the picker's O(1) seed counter
+    std::unordered_map<PeerConnection*, ext::PeerExtensions>           peer_ext_;
+    std::unordered_map<PeerConnection*, std::unordered_set<std::string>> pex_sent_;
+    std::unordered_map<PeerConnection*, int>                             pex_last_tick_;  ///< tick of last PEX to peer (BEP11 ≥60 s gap)
+    PeerList                                                          peer_list_;
+    int                                                               tick_count_ = 0;
+    int                                                               next_announce_tick_ = 300;  ///< tick to re-announce (driven by tracker interval)
+    int                                                               progress_logged_ = -1;      ///< last download %-decile logged at INFO (avoids per-piece spam)
+
+    // ut_metadata (BEP 9) assembly state, used while we lack metadata.
+    Bytes             metadata_buf_;
+    std::uint32_t     metadata_size_     = 0;
+    std::uint32_t     metadata_pieces_   = 0;
+    std::uint32_t     metadata_received_ = 0;
+    std::vector<bool> metadata_have_;
+
+    std::uint64_t bytes_downloaded_ = 0;  ///< cumulative payload downloaded (tracker stat / resume)
+    std::uint64_t bytes_uploaded_   = 0;
+    std::uint64_t verified_bytes_   = 0;  ///< payload currently present & verified on disk (drives `left`)
+
+    TimerId                                  tick_timer_ = kInvalidTimerId;
+    std::function<void()>                    on_complete_;
+    std::function<void(const TorrentInfo&)>  on_metadata_;
+};
+
+} // namespace librats::bittorrent

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

@@ -0,0 +1,129 @@
+#include "librats/bittorrent/torrent_creator.h"
+
+#include "librats/bittorrent/bencode.h"
+#include "librats/bittorrent/file_storage.h"
+#include "librats/crypto/sha1.h"
+#include "librats/util/fs.h"
+
+#include <ctime>
+
+namespace librats::bittorrent {
+
+namespace {
+
+struct SourceFile {
+    std::vector<std::string> components;  ///< path relative to the torrent root
+    std::int64_t             size = 0;
+    std::string              disk_path;   ///< where to read the bytes from
+};
+
+/// Recursively collect the regular files under @p dir, accumulating the path
+/// components relative to the torrent root.
+void scan_directory(const std::string& dir, std::vector<std::string> prefix,
+                    std::vector<SourceFile>& out) {
+    std::vector<DirectoryEntry> entries;
+    if (!list_directory(dir.c_str(), entries)) return;
+    for (const auto& e : entries) {
+        if (e.name == "." || e.name == "..") continue;
+        std::vector<std::string> comps = prefix;
+        comps.push_back(e.name);
+        const std::string child = combine_paths(dir, e.name);
+        if (e.is_directory) scan_directory(child, std::move(comps), out);
+        else out.push_back(SourceFile{std::move(comps), std::int64_t(get_file_size(child.c_str())), child});
+    }
+}
+
+} // namespace
+
+std::optional<TorrentInfo> TorrentCreator::create_from_path(const std::string& path, std::string* error,
+                                                            const PieceHashProgress& on_progress) {
+    auto fail = [&](const char* m) -> std::optional<TorrentInfo> { if (error) *error = m; return std::nullopt; };
+
+    const std::string root_name = name_.empty() ? get_filename_from_path(path) : name_;
+    if (root_name.empty()) return fail("empty torrent name");
+
+    // Gather the source files and lay them out (the layout also drives reading).
+    std::vector<SourceFile> sources;
+    bool single_file = false;
+    if (is_directory(path.c_str())) {
+        scan_directory(path, {}, sources);
+    } else if (is_file(path.c_str())) {
+        single_file = true;
+        sources.push_back(SourceFile{{root_name}, std::int64_t(get_file_size(path.c_str())), path});
+    } else {
+        return fail("path is neither a file nor a directory");
+    }
+    if (sources.empty()) return fail("no files to add");
+
+    FileStorage layout;
+    layout.set_piece_length(piece_length_);
+    layout.set_name(root_name);
+    std::vector<std::string> disk_paths;
+    for (const auto& s : sources) {
+        std::string rel = root_name;
+        if (!single_file)
+            for (const auto& c : s.components) { rel += '/'; rel += c; }
+        if (!layout.add_file(rel, s.size)) return fail("file size overflow");
+        disk_paths.push_back(s.disk_path);
+    }
+
+    // Hash every piece by reading the bytes it spans across the source files.
+    const std::uint32_t total_pieces = layout.num_pieces();
+    std::string pieces;
+    pieces.reserve(std::size_t(total_pieces) * 20);
+    for (std::uint32_t p = 0; p < total_pieces; ++p) {
+        Bytes buf;
+        buf.reserve(layout.piece_size(p));
+        for (const auto& slice : layout.map_block(p, 0, layout.piece_size(p))) {
+            Bytes chunk(std::size_t(slice.size));
+            if (!read_file_chunk(disk_paths[slice.file_index], std::uint64_t(slice.offset),
+                                 chunk.data(), chunk.size()))
+                return fail("failed to read source file");
+            buf.insert(buf.end(), chunk.begin(), chunk.end());
+        }
+        auto h = SHA1::hash_raw(buf.data(), buf.size());
+        pieces.append(reinterpret_cast<const char*>(h.data()), 20);
+        if (on_progress) on_progress(p + 1, total_pieces);
+    }
+
+    // Build the info dictionary.
+    librats::BencodeValue info = librats::BencodeValue::create_dict();
+    info["name"]         = librats::BencodeValue(root_name);
+    info["piece length"] = librats::BencodeValue(std::int64_t(piece_length_));
+    info["pieces"]       = librats::BencodeValue(pieces);
+    if (private_) info["private"] = librats::BencodeValue(std::int64_t(1));
+    if (single_file) {
+        info["length"] = librats::BencodeValue(std::int64_t(sources[0].size));
+    } else {
+        librats::BencodeValue files = librats::BencodeValue::create_list();
+        for (const auto& s : sources) {
+            librats::BencodeValue f = librats::BencodeValue::create_dict();
+            f["length"] = librats::BencodeValue(std::int64_t(s.size));
+            librats::BencodeValue comps = librats::BencodeValue::create_list();
+            for (const auto& c : s.components) comps.push_back(librats::BencodeValue(c));
+            f["path"] = comps;
+            files.push_back(f);
+        }
+        info["files"] = files;
+    }
+
+    // Wrap into a full .torrent with the optional top-level fields.
+    librats::BencodeValue root = librats::BencodeValue::create_dict();
+    if (!trackers_.empty()) {
+        root["announce"] = librats::BencodeValue(trackers_.front());
+        librats::BencodeValue tier = librats::BencodeValue::create_list();
+        for (const auto& t : trackers_) tier.push_back(librats::BencodeValue(t));
+        librats::BencodeValue al = librats::BencodeValue::create_list();
+        al.push_back(tier);
+        root["announce-list"] = al;
+    }
+    if (!comment_.empty())    root["comment"]    = librats::BencodeValue(comment_);
+    if (!created_by_.empty()) root["created by"] = librats::BencodeValue(created_by_);
+    root["creation date"] = librats::BencodeValue(std::int64_t(std::time(nullptr)));
+    root["info"]          = info;
+
+    torrent_bytes_ = root.encode();
+    return TorrentInfo::from_bytes(torrent_bytes_);
+}
+
+} // namespace librats::bittorrent

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

@@ -0,0 +1,58 @@
+#pragma once
+
+/**
+ * @file torrent_creator.h
+ * @brief Build a .torrent from files on disk.
+ *
+ * Point it at a file or directory; it lays the files end-to-end, hashes every
+ * piece (SHA-1), and emits both a parsed TorrentInfo and the bencoded .torrent
+ * bytes. The resulting metadata is exactly what a downloader would receive, so
+ * the creator can immediately seed via Client::add_torrent_for_seeding.
+ */
+
+#include "librats/bittorrent/torrent_info.h"
+#include "librats/bittorrent/types.h"
+#include "librats/core/bytes.h"
+
+#include <cstdint>
+#include <functional>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace librats::bittorrent {
+
+/// Reports piece-hashing progress during create_from_path: (pieces_hashed,
+/// total_pieces). Called once per piece as it is hashed; total_pieces is fixed
+/// for the whole run and the final call always has pieces_hashed == total_pieces.
+using PieceHashProgress = std::function<void(std::uint32_t pieces_hashed, std::uint32_t total_pieces)>;
+
+class TorrentCreator {
+public:
+    void set_piece_length(std::uint32_t length) { piece_length_ = length; }
+    void set_name(std::string name)             { name_ = std::move(name); }
+    void add_tracker(std::string url)           { trackers_.push_back(std::move(url)); }
+    void set_private(bool is_private)           { private_ = is_private; }
+    void set_comment(std::string comment)       { comment_ = std::move(comment); }
+    void set_created_by(std::string creator)    { created_by_ = std::move(creator); }
+
+    /// Hash @p path (a file or directory) and build the torrent. On success the
+    /// bencoded form is available via torrent_file(). Returns nullopt (and sets
+    /// @p error, if given) on I/O or layout problems. If @p on_progress is set it
+    /// is invoked once per hashed piece so callers can drive a progress bar.
+    std::optional<TorrentInfo> create_from_path(const std::string& path, std::string* error = nullptr,
+                                                const PieceHashProgress& on_progress = {});
+
+    const Bytes& torrent_file() const noexcept { return torrent_bytes_; }
+
+private:
+    std::uint32_t            piece_length_ = kDefaultPieceLength;
+    std::string              name_;
+    std::string              comment_;
+    std::string              created_by_;
+    bool                     private_ = false;
+    std::vector<std::string> trackers_;
+    Bytes                    torrent_bytes_;
+};
+
+} // namespace librats::bittorrent