librats 1.0.2 → 2.2.0

package/native-src/src/bt_messages.cpp

@@ -1,364 +0,0 @@
-#include "bt_messages.h"
-#include <cstring>
-
-namespace librats {
-
-//=============================================================================
-// Helpers
-//=============================================================================
-
-const char* message_type_to_string(BtMessageType type) {
-    switch (type) {
-        case BtMessageType::Choke: return "Choke";
-        case BtMessageType::Unchoke: return "Unchoke";
-        case BtMessageType::Interested: return "Interested";
-        case BtMessageType::NotInterested: return "NotInterested";
-        case BtMessageType::Have: return "Have";
-        case BtMessageType::Bitfield: return "Bitfield";
-        case BtMessageType::Request: return "Request";
-        case BtMessageType::Piece: return "Piece";
-        case BtMessageType::Cancel: return "Cancel";
-        case BtMessageType::Port: return "Port";
-        case BtMessageType::SuggestPiece: return "SuggestPiece";
-        case BtMessageType::HaveAll: return "HaveAll";
-        case BtMessageType::HaveNone: return "HaveNone";
-        case BtMessageType::RejectRequest: return "RejectRequest";
-        case BtMessageType::AllowedFast: return "AllowedFast";
-        case BtMessageType::Extended: return "Extended";
-        default: return "Unknown";
-    }
-}
-
-//=============================================================================
-// Encoder Helper Methods
-//=============================================================================
-
-void BtMessageEncoder::write_uint32(std::vector<uint8_t>& buf, uint32_t value) {
-    buf.push_back(static_cast<uint8_t>((value >> 24) & 0xFF));
-    buf.push_back(static_cast<uint8_t>((value >> 16) & 0xFF));
-    buf.push_back(static_cast<uint8_t>((value >> 8) & 0xFF));
-    buf.push_back(static_cast<uint8_t>(value & 0xFF));
-}
-
-void BtMessageEncoder::write_uint16(std::vector<uint8_t>& buf, uint16_t value) {
-    buf.push_back(static_cast<uint8_t>((value >> 8) & 0xFF));
-    buf.push_back(static_cast<uint8_t>(value & 0xFF));
-}
-
-//=============================================================================
-// Core Protocol Encoding (BEP 3)
-//=============================================================================
-
-std::vector<uint8_t> BtMessageEncoder::encode_keepalive() {
-    std::vector<uint8_t> msg;
-    write_uint32(msg, 0);  // length = 0
-    return msg;
-}
-
-std::vector<uint8_t> BtMessageEncoder::encode_choke() {
-    std::vector<uint8_t> msg;
-    write_uint32(msg, 1);  // length = 1
-    msg.push_back(static_cast<uint8_t>(BtMessageType::Choke));
-    return msg;
-}
-
-std::vector<uint8_t> BtMessageEncoder::encode_unchoke() {
-    std::vector<uint8_t> msg;
-    write_uint32(msg, 1);
-    msg.push_back(static_cast<uint8_t>(BtMessageType::Unchoke));
-    return msg;
-}
-
-std::vector<uint8_t> BtMessageEncoder::encode_interested() {
-    std::vector<uint8_t> msg;
-    write_uint32(msg, 1);
-    msg.push_back(static_cast<uint8_t>(BtMessageType::Interested));
-    return msg;
-}
-
-std::vector<uint8_t> BtMessageEncoder::encode_not_interested() {
-    std::vector<uint8_t> msg;
-    write_uint32(msg, 1);
-    msg.push_back(static_cast<uint8_t>(BtMessageType::NotInterested));
-    return msg;
-}
-
-std::vector<uint8_t> BtMessageEncoder::encode_have(uint32_t piece_index) {
-    std::vector<uint8_t> msg;
-    write_uint32(msg, 5);  // length = 1 (type) + 4 (piece index)
-    msg.push_back(static_cast<uint8_t>(BtMessageType::Have));
-    write_uint32(msg, piece_index);
-    return msg;
-}
-
-std::vector<uint8_t> BtMessageEncoder::encode_bitfield(const Bitfield& bitfield) {
-    std::vector<uint8_t> bf_bytes = bitfield.to_bytes();
-    
-    std::vector<uint8_t> msg;
-    write_uint32(msg, static_cast<uint32_t>(1 + bf_bytes.size()));  // length
-    msg.push_back(static_cast<uint8_t>(BtMessageType::Bitfield));
-    msg.insert(msg.end(), bf_bytes.begin(), bf_bytes.end());
-    return msg;
-}
-
-std::vector<uint8_t> BtMessageEncoder::encode_request(uint32_t piece_index,
-                                                       uint32_t begin,
-                                                       uint32_t length) {
-    std::vector<uint8_t> msg;
-    write_uint32(msg, 13);  // length = 1 + 4 + 4 + 4
-    msg.push_back(static_cast<uint8_t>(BtMessageType::Request));
-    write_uint32(msg, piece_index);
-    write_uint32(msg, begin);
-    write_uint32(msg, length);
-    return msg;
-}
-
-std::vector<uint8_t> BtMessageEncoder::encode_request(const RequestMessage& req) {
-    return encode_request(req.piece_index, req.begin, req.length);
-}
-
-std::vector<uint8_t> BtMessageEncoder::encode_piece(uint32_t piece_index,
-                                                     uint32_t begin,
-                                                     const uint8_t* data,
-                                                     size_t length) {
-    std::vector<uint8_t> msg;
-    write_uint32(msg, static_cast<uint32_t>(9 + length));  // length = 1 + 4 + 4 + data
-    msg.push_back(static_cast<uint8_t>(BtMessageType::Piece));
-    write_uint32(msg, piece_index);
-    write_uint32(msg, begin);
-    msg.insert(msg.end(), data, data + length);
-    return msg;
-}
-
-std::vector<uint8_t> BtMessageEncoder::encode_piece(const PieceMessage& piece) {
-    return encode_piece(piece.piece_index, piece.begin, 
-                        piece.data.data(), piece.data.size());
-}
-
-std::vector<uint8_t> BtMessageEncoder::encode_cancel(uint32_t piece_index,
-                                                      uint32_t begin,
-                                                      uint32_t length) {
-    std::vector<uint8_t> msg;
-    write_uint32(msg, 13);  // length = 1 + 4 + 4 + 4
-    msg.push_back(static_cast<uint8_t>(BtMessageType::Cancel));
-    write_uint32(msg, piece_index);
-    write_uint32(msg, begin);
-    write_uint32(msg, length);
-    return msg;
-}
-
-std::vector<uint8_t> BtMessageEncoder::encode_cancel(const RequestMessage& req) {
-    return encode_cancel(req.piece_index, req.begin, req.length);
-}
-
-std::vector<uint8_t> BtMessageEncoder::encode_port(uint16_t port) {
-    std::vector<uint8_t> msg;
-    write_uint32(msg, 3);  // length = 1 + 2
-    msg.push_back(static_cast<uint8_t>(BtMessageType::Port));
-    write_uint16(msg, port);
-    return msg;
-}
-
-//=============================================================================
-// Fast Extension Encoding (BEP 6)
-//=============================================================================
-
-std::vector<uint8_t> BtMessageEncoder::encode_have_all() {
-    std::vector<uint8_t> msg;
-    write_uint32(msg, 1);
-    msg.push_back(static_cast<uint8_t>(BtMessageType::HaveAll));
-    return msg;
-}
-
-std::vector<uint8_t> BtMessageEncoder::encode_have_none() {
-    std::vector<uint8_t> msg;
-    write_uint32(msg, 1);
-    msg.push_back(static_cast<uint8_t>(BtMessageType::HaveNone));
-    return msg;
-}
-
-std::vector<uint8_t> BtMessageEncoder::encode_suggest_piece(uint32_t piece_index) {
-    std::vector<uint8_t> msg;
-    write_uint32(msg, 5);
-    msg.push_back(static_cast<uint8_t>(BtMessageType::SuggestPiece));
-    write_uint32(msg, piece_index);
-    return msg;
-}
-
-std::vector<uint8_t> BtMessageEncoder::encode_reject_request(uint32_t piece_index,
-                                                              uint32_t begin,
-                                                              uint32_t length) {
-    std::vector<uint8_t> msg;
-    write_uint32(msg, 13);
-    msg.push_back(static_cast<uint8_t>(BtMessageType::RejectRequest));
-    write_uint32(msg, piece_index);
-    write_uint32(msg, begin);
-    write_uint32(msg, length);
-    return msg;
-}
-
-std::vector<uint8_t> BtMessageEncoder::encode_allowed_fast(uint32_t piece_index) {
-    std::vector<uint8_t> msg;
-    write_uint32(msg, 5);
-    msg.push_back(static_cast<uint8_t>(BtMessageType::AllowedFast));
-    write_uint32(msg, piece_index);
-    return msg;
-}
-
-//=============================================================================
-// Extension Protocol Encoding (BEP 10)
-//=============================================================================
-
-std::vector<uint8_t> BtMessageEncoder::encode_extended(uint8_t extension_id,
-                                                        const std::vector<uint8_t>& payload) {
-    std::vector<uint8_t> msg;
-    write_uint32(msg, static_cast<uint32_t>(2 + payload.size()));  // length = 1 + 1 + payload
-    msg.push_back(static_cast<uint8_t>(BtMessageType::Extended));
-    msg.push_back(extension_id);
-    msg.insert(msg.end(), payload.begin(), payload.end());
-    return msg;
-}
-
-//=============================================================================
-// Decoder Helper Methods
-//=============================================================================
-
-uint32_t BtMessageDecoder::read_uint32(const uint8_t* data) {
-    return (static_cast<uint32_t>(data[0]) << 24) |
-           (static_cast<uint32_t>(data[1]) << 16) |
-           (static_cast<uint32_t>(data[2]) << 8) |
-           static_cast<uint32_t>(data[3]);
-}
-
-uint16_t BtMessageDecoder::read_uint16(const uint8_t* data) {
-    return (static_cast<uint16_t>(data[0]) << 8) |
-           static_cast<uint16_t>(data[1]);
-}
-
-//=============================================================================
-// Message Decoding
-//=============================================================================
-
-size_t BtMessageDecoder::message_length(const uint8_t* data, size_t length) {
-    if (length < 4) {
-        return 0;  // Not enough data to read length prefix
-    }
-    
-    uint32_t msg_len = read_uint32(data);
-    size_t total_len = 4 + msg_len;  // 4-byte length prefix + message
-    
-    if (length < total_len) {
-        return 0;  // Message not complete
-    }
-    
-    return total_len;
-}
-
-bool BtMessageDecoder::is_keepalive(const uint8_t* data, size_t length) {
-    if (length < 4) return false;
-    return read_uint32(data) == 0;
-}
-
-std::optional<BtMessage> BtMessageDecoder::decode(const uint8_t* data,
-                                                   size_t length,
-                                                   uint32_t num_pieces) {
-    if (length < 4) {
-        return std::nullopt;
-    }
-    
-    uint32_t msg_len = read_uint32(data);
-    
-    // Keep-alive: length = 0
-    if (msg_len == 0) {
-        return BtMessage(BtMessageType::Choke);  // Treat as choke for simplicity
-    }
-    
-    if (length < 4 + msg_len || msg_len < 1) {
-        return std::nullopt;
-    }
-    
-    const uint8_t* payload = data + 4;
-    uint8_t type_byte = payload[0];
-    
-    BtMessage msg;
-    msg.type = static_cast<BtMessageType>(type_byte);
-    
-    switch (msg.type) {
-        case BtMessageType::Choke:
-        case BtMessageType::Unchoke:
-        case BtMessageType::Interested:
-        case BtMessageType::NotInterested:
-        case BtMessageType::HaveAll:
-        case BtMessageType::HaveNone:
-            // No additional data
-            if (msg_len != 1) return std::nullopt;
-            break;
-            
-        case BtMessageType::Have:
-        case BtMessageType::SuggestPiece:
-        case BtMessageType::AllowedFast:
-            // 4-byte piece index
-            if (msg_len != 5) return std::nullopt;
-            msg.have_piece = read_uint32(payload + 1);
-            break;
-            
-        case BtMessageType::Port:
-            // 2-byte port
-            if (msg_len != 3) return std::nullopt;
-            msg.port = read_uint16(payload + 1);
-            break;
-            
-        case BtMessageType::Bitfield: {
-            // Variable length
-            size_t bf_len = msg_len - 1;
-            size_t expected_bits = num_pieces > 0 ? num_pieces : bf_len * 8;
-            msg.bitfield = Bitfield::from_bytes(payload + 1, bf_len, expected_bits);
-            break;
-        }
-            
-        case BtMessageType::Request:
-        case BtMessageType::Cancel:
-        case BtMessageType::RejectRequest:
-            // 12 bytes: piece index (4) + begin (4) + length (4)
-            if (msg_len != 13) return std::nullopt;
-            msg.request = RequestMessage(
-                read_uint32(payload + 1),
-                read_uint32(payload + 5),
-                read_uint32(payload + 9)
-            );
-            break;
-            
-        case BtMessageType::Piece: {
-            // Variable length: piece index (4) + begin (4) + data
-            if (msg_len < 9) return std::nullopt;
-            
-            uint32_t piece_index = read_uint32(payload + 1);
-            uint32_t begin = read_uint32(payload + 5);
-            size_t data_len = msg_len - 9;
-            
-            std::vector<uint8_t> piece_data(payload + 9, payload + 9 + data_len);
-            msg.piece = PieceMessage(piece_index, begin, std::move(piece_data));
-            break;
-        }
-            
-        case BtMessageType::Extended:
-            // 1-byte extension ID + variable payload
-            if (msg_len < 2) return std::nullopt;
-            msg.extension_id = payload[1];
-            msg.extension_payload.assign(payload + 2, payload + msg_len);
-            break;
-            
-        default:
-            // Unknown message type
-            return std::nullopt;
-    }
-    
-    return msg;
-}
-
-std::optional<BtMessage> BtMessageDecoder::decode(const std::vector<uint8_t>& data,
-                                                   uint32_t num_pieces) {
-    return decode(data.data(), data.size(), num_pieces);
-}
-
-} // namespace librats

