librats 1.0.2 → 2.1.4

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

@@ -0,0 +1,374 @@
+#include "librats/bittorrent/tracker.h"
+
+#include "librats/bittorrent/bencode.h"
+#include "librats/bittorrent/byte_io.h"
+#include "librats/bittorrent/log.h"
+#include "librats/core/socket.h"
+#include "librats/util/network_utils.h"
+
+#include <algorithm>
+#include <cctype>
+#include <cstring>
+#include <iomanip>
+#include <random>
+#include <sstream>
+#include <thread>
+
+namespace librats::bittorrent {
+
+namespace {
+
+// UDP BEP 15 constants.
+constexpr std::int64_t  kUdpMagic       = 0x41727101980LL;
+constexpr std::uint32_t kActionConnect  = 0;
+constexpr std::uint32_t kActionAnnounce = 1;
+constexpr std::uint32_t kActionError    = 3;
+
+std::uint32_t random_u32() {
+    thread_local std::mt19937 gen(std::random_device{}());
+    return std::uniform_int_distribution<std::uint32_t>{}(gen);
+}
+
+// Parse a TCP/UDP port out of an untrusted tracker URL. Returns 0 on anything
+// that is not a plain 1..65535 decimal number. std::stoi must NOT be used here:
+// a hostile ".torrent"/magnet `tr=udp://host:notaport` would throw
+// std::invalid_argument out of the detached announce worker → std::terminate.
+std::uint16_t parse_port(const std::string& s) {
+    if (s.empty()) return 0;
+    std::uint32_t v = 0;
+    for (const char c : s) {
+        if (c < '0' || c > '9') return 0;
+        v = v * 10 + std::uint32_t(c - '0');
+        if (v > 65535) return 0;
+    }
+    return std::uint16_t(v);
+}
+
+const char* http_event(TrackerEvent e) {
+    switch (e) {
+        case TrackerEvent::Started:   return "started";
+        case TrackerEvent::Stopped:   return "stopped";
+        case TrackerEvent::Completed: return "completed";
+        default:                      return "";
+    }
+}
+
+// UDP event codes differ from our enum order, so map explicitly.
+std::uint32_t udp_event(TrackerEvent e) {
+    switch (e) {
+        case TrackerEvent::Completed: return 1;
+        case TrackerEvent::Started:   return 2;
+        case TrackerEvent::Stopped:   return 3;
+        default:                      return 0;
+    }
+}
+
+std::string url_encode_binary(const std::uint8_t* data, std::size_t len) {
+    std::ostringstream o;
+    o.fill('0');
+    o << std::hex;
+    for (std::size_t i = 0; i < len; ++i) {
+        const std::uint8_t c = data[i];
+        if (std::isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') o << char(c);
+        else o << '%' << std::setw(2) << int(c);
+    }
+    return o.str();
+}
+
+std::vector<Address> parse_compact_peers(const std::string& data) {
+    std::vector<Address> peers;
+    for (std::size_t i = 0; i + 6 <= data.size(); i += 6) {
+        const auto* b = reinterpret_cast<const std::uint8_t*>(data.data() + i);
+        std::ostringstream ip;
+        ip << int(b[0]) << '.' << int(b[1]) << '.' << int(b[2]) << '.' << int(b[3]);
+        peers.emplace_back(ip.str(), read_u16_be(b + 4));
+    }
+    return peers;
+}
+
+std::vector<Address> parse_dict_peers(const librats::BencodeValue& list) {
+    std::vector<Address> peers;
+    for (std::size_t i = 0; i < list.size(); ++i) {
+        const auto& d = list[i];
+        if (!d.is_dict() || !d.has_key("ip") || !d.has_key("port")) continue;
+        const std::uint16_t port = std::uint16_t(d["port"].as_integer());
+        if (port == 0) continue;
+        // BEP 3 dictionary model: "ip" may be a dotted-quad, an IPv6 literal, OR a
+        // DNS name. Address is strictly numeric, so a name must be resolved here
+        // (we already run on a blocking announce worker) — feeding it to the numeric
+        // Address ctor would assert in debug and silently drop the peer in release.
+        const std::string& host = d["ip"].as_string();
+        auto ip = IpAddress::parse(host);
+        if (!ip) {
+            std::string resolved = network_utils::resolve_hostname(host);
+            if (resolved.empty()) resolved = network_utils::resolve_hostname_v6(host);
+            ip = IpAddress::parse(resolved);
+        }
+        if (ip) peers.emplace_back(*ip, port);
+    }
+    return peers;
+}
+
+/// Blocking HTTP/1.0 GET; returns the response body (headers stripped).
+Bytes http_get(const std::string& url, int timeout_ms) {
+    const std::size_t scheme = url.find("://");
+    if (scheme == std::string::npos) return {};
+    const std::string proto = url.substr(0, scheme);
+    const std::size_t host_start = scheme + 3;
+    const std::size_t path_start = url.find('/', host_start);
+
+    std::string host_port = url.substr(host_start, path_start == std::string::npos ? std::string::npos
+                                                                                   : path_start - host_start);
+    std::string path = (path_start == std::string::npos) ? "/" : url.substr(path_start);
+
+    std::uint16_t port = (proto == "https") ? 443 : 80;
+    if (const std::size_t colon = host_port.find(':'); colon != std::string::npos) {
+        const std::uint16_t parsed = parse_port(host_port.substr(colon + 1));
+        if (parsed == 0) return {};  // malformed port — fail the announce, never crash
+        port = parsed;
+        host_port = host_port.substr(0, colon);
+    }
+
+    socket_t sock = create_tcp_client(host_port, port, timeout_ms);
+    if (!is_valid_socket(sock)) return {};
+
+    std::ostringstream req;
+    req << "GET " << path << " HTTP/1.0\r\nHost: " << host_port
+        << "\r\nUser-Agent: librats\r\nAccept: */*\r\nConnection: close\r\n\r\n";
+    if (send_tcp_string(sock, req.str()) <= 0) { close_socket(sock); return {}; }
+
+    Bytes data;
+    for (;;) {
+        Bytes chunk = receive_tcp_data(sock, 4096);
+        if (chunk.empty()) break;
+        data.insert(data.end(), chunk.begin(), chunk.end());
+    }
+    close_socket(sock);
+
+    // Strip headers (everything up to and including the blank line).
+    static const std::uint8_t sep[4] = {'\r', '\n', '\r', '\n'};
+    for (std::size_t i = 0; i + 4 <= data.size(); ++i) {
+        if (std::memcmp(data.data() + i, sep, 4) == 0)
+            return Bytes(data.begin() + std::ptrdiff_t(i + 4), data.end());
+    }
+    return {};
+}
+
+// Wait for a UDP datagram for up to @p total_timeout_ms, but in short slices so a
+// pending cancellation (e.g. shutdown) aborts the wait within one slice instead
+// of blocking for the whole timeout against an unresponsive tracker. Returns the
+// datagram, or empty on timeout / cancellation.
+Bytes receive_udp_sliced(socket_t sock, std::size_t maxlen, Address& sender, int total_timeout_ms,
+                         const TrackerCancelPredicate& cancelled) {
+    if (!cancelled) {
+        // No cancellation wanted — one plain blocking wait (fast path).
+        return receive_udp_data(sock, maxlen, sender, total_timeout_ms);
+    }
+    constexpr int kSliceMs = 200;
+    int elapsed = 0;
+    while (elapsed < total_timeout_ms) {
+        if (cancelled()) return {};
+        const int slice = (std::min)(kSliceMs, total_timeout_ms - elapsed);
+        Bytes data = receive_udp_data(sock, maxlen, sender, slice);
+        if (!data.empty()) return data;
+        elapsed += slice;
+    }
+    return {};
+}
+
+TrackerResponse announce_http(const std::string& url, const TrackerRequest& req, int timeout_ms,
+                              const TrackerCancelPredicate& cancelled) {
+    TrackerResponse out;
+    if (cancelled && cancelled()) { out.failure_reason = "cancelled"; return out; }
+    const Bytes body = http_get(tracker_detail::build_http_announce_url(url, req), timeout_ms);
+    if (body.empty()) { out.failure_reason = "no response"; return out; }
+    return tracker_detail::parse_http_response(body);
+}
+
+TrackerResponse announce_udp(const std::string& url, const TrackerRequest& req, int timeout_ms,
+                             const TrackerCancelPredicate& cancelled) {
+    TrackerResponse out;
+    if (cancelled && cancelled()) { out.failure_reason = "cancelled"; return out; }
+
+    // Parse udp://host:port[/...]
+    std::string rest = url.substr(6);
+    if (const std::size_t slash = rest.find('/'); slash != std::string::npos) rest = rest.substr(0, slash);
+    const std::size_t colon = rest.find(':');
+    if (colon == std::string::npos) { out.failure_reason = "bad udp url"; return out; }
+    const std::string host = rest.substr(0, colon);
+    const std::uint16_t port = parse_port(rest.substr(colon + 1));
+    if (port == 0) { out.failure_reason = "bad udp port"; return out; }
+
+    socket_t sock = create_udp_socket(0, "", AddressFamily::IPv4);
+    if (!is_valid_socket(sock)) { out.failure_reason = "socket"; return out; }
+    struct Closer { socket_t s; ~Closer() { if (is_valid_socket(s)) close_socket(s); } } closer{sock};
+
+    // 1) connect
+    const std::uint32_t tid1 = random_u32();
+    Bytes creq(16);
+    write_u64_be(creq.data(), std::uint64_t(kUdpMagic));
+    write_u32_be(creq.data() + 8, kActionConnect);
+    write_u32_be(creq.data() + 12, tid1);
+    if (send_udp_data(sock, creq, host, port, AddressFamily::IPv4) <= 0) { out.failure_reason = "send"; return out; }
+
+    Address sender;
+    Bytes cresp = receive_udp_sliced(sock, 2048, sender, timeout_ms, cancelled);
+    if (cresp.size() < 16 || read_u32_be(cresp.data()) != kActionConnect ||
+        read_u32_be(cresp.data() + 4) != tid1) {
+        out.failure_reason = (cancelled && cancelled()) ? "cancelled" : "connect failed";
+        return out;
+    }
+    const std::uint64_t conn_id = read_u64_be(cresp.data() + 8);
+
+    // 2) announce
+    const std::uint32_t tid2 = random_u32();
+    Bytes areq(98);
+    write_u64_be(areq.data(), conn_id);
+    write_u32_be(areq.data() + 8, kActionAnnounce);
+    write_u32_be(areq.data() + 12, tid2);
+    std::memcpy(areq.data() + 16, req.info_hash.data(), 20);
+    std::memcpy(areq.data() + 36, req.peer_id.data(), 20);
+    write_u64_be(areq.data() + 56, req.downloaded);
+    write_u64_be(areq.data() + 64, req.left);
+    write_u64_be(areq.data() + 72, req.uploaded);
+    write_u32_be(areq.data() + 80, udp_event(req.event));
+    write_u32_be(areq.data() + 84, 0);                       // our IP — let the tracker use the source
+    write_u32_be(areq.data() + 88, random_u32());            // key
+    write_u32_be(areq.data() + 92, std::uint32_t(req.numwant));
+    write_u16_be(areq.data() + 96, req.port);
+    if (send_udp_data(sock, areq, host, port, AddressFamily::IPv4) <= 0) { out.failure_reason = "send"; return out; }
+
+    Bytes resp = receive_udp_sliced(sock, 2048, sender, timeout_ms, cancelled);
+    if (resp.size() < 8) {
+        out.failure_reason = (cancelled && cancelled()) ? "cancelled" : "no response";
+        return out;
+    }
+    const std::uint32_t action = read_u32_be(resp.data());
+    if (action == kActionError) {
+        out.failure_reason.assign(resp.begin() + 8, resp.end());
+        return out;
+    }
+    if (action != kActionAnnounce || read_u32_be(resp.data() + 4) != tid2 || resp.size() < 20) {
+        out.failure_reason = "bad announce response";
+        return out;
+    }
+
+    out.interval   = read_u32_be(resp.data() + 8);
+    out.incomplete = read_u32_be(resp.data() + 12);
+    out.complete   = read_u32_be(resp.data() + 16);
+    for (std::size_t off = 20; off + 6 <= resp.size(); off += 6) {
+        const std::uint8_t* b = resp.data() + off;
+        std::ostringstream ip;
+        ip << int(b[0]) << '.' << int(b[1]) << '.' << int(b[2]) << '.' << int(b[3]);
+        out.peers.emplace_back(ip.str(), read_u16_be(b + 4));
+    }
+    out.success = true;
+    return out;
+}
+
+} // namespace
+
+namespace tracker_detail {
+
+std::string build_http_announce_url(const std::string& base, const TrackerRequest& req) {
+    std::ostringstream u;
+    u << base << (base.find('?') == std::string::npos ? '?' : '&');
+    u << "info_hash=" << url_encode_binary(req.info_hash.data(), req.info_hash.size());
+    u << "&peer_id="  << url_encode_binary(req.peer_id.data(), req.peer_id.size());
+    u << "&port="       << req.port;
+    u << "&uploaded="   << req.uploaded;
+    u << "&downloaded=" << req.downloaded;
+    u << "&left="       << req.left;
+    u << "&numwant="    << req.numwant;
+    u << "&compact=1";
+    if (req.event != TrackerEvent::None) u << "&event=" << http_event(req.event);
+    return u.str();
+}
+
+TrackerResponse parse_http_response(const Bytes& body) {
+    TrackerResponse out;
+    try {
+        librats::BencodeValue d = librats::BencodeDecoder::decode(body.data(), body.size());
+        if (!d.is_dict()) { out.failure_reason = "not a dict"; return out; }
+        if (d.has_key("failure reason")) { out.failure_reason = d["failure reason"].as_string(); return out; }
+        if (d.has_key("interval"))     out.interval     = std::uint32_t(d["interval"].as_integer());
+        if (d.has_key("min interval")) out.min_interval = std::uint32_t(d["min interval"].as_integer());
+        if (d.has_key("complete"))     out.complete     = std::uint32_t(d["complete"].as_integer());
+        if (d.has_key("incomplete"))   out.incomplete   = std::uint32_t(d["incomplete"].as_integer());
+        if (d.has_key("peers")) {
+            const auto& p = d["peers"];
+            if (p.is_string())    out.peers = parse_compact_peers(p.as_string());
+            else if (p.is_list()) out.peers = parse_dict_peers(p);
+        }
+        out.success = true;
+    } catch (const std::exception& e) {
+        out.failure_reason = e.what();
+    }
+    return out;
+}
+
+} // namespace tracker_detail
+
+TrackerResponse announce_to_tracker(const std::string& url, const TrackerRequest& req, int timeout_ms,
+                                    const TrackerCancelPredicate& cancelled) {
+    if (url.rfind("udp://", 0) == 0)  return announce_udp(url, req, timeout_ms, cancelled);
+    // We have no TLS for trackers yet. Skip https:// rather than speaking cleartext
+    // HTTP to port 443 — that never works and would leak info_hash/peer_id in the
+    // clear (H11). Re-enable once a real TLS stream is wired in.
+    if (url.rfind("https://", 0) == 0) {
+        TrackerResponse out; out.failure_reason = "https trackers not supported (no TLS)";
+        return out;
+    }
+    if (url.rfind("http://", 0) == 0) return announce_http(url, req, timeout_ms, cancelled);
+    TrackerResponse out;
+    out.failure_reason = "unsupported tracker scheme";
+    return out;
+}
+
+// ---- TrackerAnnouncer ----
+
+TrackerAnnouncer::TrackerAnnouncer(std::vector<std::string> trackers, Poster poster, int timeout_ms)
+    : trackers_(std::move(trackers)), poster_(std::move(poster)), timeout_ms_(timeout_ms) {}
+
+TrackerAnnouncer::~TrackerAnnouncer() { stop(); }
+
+void TrackerAnnouncer::announce(const TrackerRequest& req, PeerCallback on_peers) {
+    for (const std::string& url : trackers_) {
+        {
+            std::lock_guard<std::mutex> lk(mutex_);
+            if (stopping_) return;
+            ++inflight_;
+        }
+        std::thread([this, url, req, on_peers] {
+            TrackerResponse resp = announce_to_tracker(url, req, timeout_ms_);
+            if (resp.success)
+                LOG_DEBUG("bt.tracker", "← " << url << ": " << resp.peers.size() << " peers, interval "
+                                        << resp.interval << "s");
+            else
+                LOG_DEBUG("bt.tracker", "✗ " << url << ": " << resp.failure_reason);
+            {
+                std::lock_guard<std::mutex> lk(mutex_);
+                if (!stopping_ && resp.success && poster_) {
+                    // Honour the tracker's requested re-announce cadence (clamped to a
+                    // sane 1 min..1 h) so we don't get rate-limited/banned (H13).
+                    std::uint32_t interval = (std::max)(resp.interval, resp.min_interval);
+                    if (interval == 0) interval = 1800;
+                    interval = std::min<std::uint32_t>(std::max<std::uint32_t>(interval, 60), 3600);
+                    poster_([on_peers, peers = resp.peers, interval] { on_peers(peers, interval); });
+                }
+                --inflight_;
+                // Notify while still holding the lock: once inflight_ hits zero a waiting
+                // stop() may return and the announcer be destroyed, taking drain_cv_ with it.
+                drain_cv_.notify_all();
+            }
+        }).detach();
+    }
+}
+
+void TrackerAnnouncer::stop() {
+    std::unique_lock<std::mutex> lk(mutex_);
+    stopping_ = true;
+    drain_cv_.wait(lk, [this] { return inflight_ == 0; });
+}
+
+} // namespace librats::bittorrent

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

@@ -0,0 +1,108 @@
+#pragma once
+
+/**
+ * @file tracker.h
+ * @brief Tracker announces (BEP 3 over HTTP, BEP 15 over UDP) and the per-torrent
+ *        announcer that drives them.
+ *
+ * A tracker is a directory: you periodically POST your progress and it hands back
+ * a list of peers. The wire work is blocking (a short HTTP request or a two-step
+ * UDP connect→announce), so announce_to_tracker() is a self-contained blocking
+ * call with no shared state — easy to test and safe to run off-thread.
+ *
+ * TrackerAnnouncer is what a Torrent owns: it fires announces to every tracker on
+ * background threads and delivers discovered peers back through a poster (onto the
+ * reactor), exactly like the disk subsystem. stop() joins any in-flight announce
+ * so a torrent never tears down underneath one.
+ */
+
+#include "librats/bittorrent/types.h"
+#include "librats/core/address.h"
+#include "librats/core/bytes.h"
+
+#include <condition_variable>
+#include <cstdint>
+#include <functional>
+#include <mutex>
+#include <string>
+#include <vector>
+
+namespace librats::bittorrent {
+
+enum class TrackerEvent { None, Started, Stopped, Completed };
+
+struct TrackerRequest {
+    InfoHash      info_hash{};
+    PeerId        peer_id{};
+    std::uint16_t port       = 0;
+    std::uint64_t uploaded   = 0;
+    std::uint64_t downloaded = 0;
+    std::uint64_t left       = 0;
+    TrackerEvent  event      = TrackerEvent::None;
+    int           numwant    = 50;
+};
+
+struct TrackerResponse {
+    bool                 success    = false;
+    std::string          failure_reason;
+    std::uint32_t        interval   = 1800;  ///< seconds until the next announce
+    std::uint32_t        min_interval = 0;
+    std::uint32_t        complete   = 0;     ///< seeders
+    std::uint32_t        incomplete = 0;     ///< leechers
+    std::vector<Address> peers;
+};
+
+/// Polled by the blocking announce so a caller can abort it early (e.g. on
+/// shutdown): when it returns true the announce bails within ~one poll slice
+/// instead of blocking for the full timeout. An empty predicate never cancels.
+using TrackerCancelPredicate = std::function<bool()>;
+
+/// Perform one blocking announce to @p url (http/https/udp). Self-contained: it
+/// opens, uses and closes its own socket and shares no state with anything.
+/// @p cancelled, if set, is polled during the wait so the call can be aborted
+/// promptly (the blocking receive is done in short slices between polls).
+TrackerResponse announce_to_tracker(const std::string& url, const TrackerRequest& req,
+                                    int timeout_ms = 10000,
+                                    const TrackerCancelPredicate& cancelled = {});
+
+/// Drives announces to a torrent's trackers from background threads, delivering
+/// peers via a poster (the reactor). Owned by one Torrent.
+class TrackerAnnouncer {
+public:
+    using Poster       = std::function<void(std::function<void()>)>;
+    /// Delivers a tracker's response: discovered peers and the interval (seconds)
+    /// the tracker wants before the next announce (already max'd with min-interval).
+    using PeerCallback = std::function<void(const std::vector<Address>& peers, std::uint32_t interval)>;
+
+    TrackerAnnouncer(std::vector<std::string> trackers, Poster poster, int timeout_ms = 10000);
+    ~TrackerAnnouncer();
+
+    TrackerAnnouncer(const TrackerAnnouncer&) = delete;
+    TrackerAnnouncer& operator=(const TrackerAnnouncer&) = delete;
+
+    /// Announce to every tracker (each on its own worker thread); @p on_peers is
+    /// posted onto the reactor for each tracker that returns peers.
+    void announce(const TrackerRequest& req, PeerCallback on_peers);
+    /// Wait for any in-flight announce to finish. Idempotent; called by the dtor.
+    void stop();
+
+    std::size_t tracker_count() const noexcept { return trackers_.size(); }
+
+private:
+    std::vector<std::string> trackers_;
+    Poster                   poster_;
+    int                      timeout_ms_;
+
+    std::mutex               mutex_;
+    std::condition_variable  drain_cv_;
+    int                      inflight_ = 0;
+    bool                     stopping_ = false;
+};
+
+// Exposed for unit testing the HTTP wire format without a live tracker.
+namespace tracker_detail {
+std::string     build_http_announce_url(const std::string& base, const TrackerRequest& req);
+TrackerResponse parse_http_response(const Bytes& body);
+} // namespace tracker_detail
+
+} // namespace librats::bittorrent