librats 1.0.2 → 2.1.4

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

@@ -0,0 +1,77 @@
+#include "librats/bittorrent/file_storage.h"
+#include "librats/bittorrent/types.h"  // kBlockSize
+
+#include <algorithm>
+#include <limits>
+
+namespace librats::bittorrent {
+
+bool FileStorage::add_file(std::string path, std::int64_t size) {
+    // Reject a negative size or a running total that would overflow int64: a
+    // hostile .torrent could otherwise trigger signed-overflow UB here and a
+    // garbage num_pieces() downstream. Leave the layout untouched so the caller
+    // can bail cleanly.
+    if (size < 0 || size > std::numeric_limits<std::int64_t>::max() - total_size_)
+        return false;
+    files_.push_back(FileEntry{std::move(path), size, total_size_});
+    total_size_ += size;
+    return true;
+}
+
+void FileStorage::clear() {
+    files_.clear();
+    name_.clear();
+    piece_length_ = 0;
+    total_size_   = 0;
+}
+
+std::uint32_t FileStorage::num_pieces() const noexcept {
+    if (piece_length_ == 0) return 0;
+    return std::uint32_t((total_size_ + piece_length_ - 1) / piece_length_);
+}
+
+std::uint32_t FileStorage::piece_size(std::uint32_t piece) const noexcept {
+    const std::uint32_t n = num_pieces();
+    if (piece + 1 < n) return piece_length_;
+    // Final piece: the remainder. (Also the only piece for tiny torrents.)
+    const std::int64_t tail = total_size_ - std::int64_t(piece) * piece_length_;
+    if (tail <= 0) return 0;
+    return std::uint32_t(std::min<std::int64_t>(tail, piece_length_));
+}
+
+std::uint32_t FileStorage::blocks_in_piece(std::uint32_t piece) const noexcept {
+    const std::uint32_t ps = piece_size(piece);
+    return (ps + kBlockSize - 1) / kBlockSize;
+}
+
+std::vector<FileSlice> FileStorage::map_block(std::uint32_t piece, std::uint32_t offset,
+                                              std::int64_t size) const {
+    std::vector<FileSlice> slices;
+    if (size <= 0 || files_.empty()) return slices;
+
+    std::int64_t abs = std::int64_t(piece) * piece_length_ + offset;
+    if (abs >= total_size_) return slices;
+    std::int64_t remaining = (std::min)(size, total_size_ - abs);  // clamp to payload
+
+    // Binary search: the file containing `abs` is the last one whose offset <= abs.
+    // (Zero-length files share an offset with the following file; picking the last
+    // such index lands on the real, non-empty file, and the loop skips empties.)
+    std::size_t f = std::size_t(
+        std::upper_bound(files_.begin(), files_.end(), abs,
+                         [](std::int64_t a, const FileEntry& e) { return a < e.offset; })
+        - files_.begin());
+    if (f > 0) --f;
+
+    while (remaining > 0 && f < files_.size()) {
+        const std::int64_t file_off = abs - files_[f].offset;
+        if (file_off >= files_[f].size) { ++f; continue; }  // empty / already past this file
+        const std::int64_t take = (std::min)(remaining, files_[f].size - file_off);
+        slices.push_back(FileSlice{f, file_off, take});
+        remaining -= take;
+        abs       += take;
+        ++f;
+    }
+    return slices;
+}
+
+} // namespace librats::bittorrent

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

