librats 1.0.2 → 2.2.0

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

@@ -0,0 +1,194 @@
+#pragma once
+
+/**
+ * @file peer_connection.h
+ * @brief One peer link: the BitTorrent wire handshake, message codec and the
+ *        choke/interest state machine.
+ *
+ * A PeerConnection owns a non-blocking TCP socket registered with a Reactor and
+ * lives entirely on that reactor's thread. It turns the byte stream into
+ * protocol events delivered to an Observer, and offers send_* methods to emit
+ * messages. It deliberately knows nothing about pieces-to-request strategy or
+ * disk — the owning Torrent (a later phase) drives those through this surface.
+ *
+ * Wire format: a 68-byte handshake, then length-prefixed messages
+ * `[u32 length][u8 id][payload]` (length 0 = keep-alive). All integers are
+ * big-endian.
+ */
+
+#include "librats/bittorrent/bitfield.h"
+#include "librats/bittorrent/reactor.h"
+#include "librats/bittorrent/types.h"
+#include "librats/core/bytes.h"
+#include "librats/core/chained_send_buffer.h"
+#include "librats/core/receive_buffer.h"
+
+#include <chrono>
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <vector>
+
+namespace librats::bittorrent {
+
+enum class MessageId : std::uint8_t {
+    Choke         = 0,
+    Unchoke       = 1,
+    Interested    = 2,
+    NotInterested = 3,
+    Have          = 4,
+    Bitfield      = 5,
+    Request       = 6,
+    Piece         = 7,
+    Cancel        = 8,
+    Port          = 9,
+    Extended      = 20,
+};
+
+class PeerConnection {
+public:
+    /// Protocol events. All fire on the reactor thread; ByteView arguments are
+    /// only valid for the duration of the call (copy if you need to keep them).
+    struct Observer {
+        virtual ~Observer() = default;
+        virtual void on_handshake(PeerConnection&, const InfoHash&, const PeerId&) {}
+        virtual void on_choke(PeerConnection&, bool peer_choking) {}
+        virtual void on_interest(PeerConnection&, bool peer_interested) {}
+        virtual void on_have(PeerConnection&, std::uint32_t piece) {}
+        virtual void on_bitfield(PeerConnection&, const Bitfield&) {}
+        virtual void on_request(PeerConnection&, std::uint32_t piece, std::uint32_t offset, std::uint32_t length) {}
+        virtual void on_piece(PeerConnection&, std::uint32_t piece, std::uint32_t offset, ByteView data) {}
+        virtual void on_cancel(PeerConnection&, std::uint32_t piece, std::uint32_t offset, std::uint32_t length) {}
+        virtual void on_port(PeerConnection&, std::uint16_t port) {}
+        virtual void on_extended(PeerConnection&, std::uint8_t ext_id, ByteView payload) {}
+        virtual void on_closed(PeerConnection&, const std::string& reason) {}
+    };
+
+    /// Late-binding info for an incoming connection: filled by the Resolver once
+    /// the peer's handshake reveals which torrent it is for.
+    struct Binding {
+        Observer*     observer   = nullptr;
+        std::uint32_t num_pieces = 0;
+    };
+    /// Maps an incoming handshake's info-hash to a torrent. Return false to reject.
+    using Resolver = std::function<bool(const InfoHash& their_info_hash, Binding& out)>;
+
+    /// Outgoing connection: we know the torrent up front.
+    /// @param num_pieces sizes the peer's bitfield; 0 if metadata isn't known yet.
+    PeerConnection(Reactor& reactor, socket_t sock, bool outgoing,
+                   const InfoHash& info_hash, const PeerId& our_peer_id,
+                   std::uint32_t num_pieces, Observer* observer,
+                   std::string remote_ip = "", std::uint16_t remote_port = 0);
+    /// Incoming connection: the torrent is resolved from the peer's handshake.
+    PeerConnection(Reactor& reactor, socket_t sock, const PeerId& our_peer_id,
+                   Resolver resolver, std::string remote_ip = "", std::uint16_t remote_port = 0);
+    ~PeerConnection();
+
+    PeerConnection(const PeerConnection&) = delete;
+    PeerConnection& operator=(const PeerConnection&) = delete;
+
+    /// Register with the reactor; an outgoing connection sends its handshake now.
+    void start();
+    /// Tear down: deregister, close the socket, fire on_closed once.
+    void close(const std::string& reason);
+
+    // ---- state ----
+    bool            closed()          const noexcept { return closed_; }
+    bool            handshake_done()  const noexcept { return handshake_sent_ && handshake_received_; }
+    bool            outgoing()        const noexcept { return outgoing_; }
+    bool            am_choking()      const noexcept { return am_choking_; }
+    bool            am_interested()   const noexcept { return am_interested_; }
+    bool            peer_choking()    const noexcept { return peer_choking_; }
+    bool            peer_interested() const noexcept { return peer_interested_; }
+    const Bitfield& peer_bitfield()   const noexcept { return peer_have_; }
+    const PeerId&   peer_id()         const noexcept { return peer_id_; }
+    const InfoHash& info_hash()       const noexcept { return info_hash_; }
+    bool            peer_supports_extensions() const noexcept { return reserved::has_extensions(peer_reserved_); }
+    const std::string& remote_ip()   const noexcept { return remote_ip_; }
+    std::uint16_t      remote_port()  const noexcept { return remote_port_; }
+
+    // ---- send ----
+    void send_keepalive();
+    void send_choke();
+    void send_unchoke();
+    void send_interested();
+    void send_not_interested();
+    void send_have(std::uint32_t piece);
+    void send_bitfield(const Bitfield& bitfield);
+    void send_request(std::uint32_t piece, std::uint32_t offset, std::uint32_t length);
+    /// Takes ownership of `data` — the block goes into the send queue as its own
+    /// chunk, so a disk read is handed straight to the socket without a copy.
+    void send_piece(std::uint32_t piece, std::uint32_t offset, Bytes data);
+    void send_cancel(std::uint32_t piece, std::uint32_t offset, std::uint32_t length);
+    void send_port(std::uint16_t port);
+    void send_extended(std::uint8_t ext_id, ByteView payload);
+
+private:
+    void on_io(std::uint32_t events);
+    void do_read();
+    std::size_t read_size() const;  ///< bytes to offer the next recv() (see rx_need_)
+    void parse();
+    bool parse_handshake();
+    void send_handshake();
+    void dispatch(MessageId id, const std::uint8_t* payload, std::uint32_t len);
+
+    void send_message(MessageId id, const std::uint8_t* payload, std::uint32_t len);
+    /// Append to the send queue. No syscall: the caller flushes once the whole
+    /// message is queued, so a message never costs more than one send().
+    void queue(ByteView bytes) { if (!closed_) tx_.append(bytes); }
+    /// Queue a buffer the caller already owns — moved in, never copied.
+    void queue(Bytes bytes) { if (!closed_) tx_.append(std::move(bytes)); }
+    /// Push the queue to the socket with one gather-send, (dis)arm write interest,
+    /// and enforce the send high-water mark. May close the connection.
+    void flush();
+    void want_write(bool on);
+    /// Periodic self-rescheduling tick: enforces the handshake/idle deadlines and
+    /// emits keep-alives. Stops rescheduling once the connection is closed.
+    void tick();
+
+    Reactor&      reactor_;
+    socket_t      sock_;
+    bool          outgoing_;
+    InfoHash      info_hash_;
+    PeerId        our_peer_id_;
+    PeerId        peer_id_{};
+    std::uint32_t num_pieces_;
+    Observer*     obs_;
+    Resolver      resolver_;        ///< incoming only; resolves the torrent
+    bool          bound_ = true;    ///< false for an unresolved incoming connection
+    std::string   remote_ip_;       ///< peer's address (source for incoming, dialed for outgoing)
+    std::uint16_t remote_port_ = 0;
+
+    ReceiveBuffer     rx_;
+    /// Wire size of the message rx_ is mid-way through (4-byte prefix included), once
+    /// that prefix has been read; 0 when no message is in flight. Lets the next recv()
+    /// size rx_ for the whole message in one go. Peer-declared, hence capped.
+    std::size_t       rx_need_ = 0;
+    ChainedSendBuffer tx_;
+    bool              want_write_ = false;
+
+    // Timeout bookkeeping, all evaluated by the periodic tick().
+    TimerId                               tick_timer_ = kInvalidTimerId;
+    std::chrono::steady_clock::time_point created_{};    ///< start() time — handshake deadline
+    std::chrono::steady_clock::time_point last_recv_{};  ///< last byte received — idle deadline
+    std::chrono::steady_clock::time_point last_sent_{};  ///< last byte sent — keep-alive timer
+
+    bool          started_           = false;
+    bool          handshake_sent_    = false;
+    bool          handshake_received_= false;
+    bool          closed_            = false;
+
+    bool          am_choking_      = true;
+    bool          am_interested_   = false;
+    bool          peer_choking_    = true;
+    bool          peer_interested_ = false;
+    /// A bitfield is only valid as the peer's first piece-state message (BEP 3).
+    /// Set once the peer has sent a bitfield or any HAVE; a later bitfield is then
+    /// rejected so we can't double-count its availability against a single per-bit
+    /// decrement at disconnect.
+    bool          piece_state_begun_ = false;
+    Bitfield      peer_have_;
+    ReservedBytes peer_reserved_{};
+};
+
+} // namespace librats::bittorrent

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