package/native-src/src/bt_messages.h

@@ -1,324 +0,0 @@
-#pragma once
-
-/**
- * @file bt_messages.h
- * @brief BitTorrent protocol message encoding and decoding
- * 
- * Implements BEP 3 (BitTorrent Wire Protocol) message types.
- * Also includes BEP 6 (Fast Extension) and BEP 10 (Extension Protocol).
- */
-
-#include "bt_types.h"
-#include "bt_bitfield.h"
-
-#include <vector>
-#include <cstdint>
-#include <optional>
-#include <string>
-
-namespace librats {
-
-//=============================================================================
-// Message Types (BEP 3)
-//=============================================================================
-
-/**
- * @brief BitTorrent message type IDs
- */
-enum class BtMessageType : uint8_t {
-    // Core protocol (BEP 3)
-    Choke = 0,
-    Unchoke = 1,
-    Interested = 2,
-    NotInterested = 3,
-    Have = 4,
-    Bitfield = 5,
-    Request = 6,
-    Piece = 7,
-    Cancel = 8,
-    
-    // DHT extension (BEP 5)
-    Port = 9,
-    
-    // Fast extension (BEP 6)
-    SuggestPiece = 13,
-    HaveAll = 14,
-    HaveNone = 15,
-    RejectRequest = 16,
-    AllowedFast = 17,
-    
-    // Extension protocol (BEP 10)
-    Extended = 20
-};
-
-/**
- * @brief Convert message type to string for debugging
- */
-const char* message_type_to_string(BtMessageType type);
-
-//=============================================================================
-// Message Structures
-//=============================================================================
-
-/**
- * @brief Request/Cancel message data
- */
-struct RequestMessage {
-    uint32_t piece_index;
-    uint32_t begin;
-    uint32_t length;
-    
-    RequestMessage() : piece_index(0), begin(0), length(0) {}
-    RequestMessage(uint32_t idx, uint32_t b, uint32_t len)
-        : piece_index(idx), begin(b), length(len) {}
-    
-    bool operator==(const RequestMessage& other) const {
-        return piece_index == other.piece_index &&
-               begin == other.begin &&
-               length == other.length;
-    }
-};
-
-/**
- * @brief Piece message data (block of data)
- */
-struct PieceMessage {
-    uint32_t piece_index;
-    uint32_t begin;
-    std::vector<uint8_t> data;
-    
-    PieceMessage() : piece_index(0), begin(0) {}
-    PieceMessage(uint32_t idx, uint32_t b, std::vector<uint8_t> d)
-        : piece_index(idx), begin(b), data(std::move(d)) {}
-};
-
-/**
- * @brief Parsed message from the wire
- */
-struct BtMessage {
-    BtMessageType type;
-    
-    // Data depending on type
-    union {
-        uint32_t have_piece;        // Have
-        uint32_t port;              // Port (DHT)
-        uint32_t suggest_piece;     // SuggestPiece
-        uint32_t allowed_fast;      // AllowedFast
-    };
-    
-    // For complex message types (stored separately)
-    std::optional<Bitfield> bitfield;
-    std::optional<RequestMessage> request;
-    std::optional<PieceMessage> piece;
-    
-    // For Extended messages
-    uint8_t extension_id;
-    std::vector<uint8_t> extension_payload;
-    
-    BtMessage() : type(BtMessageType::Choke), have_piece(0), extension_id(0) {}
-    explicit BtMessage(BtMessageType t) : type(t), have_piece(0), extension_id(0) {}
-};
-
-//=============================================================================
-// Message Encoder
-//=============================================================================
-
-/**
- * @brief Encodes BitTorrent protocol messages to wire format
- */
-class BtMessageEncoder {
-public:
-    /**
-     * @brief Encode a keep-alive message (length = 0)
-     */
-    static std::vector<uint8_t> encode_keepalive();
-    
-    /**
-     * @brief Encode a choke message
-     */
-    static std::vector<uint8_t> encode_choke();
-    
-    /**
-     * @brief Encode an unchoke message
-     */
-    static std::vector<uint8_t> encode_unchoke();
-    
-    /**
-     * @brief Encode an interested message
-     */
-    static std::vector<uint8_t> encode_interested();
-    
-    /**
-     * @brief Encode a not interested message
-     */
-    static std::vector<uint8_t> encode_not_interested();
-    
-    /**
-     * @brief Encode a have message
-     * @param piece_index Index of the piece we now have
-     */
-    static std::vector<uint8_t> encode_have(uint32_t piece_index);
-    
-    /**
-     * @brief Encode a bitfield message
-     * @param bitfield Our have bitfield
-     */
-    static std::vector<uint8_t> encode_bitfield(const Bitfield& bitfield);
-    
-    /**
-     * @brief Encode a request message
-     * @param piece_index Piece index
-     * @param begin Offset within piece
-     * @param length Length of block (usually 16384)
-     */
-    static std::vector<uint8_t> encode_request(uint32_t piece_index, 
-                                                uint32_t begin, 
-                                                uint32_t length);
-    
-    /**
-     * @brief Encode a request message from RequestMessage struct
-     */
-    static std::vector<uint8_t> encode_request(const RequestMessage& req);
-    
-    /**
-     * @brief Encode a piece message (block data)
-     * @param piece_index Piece index
-     * @param begin Offset within piece
-     * @param data Block data
-     */
-    static std::vector<uint8_t> encode_piece(uint32_t piece_index,
-                                              uint32_t begin,
-                                              const uint8_t* data,
-                                              size_t length);
-    
-    /**
-     * @brief Encode a piece message from PieceMessage struct
-     */
-    static std::vector<uint8_t> encode_piece(const PieceMessage& piece);
-    
-    /**
-     * @brief Encode a cancel message
-     */
-    static std::vector<uint8_t> encode_cancel(uint32_t piece_index,
-                                               uint32_t begin,
-                                               uint32_t length);
-    
-    /**
-     * @brief Encode a cancel message from RequestMessage struct
-     */
-    static std::vector<uint8_t> encode_cancel(const RequestMessage& req);
-    
-    /**
-     * @brief Encode a port message (DHT port)
-     */
-    static std::vector<uint8_t> encode_port(uint16_t port);
-    
-    //=========================================================================
-    // Fast Extension (BEP 6)
-    //=========================================================================
-    
-    /**
-     * @brief Encode a have-all message
-     */
-    static std::vector<uint8_t> encode_have_all();
-    
-    /**
-     * @brief Encode a have-none message
-     */
-    static std::vector<uint8_t> encode_have_none();
-    
-    /**
-     * @brief Encode a suggest piece message
-     */
-    static std::vector<uint8_t> encode_suggest_piece(uint32_t piece_index);
-    
-    /**
-     * @brief Encode a reject request message
-     */
-    static std::vector<uint8_t> encode_reject_request(uint32_t piece_index,
-                                                       uint32_t begin,
-                                                       uint32_t length);
-    
-    /**
-     * @brief Encode an allowed fast message
-     */
-    static std::vector<uint8_t> encode_allowed_fast(uint32_t piece_index);
-    
-    //=========================================================================
-    // Extension Protocol (BEP 10)
-    //=========================================================================
-    
-    /**
-     * @brief Encode an extended message
-     * @param extension_id Extension message ID (0 for handshake)
-     * @param payload Bencoded payload
-     */
-    static std::vector<uint8_t> encode_extended(uint8_t extension_id,
-                                                 const std::vector<uint8_t>& payload);
-    
-private:
-    /**
-     * @brief Write a 32-bit big-endian integer to buffer
-     */
-    static void write_uint32(std::vector<uint8_t>& buf, uint32_t value);
-    
-    /**
-     * @brief Write a 16-bit big-endian integer to buffer
-     */
-    static void write_uint16(std::vector<uint8_t>& buf, uint16_t value);
-};
-
-//=============================================================================
-// Message Decoder
-//=============================================================================
-
-/**
- * @brief Decodes BitTorrent protocol messages from wire format
- */
-class BtMessageDecoder {
-public:
-    /**
-     * @brief Check if there's a complete message in the buffer
-     * 
-     * @param data Buffer data
-     * @param length Buffer length
-     * @return Size of complete message (including 4-byte length prefix), or 0 if incomplete
-     */
-    static size_t message_length(const uint8_t* data, size_t length);
-    
-    /**
-     * @brief Check if buffer contains a keep-alive (length = 0)
-     */
-    static bool is_keepalive(const uint8_t* data, size_t length);
-    
-    /**
-     * @brief Decode a message from the buffer
-     * 
-     * @param data Buffer data (starting with 4-byte length)
-     * @param length Buffer length
-     * @param num_pieces Number of pieces (for bitfield validation)
-     * @return Decoded message, or nullopt on error
-     */
-    static std::optional<BtMessage> decode(const uint8_t* data, 
-                                           size_t length,
-                                           uint32_t num_pieces = 0);
-    
-    /**
-     * @brief Decode a message from vector
-     */
-    static std::optional<BtMessage> decode(const std::vector<uint8_t>& data,
-                                           uint32_t num_pieces = 0);
-    
-private:
-    /**
-     * @brief Read a 32-bit big-endian integer from buffer
-     */
-    static uint32_t read_uint32(const uint8_t* data);
-    
-    /**
-     * @brief Read a 16-bit big-endian integer from buffer
-     */
-    static uint16_t read_uint16(const uint8_t* data);
-};
-
-} // namespace librats