@@ -0,0 +1,79 @@
+#pragma once
+
+/**
+ * @file file_storage.h
+ * @brief The file layout of a torrent and the piece <-> file mapping.
+ *
+ * A torrent's payload is one contiguous byte space: files are laid end-to-end
+ * in order, each at a running @c offset. Pieces are fixed-size windows over that
+ * space (the final piece is short). FileStorage answers the two questions the
+ * disk and wire layers need: "how big is piece i?" and "which file regions does
+ * a (piece, offset, length) range touch?". The latter (map_block) is O(log n)
+ * via a binary search over the sorted file offsets.
+ */
+
+#include "librats/util/rats_export.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace librats::bittorrent {
+
+/// One file in the torrent. @c path is the full relative path including the
+/// torrent name as its first component (so the disk layer just joins it onto
+/// the save path). @c offset is the file's start in the torrent byte space.
+struct FileEntry {
+    std::string  path;
+    std::int64_t size   = 0;
+    std::int64_t offset = 0;
+};
+
+/// A contiguous region of a single file — one fragment of a mapped block.
+struct FileSlice {
+    std::size_t  file_index = 0;
+    std::int64_t offset     = 0;  ///< byte offset within the file
+    std::int64_t size       = 0;
+};
+
+class RATS_API FileStorage {
+public:
+    void set_piece_length(std::uint32_t length) noexcept { piece_length_ = length; }
+    void set_name(std::string name) { name_ = std::move(name); }
+    /// Append a file (its offset is computed from the running total). Returns
+    /// false and leaves the layout unchanged if @p size is negative or would
+    /// overflow the int64 running total — a hostile .torrent must be rejected
+    /// rather than driving signed-overflow UB and a garbage num_pieces().
+    bool add_file(std::string path, std::int64_t size);
+    void clear();
+
+    const std::string&            name()         const noexcept { return name_; }
+    std::uint32_t                 piece_length() const noexcept { return piece_length_; }
+    std::int64_t                  total_size()   const noexcept { return total_size_; }
+    std::size_t                   num_files()    const noexcept { return files_.size(); }
+    const FileEntry&              file_at(std::size_t i) const { return files_[i]; }
+    const std::vector<FileEntry>& files()        const noexcept { return files_; }
+
+    /// A layout is usable once it has a piece length and at least one file.
+    bool is_valid() const noexcept { return piece_length_ > 0 && !files_.empty(); }
+
+    std::uint32_t num_pieces() const noexcept;
+    /// Size of piece @p piece — piece_length except a possibly-short final piece.
+    std::uint32_t piece_size(std::uint32_t piece) const noexcept;
+    /// Number of 16 KiB blocks in piece @p piece (the last block may be short).
+    std::uint32_t blocks_in_piece(std::uint32_t piece) const noexcept;
+
+    /// Map a byte range within a piece to the file regions it covers. The range
+    /// is clamped to the torrent's total size; zero-length files are skipped.
+    std::vector<FileSlice> map_block(std::uint32_t piece, std::uint32_t offset,
+                                     std::int64_t size) const;
+
+private:
+    std::vector<FileEntry> files_;
+    std::string            name_;
+    std::uint32_t          piece_length_ = 0;
+    std::int64_t           total_size_   = 0;
+};
+
+} // namespace librats::bittorrent

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

@@ -0,0 +1,42 @@
+#pragma once
+
+/**
+ * @file log.h
+ * @brief Small logging helpers shared across the BitTorrent modules.
+ *
+ * Formatting sugar on top of util/logger.h — nothing more. BitTorrent logs under a
+ * set of dot-namespaced tags so each component gets its own stable colour and is
+ * easy to grep (mirrors the dht.* scheme):
+ *
+ *   "bt.client"  — the session: listener, accept/dial, add/remove torrent
+ *   "bt.torrent" — one torrent's lifecycle: state transitions, pieces, choking
+ *   "bt.peer"    — a peer link: handshake and disconnect (with reason)
+ *   "bt.tracker" — per-tracker HTTP/UDP announce results
+ *   "bt.meta"    — magnet metadata fetch (BEP 9)
+ *   "bt.disk"    — disk I/O failures
+ *   "bt.picker"  — piece selection (end-game entry)
+ *   "bt.node"    — the Node subsystem wrapper
+ *
+ * Conventions: an info-hash renders via short_hash() (8 leading hex, like a git
+ * short hash); a peer renders as "ip:port". Direction/outcome use glyphs —
+ * → outgoing, ← incoming, ✓ success, ✗ failure — matching the DHT logs.
+ */
+
+#include "librats/bittorrent/types.h"
+#include "librats/util/logger.h"
+
+#include <cstddef>
+#include <string>
+
+namespace librats::bittorrent {
+
+/// Compact, log-friendly rendering of a 20-byte info-hash: its leading `chars`
+/// hex digits (default 8, like a git short hash). The full 40-char id is
+/// unreadable in a log line and its prefix is more than enough to follow one
+/// torrent across lines. Use to_hex(id) only where the complete id matters.
+inline std::string short_hash(const InfoHash& id, std::size_t chars = 8) {
+    const std::string full = to_hex(id);
+    return chars >= full.size() ? full : full.substr(0, chars);
+}
+
+} // namespace librats::bittorrent

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