@@ -0,0 +1,68 @@
+#include "librats/bittorrent/peer_list.h"
+
+#include <algorithm>
+
+namespace librats::bittorrent {
+
+bool PeerList::add(const std::string& ip, std::uint16_t port, PeerSource source) {
+    if (ip.empty() || port == 0) return false;
+    auto [it, inserted] = peers_.try_emplace(key(ip, port));
+    Peer& p = it->second;
+    p.sources |= std::uint8_t(source);
+    if (inserted) { p.ip = ip; p.port = port; }
+    return inserted;
+}
+
+std::vector<PeerList::Endpoint> PeerList::connect_candidates(std::size_t max) {
+    std::vector<Peer*> eligible_peers;
+    for (auto& [k, p] : peers_)
+        if (eligible(p)) eligible_peers.push_back(&p);
+
+    // Fewest past failures first; ties broken by richer source provenance so a
+    // tracker/DHT-vouched peer outranks one only seen via PEX.
+    std::sort(eligible_peers.begin(), eligible_peers.end(), [](const Peer* a, const Peer* b) {
+        if (a->fail_count != b->fail_count) return a->fail_count < b->fail_count;
+        return a->sources > b->sources;
+    });
+
+    std::vector<Endpoint> out;
+    const std::size_t take = (std::min)(max, eligible_peers.size());
+    out.reserve(take);
+    for (std::size_t i = 0; i < take; ++i) {
+        eligible_peers[i]->connecting = true;
+        out.push_back(Endpoint{eligible_peers[i]->ip, eligible_peers[i]->port});
+    }
+    return out;
+}
+
+void PeerList::set_connected(const std::string& ip, std::uint16_t port, bool connected) {
+    auto it = peers_.find(key(ip, port));
+    if (it == peers_.end()) return;
+    it->second.connected  = connected;
+    it->second.connecting = false;
+    if (connected) it->second.fail_count = 0;  // a successful connect clears the penalty
+}
+
+void PeerList::on_connect_failed(const std::string& ip, std::uint16_t port) {
+    auto it = peers_.find(key(ip, port));
+    if (it == peers_.end()) return;
+    it->second.connecting = false;
+    ++it->second.fail_count;
+}
+
+void PeerList::ban(const std::string& ip, std::uint16_t port) {
+    auto it = peers_.find(key(ip, port));
+    if (it != peers_.end()) it->second.banned = true;
+}
+
+std::size_t PeerList::num_candidates() const {
+    std::size_t n = 0;
+    for (const auto& [k, p] : peers_) if (eligible(p)) ++n;
+    return n;
+}
+
+bool PeerList::contains(const std::string& ip, std::uint16_t port) const {
+    return peers_.count(key(ip, port)) != 0;
+}
+
+} // namespace librats::bittorrent

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

