librats 1.0.2 → 2.2.0

package/native-src/src/bt_file_storage.h

@@ -1,298 +0,0 @@
-#pragma once
-
-/**
- * @file bt_file_storage.h
- * @brief File storage layout for BitTorrent torrents
- * 
- * Handles mapping between pieces/blocks and files in a torrent.
- * Supports both single-file and multi-file torrents.
- */
-
-#include <string>
-#include <vector>
-#include <cstdint>
-
-namespace librats {
-
-/**
- * @brief Information about a single file in the torrent
- */
-struct FileEntry {
-    std::string path;           ///< Relative path of the file
-    int64_t size;               ///< Size in bytes
-    int64_t offset;             ///< Offset from start of torrent data
-    bool pad_file;              ///< True if this is a padding file (not real data)
-    bool executable;            ///< Executable attribute (Unix)
-    bool hidden;                ///< Hidden attribute (Windows)
-    
-    FileEntry() 
-        : size(0), offset(0), pad_file(false), executable(false), hidden(false) {}
-    
-    FileEntry(const std::string& p, int64_t s, int64_t off = 0)
-        : path(p), size(s), offset(off), pad_file(false), executable(false), hidden(false) {}
-};
-
-/**
- * @brief A slice of a file that corresponds to part of a piece
- */
-struct FileSlice {
-    size_t file_index;          ///< Index of the file in FileStorage
-    int64_t offset;             ///< Offset within the file
-    int64_t size;               ///< Number of bytes in this slice
-    
-    FileSlice() : file_index(0), offset(0), size(0) {}
-    FileSlice(size_t idx, int64_t off, int64_t sz) 
-        : file_index(idx), offset(off), size(sz) {}
-};
-
-/**
- * @brief Result of mapping a file position to piece/block
- */
-struct PiecePosition {
-    uint32_t piece;             ///< Piece index
-    uint32_t offset;            ///< Offset within piece
-    uint32_t length;            ///< Length of data
-    
-    PiecePosition() : piece(0), offset(0), length(0) {}
-    PiecePosition(uint32_t p, uint32_t off, uint32_t len)
-        : piece(p), offset(off), length(len) {}
-};
-
-/**
- * @brief Manages file layout and piece-to-file mapping for a torrent
- * 
- * This class stores information about all files in a torrent and provides
- * efficient mapping between:
- * - Piece/block positions and file positions
- * - File positions and piece positions
- * 
- * Thread-safe for read operations after construction.
- */
-class FileStorage {
-public:
-    /**
-     * @brief Default constructor - creates empty storage
-     */
-    FileStorage();
-    
-    /**
-     * @brief Constructor with piece length
-     * @param piece_length Length of each piece in bytes
-     */
-    explicit FileStorage(uint32_t piece_length);
-    
-    /**
-     * @brief Copy constructor
-     */
-    FileStorage(const FileStorage& other) = default;
-    
-    /**
-     * @brief Move constructor
-     */
-    FileStorage(FileStorage&& other) noexcept = default;
-    
-    /**
-     * @brief Copy assignment
-     */
-    FileStorage& operator=(const FileStorage& other) = default;
-    
-    /**
-     * @brief Move assignment
-     */
-    FileStorage& operator=(FileStorage&& other) noexcept = default;
-    
-    //=========================================================================
-    // File Management
-    //=========================================================================
-    
-    /**
-     * @brief Add a file to the storage
-     * 
-     * Files are added in order and their offsets are computed automatically.
-     * 
-     * @param path Relative path of the file
-     * @param size Size of the file in bytes
-     * @param pad_file True if this is a padding file
-     * @param executable True if file has executable attribute
-     * @param hidden True if file has hidden attribute
-     */
-    void add_file(const std::string& path, int64_t size, 
-                  bool pad_file = false, bool executable = false, bool hidden = false);
-    
-    /**
-     * @brief Add a FileEntry directly
-     * @param entry File entry to add (offset will be computed)
-     */
-    void add_file(const FileEntry& entry);
-    
-    /**
-     * @brief Reserve space for files (optimization)
-     * @param num_files Expected number of files
-     */
-    void reserve(size_t num_files);
-    
-    /**
-     * @brief Set the piece length
-     * @param length Piece length in bytes
-     */
-    void set_piece_length(uint32_t length);
-    
-    /**
-     * @brief Finalize the storage after all files are added
-     * 
-     * Computes the total number of pieces based on total size and piece length.
-     * Must be called before using mapping functions.
-     */
-    void finalize();
-    
-    //=========================================================================
-    // Accessors
-    //=========================================================================
-    
-    /**
-     * @brief Get number of files
-     */
-    size_t num_files() const { return files_.size(); }
-    
-    /**
-     * @brief Get total size of all files
-     */
-    int64_t total_size() const { return total_size_; }
-    
-    /**
-     * @brief Get piece length
-     */
-    uint32_t piece_length() const { return piece_length_; }
-    
-    /**
-     * @brief Get total number of pieces
-     */
-    uint32_t num_pieces() const { return num_pieces_; }
-    
-    /**
-     * @brief Get size of a specific piece
-     * 
-     * All pieces have the same size except possibly the last one.
-     * 
-     * @param piece_index Index of the piece
-     * @return Size of the piece in bytes
-     */
-    uint32_t piece_size(uint32_t piece_index) const;
-    
-    /**
-     * @brief Get file entry by index
-     * @param index File index
-     * @return Reference to file entry
-     */
-    const FileEntry& file_at(size_t index) const { return files_[index]; }
-    
-    /**
-     * @brief Get all file entries
-     */
-    const std::vector<FileEntry>& files() const { return files_; }
-    
-    /**
-     * @brief Check if storage is empty
-     */
-    bool empty() const { return files_.empty(); }
-    
-    /**
-     * @brief Check if storage is finalized
-     */
-    bool is_finalized() const { return finalized_; }
-    
-    //=========================================================================
-    // Piece-to-File Mapping
-    //=========================================================================
-    
-    /**
-     * @brief Map a piece/block to file slices
-     * 
-     * Given a piece index, offset within piece, and size, returns the list
-     * of file slices that need to be read/written.
-     * 
-     * @param piece Piece index
-     * @param offset Offset within the piece
-     * @param size Number of bytes
-     * @return Vector of file slices
-     */
-    std::vector<FileSlice> map_block(uint32_t piece, uint32_t offset, uint32_t size) const;
-    
-    /**
-     * @brief Find which file contains a given byte offset
-     * @param torrent_offset Absolute offset from start of torrent data
-     * @return File index, or num_files() if offset is out of range
-     */
-    size_t file_at_offset(int64_t torrent_offset) const;
-    
-    /**
-     * @brief Get the file index at a given piece
-     * @param piece Piece index
-     * @return File index of the first file that starts in or spans this piece
-     */
-    size_t file_at_piece(uint32_t piece) const;
-    
-    //=========================================================================
-    // File-to-Piece Mapping
-    //=========================================================================
-    
-    /**
-     * @brief Map a file position to piece position
-     * 
-     * @param file_index Index of the file
-     * @param file_offset Offset within the file
-     * @param size Number of bytes
-     * @return Piece position
-     */
-    PiecePosition map_file(size_t file_index, int64_t file_offset, uint32_t size) const;
-    
-    /**
-     * @brief Get the first piece that contains data from a file
-     * @param file_index File index
-     * @return First piece index
-     */
-    uint32_t file_first_piece(size_t file_index) const;
-    
-    /**
-     * @brief Get the last piece that contains data from a file
-     * @param file_index File index
-     * @return Last piece index
-     */
-    uint32_t file_last_piece(size_t file_index) const;
-    
-    /**
-     * @brief Get number of pieces a file spans
-     * @param file_index File index
-     * @return Number of pieces
-     */
-    uint32_t file_num_pieces(size_t file_index) const;
-    
-    //=========================================================================
-    // Torrent Name
-    //=========================================================================
-    
-    /**
-     * @brief Set the torrent name (root directory for multi-file)
-     */
-    void set_name(const std::string& name) { name_ = name; }
-    
-    /**
-     * @brief Get the torrent name
-     */
-    const std::string& name() const { return name_; }
-    
-private:
-    std::vector<FileEntry> files_;
-    std::string name_;
-    int64_t total_size_;
-    uint32_t piece_length_;
-    uint32_t num_pieces_;
-    bool finalized_;
-    
-    /**
-     * @brief Binary search to find file at offset (helper)
-     */
-    size_t find_file_at_offset(int64_t offset) const;
-};
-
-} // namespace librats