@@ -0,0 +1,98 @@
+#include "librats/bittorrent/magnet_uri.h"
+
+#include <algorithm>
+#include <cctype>
+
+namespace librats::bittorrent {
+
+namespace {
+
+/// Percent-decode a URL component (leaves '+' as a literal, as magnet links do).
+std::string url_decode(const std::string& s) {
+    std::string out;
+    out.reserve(s.size());
+    for (std::size_t i = 0; i < s.size(); ++i) {
+        if (s[i] == '%' && i + 2 < s.size()) {
+            auto hex = [](char c) -> int {
+                if (c >= '0' && c <= '9') return c - '0';
+                if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+                if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+                return -1;
+            };
+            const int hi = hex(s[i + 1]), lo = hex(s[i + 2]);
+            if (hi >= 0 && lo >= 0) { out.push_back(char(hi << 4 | lo)); i += 2; continue; }
+        }
+        out.push_back(s[i]);
+    }
+    return out;
+}
+
+/// Decode a 32-character RFC 4648 base32 string into a 20-byte info-hash.
+std::optional<InfoHash> base32_to_info_hash(const std::string& in) {
+    if (in.size() != 32) return std::nullopt;
+    auto value = [](char c) -> int {
+        c = char(std::toupper(static_cast<unsigned char>(c)));
+        if (c >= 'A' && c <= 'Z') return c - 'A';
+        if (c >= '2' && c <= '7') return c - '2' + 26;
+        return -1;
+    };
+    InfoHash out{};
+    std::uint32_t bits = 0;
+    int bit_count = 0;
+    std::size_t byte = 0;
+    for (char c : in) {
+        const int v = value(c);
+        if (v < 0) return std::nullopt;
+        bits = bits << 5 | std::uint32_t(v);
+        bit_count += 5;
+        if (bit_count >= 8) {
+            bit_count -= 8;
+            out[byte++] = std::uint8_t(bits >> bit_count);
+        }
+    }
+    return out;  // 32 * 5 = 160 bits = exactly 20 bytes
+}
+
+} // namespace
+
+std::optional<MagnetUri> MagnetUri::parse(const std::string& uri) {
+    constexpr char kPrefix[] = "magnet:?";
+    if (uri.rfind(kPrefix, 0) != 0) return std::nullopt;
+
+    MagnetUri result;
+    const std::string query = uri.substr(sizeof(kPrefix) - 1);
+
+    std::size_t pos = 0;
+    while (pos < query.size()) {
+        std::size_t amp = query.find('&', pos);
+        if (amp == std::string::npos) amp = query.size();
+        const std::string token = query.substr(pos, amp - pos);
+        pos = amp + 1;
+
+        const std::size_t eq = token.find('=');
+        if (eq == std::string::npos) continue;
+        const std::string key = token.substr(0, eq);
+        const std::string val = url_decode(token.substr(eq + 1));
+
+        if (key == "xt") {
+            constexpr char kBtih[] = "urn:btih:";
+            if (val.rfind(kBtih, 0) == 0) {
+                const std::string id = val.substr(sizeof(kBtih) - 1);
+                if (auto h = info_hash_from_hex(id)) result.info_hash = *h;
+                else if (auto b = base32_to_info_hash(id)) result.info_hash = *b;
+            }
+            // urn:btmh: (v2) intentionally ignored for now.
+        } else if (key == "dn") {
+            result.display_name = val;
+        } else if (key == "tr") {
+            if (!val.empty()) result.trackers.push_back(val);
+        } else if (key == "ws") {
+            if (!val.empty()) result.web_seeds.push_back(val);
+        }
+    }
+
+    if (!result.is_valid()) return std::nullopt;
+    return result;
+}
+
+} // namespace librats::bittorrent

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

@@ -0,0 +1,35 @@
+#pragma once
+
+/**
+ * @file magnet_uri.h
+ * @brief Parsing of magnet links (BEP 9 / BEP 53 subset).
+ *
+ * A magnet link carries an info-hash (and optionally a name, trackers and web
+ * seeds) but no metadata — the file list and piece hashes must still be fetched
+ * from peers via ut_metadata. We accept the v1 `xt=urn:btih:` form with either a
+ * 40-char hex or a 32-char base32 SHA-1.
+ */
+
+#include "librats/util/rats_export.h"
+#include "librats/bittorrent/types.h"
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace librats::bittorrent {
+
+struct RATS_API MagnetUri {
+    InfoHash                 info_hash{};
+    std::string              display_name;   ///< dn
+    std::vector<std::string> trackers;       ///< tr
+    std::vector<std::string> web_seeds;      ///< ws
+
+    bool is_valid() const noexcept { return !is_all_zero(info_hash); }
+
+    /// Parse a "magnet:?…" URI. nullopt if it is not a magnet link or carries no
+    /// valid v1 info-hash.
+    static std::optional<MagnetUri> parse(const std::string& uri);
+};
+
+} // namespace librats::bittorrent