@@ -0,0 +1,75 @@
+#pragma once
+
+/**
+ * @file peer_list.h
+ * @brief The set of *known* peer addresses for a torrent (distinct from the live
+ *        connections).
+ *
+ * Every discovery source — tracker, DHT, PEX, LSD, incoming — funnels addresses
+ * here; the Torrent then asks for connect_candidates() to dial. The list
+ * deduplicates, remembers which sources vouched for a peer, counts connection
+ * failures (so hopeless peers drift to the back and eventually drop out), and
+ * supports banning. Owned by one torrent on the reactor thread — not thread-safe.
+ */
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace librats::bittorrent {
+
+enum class PeerSource : std::uint8_t {
+    Tracker  = 1,
+    Dht      = 2,
+    Pex      = 4,
+    Lsd      = 8,
+    Incoming = 16,
+};
+
+class PeerList {
+public:
+    struct Endpoint { std::string ip; std::uint16_t port; };
+
+    struct Peer {
+        std::string   ip;
+        std::uint16_t port       = 0;
+        std::uint8_t  sources    = 0;
+        bool          connected  = false;
+        bool          connecting = false;
+        bool          banned     = false;
+        std::uint32_t fail_count = 0;
+    };
+
+    static constexpr std::uint32_t kMaxFails = 5;
+
+    /// Add or merge a candidate. Returns true if it was newly created.
+    bool add(const std::string& ip, std::uint16_t port, PeerSource source);
+
+    /// Up to @p max eligible peers to dial (not connected/connecting/banned, and
+    /// under the failure limit), best first. The returned peers are marked
+    /// `connecting` so they aren't handed out again until resolved.
+    std::vector<Endpoint> connect_candidates(std::size_t max);
+
+    void set_connected(const std::string& ip, std::uint16_t port, bool connected);
+    void on_connect_failed(const std::string& ip, std::uint16_t port);
+    void ban(const std::string& ip, std::uint16_t port);
+
+    std::size_t size()           const noexcept { return peers_.size(); }
+    std::size_t num_candidates() const;          ///< count currently eligible to dial
+    bool        contains(const std::string& ip, std::uint16_t port) const;
+
+private:
+    static std::string key(const std::string& ip, std::uint16_t port) {
+        return ip + ":" + std::to_string(port);
+    }
+    bool eligible(const Peer& p) const noexcept {
+        return !p.connected && !p.connecting && !p.banned && p.fail_count < kMaxFails;
+    }
+
+    std::unordered_map<std::string, Peer> peers_;
+};
+
+} // namespace librats::bittorrent