package/native-src/src/bt_handshake.cpp

@@ -1,134 +0,0 @@
-#include "bt_handshake.h"
-#include <cstring>
-
-namespace librats {
-
-//=============================================================================
-// ExtensionFlags
-//=============================================================================
-
-std::array<uint8_t, 8> ExtensionFlags::to_reserved() const {
-    std::array<uint8_t, 8> reserved{};
-    
-    // BEP 10: Extension protocol - reserved[5] bit 4
-    if (extension_protocol) {
-        reserved[5] |= 0x10;
-    }
-    
-    // BEP 5: DHT - reserved[7] bit 0
-    if (dht) {
-        reserved[7] |= 0x01;
-    }
-    
-    // BEP 6: Fast extension - reserved[7] bit 2
-    if (fast) {
-        reserved[7] |= 0x04;
-    }
-    
-    return reserved;
-}
-
-ExtensionFlags ExtensionFlags::from_reserved(const uint8_t* reserved) {
-    ExtensionFlags flags;
-    
-    // BEP 10: Extension protocol - reserved[5] bit 4
-    flags.extension_protocol = (reserved[5] & 0x10) != 0;
-    
-    // BEP 5: DHT - reserved[7] bit 0
-    flags.dht = (reserved[7] & 0x01) != 0;
-    
-    // BEP 6: Fast extension - reserved[7] bit 2
-    flags.fast = (reserved[7] & 0x04) != 0;
-    
-    return flags;
-}
-
-//=============================================================================
-// BtHandshake
-//=============================================================================
-
-std::vector<uint8_t> BtHandshake::encode(const BtInfoHash& info_hash,
-                                          const PeerID& peer_id,
-                                          const ExtensionFlags& extensions) {
-    std::vector<uint8_t> handshake;
-    handshake.reserve(BT_HANDSHAKE_SIZE);
-    
-    // Protocol string length (1 byte)
-    handshake.push_back(static_cast<uint8_t>(BT_PROTOCOL_STRING_LEN));
-    
-    // Protocol string (19 bytes)
-    handshake.insert(handshake.end(), 
-                     BT_PROTOCOL_STRING, 
-                     BT_PROTOCOL_STRING + BT_PROTOCOL_STRING_LEN);
-    
-    // Reserved bytes (8 bytes)
-    auto reserved = extensions.to_reserved();
-    handshake.insert(handshake.end(), reserved.begin(), reserved.end());
-    
-    // Info hash (20 bytes)
-    handshake.insert(handshake.end(), info_hash.begin(), info_hash.end());
-    
-    // Peer ID (20 bytes)
-    handshake.insert(handshake.end(), peer_id.begin(), peer_id.end());
-    
-    return handshake;
-}
-
-std::vector<uint8_t> BtHandshake::encode_with_extensions(const BtInfoHash& info_hash,
-                                                          const PeerID& peer_id) {
-    ExtensionFlags flags;
-    flags.enable_all();
-    return encode(info_hash, peer_id, flags);
-}
-
-bool BtHandshake::is_complete(const uint8_t* data, size_t length) {
-    return length >= BT_HANDSHAKE_SIZE;
-}
-
-std::optional<Handshake> BtHandshake::decode(const uint8_t* data, size_t length) {
-    if (length < BT_HANDSHAKE_SIZE) {
-        return std::nullopt;
-    }
-    
-    // Validate protocol string length
-    if (data[0] != BT_PROTOCOL_STRING_LEN) {
-        return std::nullopt;
-    }
-    
-    // Validate protocol string
-    if (std::memcmp(data + 1, BT_PROTOCOL_STRING, BT_PROTOCOL_STRING_LEN) != 0) {
-        return std::nullopt;
-    }
-    
-    Handshake hs;
-    
-    // Parse reserved bytes (offset 20)
-    std::memcpy(hs.reserved.data(), data + 20, 8);
-    hs.extensions = ExtensionFlags::from_reserved(data + 20);
-    
-    // Parse info hash (offset 28)
-    std::memcpy(hs.info_hash.data(), data + 28, BT_INFO_HASH_SIZE);
-    
-    // Parse peer ID (offset 48)
-    std::memcpy(hs.peer_id.data(), data + 48, BT_PEER_ID_SIZE);
-    
-    return hs;
-}
-
-std::optional<Handshake> BtHandshake::decode(const std::vector<uint8_t>& data) {
-    return decode(data.data(), data.size());
-}
-
-bool BtHandshake::validate_protocol(const uint8_t* data, size_t length) {
-    if (length < 20) {
-        return false;
-    }
-    
-    if (data[0] != BT_PROTOCOL_STRING_LEN) {
-        return false;
-    }
-    
-    return std::memcmp(data + 1, BT_PROTOCOL_STRING, BT_PROTOCOL_STRING_LEN) == 0;
-}
-
-} // namespace librats

package/native-src/src/bt_handshake.h

@@ -1,157 +0,0 @@
-#pragma once
-
-/**
- * @file bt_handshake.h
- * @brief BitTorrent handshake handling
- * 
- * Implements the BitTorrent handshake protocol:
- * <pstrlen><pstr><reserved><info_hash><peer_id>
- * 
- * Where:
- * - pstrlen: 1 byte, length of pstr (19 for "BitTorrent protocol")
- * - pstr: 19 bytes, protocol string
- * - reserved: 8 bytes, extension flags
- * - info_hash: 20 bytes, SHA-1 hash of the info dictionary
- * - peer_id: 20 bytes, unique client identifier
- */
-
-#include "bt_types.h"
-
-#include <vector>
-#include <cstdint>
-#include <optional>
-#include <array>
-
-namespace librats {
-
-//=============================================================================
-// Extension Flags
-//=============================================================================
-
-/**
- * @brief Extension flags in reserved bytes
- */
-struct ExtensionFlags {
-    bool dht;               ///< BEP 5: DHT support (reserved[7] & 0x01)
-    bool fast;              ///< BEP 6: Fast extension (reserved[7] & 0x04)
-    bool extension_protocol;///< BEP 10: Extension protocol (reserved[5] & 0x10)
-    
-    ExtensionFlags() : dht(false), fast(false), extension_protocol(false) {}
-    
-    /**
-     * @brief Set all standard extensions
-     */
-    void enable_all() {
-        dht = true;
-        fast = true;
-        extension_protocol = true;
-    }
-    
-    /**
-     * @brief Convert to 8-byte reserved field
-     */
-    std::array<uint8_t, 8> to_reserved() const;
-    
-    /**
-     * @brief Parse from 8-byte reserved field
-     */
-    static ExtensionFlags from_reserved(const uint8_t* reserved);
-};
-
-//=============================================================================
-// Handshake Data
-//=============================================================================
-
-/**
- * @brief Parsed handshake data
- */
-struct Handshake {
-    BtInfoHash info_hash;           ///< 20-byte info hash
-    PeerID peer_id;                 ///< 20-byte peer ID
-    ExtensionFlags extensions;      ///< Parsed extension flags
-    std::array<uint8_t, 8> reserved;///< Raw reserved bytes
-    
-    Handshake() : info_hash{}, peer_id{}, reserved{} {}
-    
-    /**
-     * @brief Check if handshake is valid
-     */
-    bool is_valid() const { return !is_zero_hash(info_hash); }
-    
-    /**
-     * @brief Get peer ID as string
-     */
-    std::string peer_id_string() const { return peer_id_to_string(peer_id); }
-    
-    /**
-     * @brief Get info hash as hex string
-     */
-    std::string info_hash_hex() const { return info_hash_to_hex(info_hash); }
-};
-
-//=============================================================================
-// Handshake Encoder/Decoder
-//=============================================================================
-
-/**
- * @brief Encode and decode BitTorrent handshakes
- */
-class BtHandshake {
-public:
-    /**
-     * @brief Create a handshake message
-     * 
-     * @param info_hash 20-byte info hash
-     * @param peer_id 20-byte peer ID
-     * @param extensions Extension flags to advertise
-     * @return 68-byte handshake message
-     */
-    static std::vector<uint8_t> encode(const BtInfoHash& info_hash,
-                                        const PeerID& peer_id,
-                                        const ExtensionFlags& extensions = ExtensionFlags());
-    
-    /**
-     * @brief Create a handshake message with all extensions enabled
-     */
-    static std::vector<uint8_t> encode_with_extensions(const BtInfoHash& info_hash,
-                                                        const PeerID& peer_id);
-    
-    /**
-     * @brief Check if buffer contains a complete handshake
-     * 
-     * @param data Buffer data
-     * @param length Buffer length
-     * @return true if at least 68 bytes available
-     */
-    static bool is_complete(const uint8_t* data, size_t length);
-    
-    /**
-     * @brief Decode a handshake message
-     * 
-     * @param data Buffer data (at least 68 bytes)
-     * @param length Buffer length
-     * @return Decoded handshake, or nullopt on error
-     */
-    static std::optional<Handshake> decode(const uint8_t* data, size_t length);
-    
-    /**
-     * @brief Decode from vector
-     */
-    static std::optional<Handshake> decode(const std::vector<uint8_t>& data);
-    
-    /**
-     * @brief Validate handshake protocol string
-     * 
-     * @param data Buffer data
-     * @param length Buffer length  
-     * @return true if starts with valid protocol string
-     */
-    static bool validate_protocol(const uint8_t* data, size_t length);
-    
-    /**
-     * @brief Get size of handshake in bytes
-     */
-    static constexpr size_t size() { return BT_HANDSHAKE_SIZE; }
-};
-
-} // namespace librats