librats 1.0.2 → 2.2.0

package/native-src/src/bencode.cpp

@@ -1,485 +0,0 @@
-#include "bencode.h"
-#include <stdexcept>
-#include <sstream>
-#include <algorithm>
-#include <cstdint>
-
-namespace librats {
-
-// BencodeValue implementation
-BencodeValue::BencodeValue() : type_(Type::String), value_(std::string()) {}
-
-BencodeValue::BencodeValue(int64_t value) : type_(Type::Integer), value_(value) {}
-
-BencodeValue::BencodeValue(const std::string& value) : type_(Type::String), value_(value) {}
-
-BencodeValue::BencodeValue(const char* value) : type_(Type::String), value_(std::string(value)) {}
-
-#if LIBRATS_USE_SHARED_PTR_VARIANT
-BencodeValue::BencodeValue(const BencodeList& value) : type_(Type::List), value_(std::make_shared<BencodeList>(value)) {}
-#else
-BencodeValue::BencodeValue(const BencodeList& value) : type_(Type::List), value_(value) {}
-#endif
-
-#if LIBRATS_USE_SHARED_PTR_VARIANT
-BencodeValue::BencodeValue(const BencodeDict& value) : type_(Type::Dictionary), value_(std::make_shared<BencodeDict>(value)) {}
-#else
-BencodeValue::BencodeValue(const BencodeDict& value) : type_(Type::Dictionary), value_(value) {}
-#endif
-
-BencodeValue::BencodeValue(const BencodeValue& other) : type_(other.type_), value_(other.value_) {}
-
-BencodeValue::BencodeValue(BencodeValue&& other) noexcept : type_(other.type_), value_(std::move(other.value_)) {}
-
-BencodeValue& BencodeValue::operator=(const BencodeValue& other) {
-    if (this != &other) {
-        type_ = other.type_;
-        value_ = other.value_;
-    }
-    return *this;
-}
-
-BencodeValue& BencodeValue::operator=(BencodeValue&& other) noexcept {
-    if (this != &other) {
-        type_ = other.type_;
-        value_ = std::move(other.value_);
-    }
-    return *this;
-}
-
-BencodeValue::~BencodeValue() = default;
-
-int64_t BencodeValue::as_integer() const {
-    if (type_ != Type::Integer) {
-        throw std::runtime_error("BencodeValue is not an integer");
-    }
-    return std::get<int64_t>(value_);
-}
-
-const std::string& BencodeValue::as_string() const {
-    if (type_ != Type::String) {
-        throw std::runtime_error("BencodeValue is not a string");
-    }
-    return std::get<std::string>(value_);
-}
-
-const BencodeList& BencodeValue::as_list() const {
-    if (type_ != Type::List) {
-        throw std::runtime_error("BencodeValue is not a list");
-    }
-#if LIBRATS_USE_SHARED_PTR_VARIANT
-    return *std::get<std::shared_ptr<BencodeList>>(value_);
-#else
-    return std::get<BencodeList>(value_);
-#endif
-}
-
-const BencodeDict& BencodeValue::as_dict() const {
-    if (type_ != Type::Dictionary) {
-        throw std::runtime_error("BencodeValue is not a dictionary");
-    }
-#if LIBRATS_USE_SHARED_PTR_VARIANT
-    return *std::get<std::shared_ptr<BencodeDict>>(value_);
-#else
-    return std::get<BencodeDict>(value_);
-#endif
-}
-
-BencodeList& BencodeValue::as_list() {
-    if (type_ != Type::List) {
-        throw std::runtime_error("BencodeValue is not a list");
-    }
-#if LIBRATS_USE_SHARED_PTR_VARIANT
-    return *std::get<std::shared_ptr<BencodeList>>(value_);
-#else
-    return std::get<BencodeList>(value_);
-#endif
-}
-
-BencodeDict& BencodeValue::as_dict() {
-    if (type_ != Type::Dictionary) {
-        throw std::runtime_error("BencodeValue is not a dictionary");
-    }
-#if LIBRATS_USE_SHARED_PTR_VARIANT
-    return *std::get<std::shared_ptr<BencodeDict>>(value_);
-#else
-    return std::get<BencodeDict>(value_);
-#endif
-}
-
-bool BencodeValue::has_key(const std::string& key) const {
-    if (type_ != Type::Dictionary) {
-        return false;
-    }
-#if LIBRATS_USE_SHARED_PTR_VARIANT
-    const auto& dict = *std::get<std::shared_ptr<BencodeDict>>(value_);
-#else
-    const auto& dict = std::get<BencodeDict>(value_);
-#endif
-    return dict.find(key) != dict.end();
-}
-
-const BencodeValue& BencodeValue::operator[](const std::string& key) const {
-    if (type_ != Type::Dictionary) {
-        throw std::runtime_error("BencodeValue is not a dictionary");
-    }
-#if LIBRATS_USE_SHARED_PTR_VARIANT
-    const auto& dict = *std::get<std::shared_ptr<BencodeDict>>(value_);
-#else
-    const auto& dict = std::get<BencodeDict>(value_);
-#endif
-    auto it = dict.find(key);
-    if (it == dict.end()) {
-        throw std::runtime_error("Key not found in dictionary: " + key);
-    }
-    return it->second;
-}
-
-BencodeValue& BencodeValue::operator[](const std::string& key) {
-    if (type_ != Type::Dictionary) {
-        throw std::runtime_error("BencodeValue is not a dictionary");
-    }
-#if LIBRATS_USE_SHARED_PTR_VARIANT
-    auto& dict = *std::get<std::shared_ptr<BencodeDict>>(value_);
-#else
-    auto& dict = std::get<BencodeDict>(value_);
-#endif
-    return dict[key];
-}
-
-const BencodeValue& BencodeValue::operator[](size_t index) const {
-    if (type_ != Type::List) {
-        throw std::runtime_error("BencodeValue is not a list");
-    }
-#if LIBRATS_USE_SHARED_PTR_VARIANT
-    const auto& list = *std::get<std::shared_ptr<BencodeList>>(value_);
-#else
-    const auto& list = std::get<BencodeList>(value_);
-#endif
-    if (index >= list.size()) {
-        throw std::runtime_error("Index out of bounds");
-    }
-    return list[index];
-}
-
-BencodeValue& BencodeValue::operator[](size_t index) {
-    if (type_ != Type::List) {
-        throw std::runtime_error("BencodeValue is not a list");
-    }
-#if LIBRATS_USE_SHARED_PTR_VARIANT
-    auto& list = *std::get<std::shared_ptr<BencodeList>>(value_);
-#else
-    auto& list = std::get<BencodeList>(value_);
-#endif
-    if (index >= list.size()) {
-        throw std::runtime_error("Index out of bounds");
-    }
-    return list[index];
-}
-
-void BencodeValue::push_back(const BencodeValue& value) {
-    if (type_ != Type::List) {
-        throw std::runtime_error("BencodeValue is not a list");
-    }
-#if LIBRATS_USE_SHARED_PTR_VARIANT
-    auto& list = *std::get<std::shared_ptr<BencodeList>>(value_);
-#else
-    auto& list = std::get<BencodeList>(value_);
-#endif
-    list.push_back(value);
-}
-
-size_t BencodeValue::size() const {
-    switch (type_) {
-        case Type::String:
-            return std::get<std::string>(value_).size();
-        case Type::List:
-#if LIBRATS_USE_SHARED_PTR_VARIANT
-            return std::get<std::shared_ptr<BencodeList>>(value_)->size();
-#else
-            return std::get<BencodeList>(value_).size();
-#endif
-        case Type::Dictionary:
-#if LIBRATS_USE_SHARED_PTR_VARIANT
-            return std::get<std::shared_ptr<BencodeDict>>(value_)->size();
-#else
-            return std::get<BencodeDict>(value_).size();
-#endif
-        default:
-            throw std::runtime_error("Size not applicable to this type");
-    }
-}
-
-std::vector<uint8_t> BencodeValue::encode() const {
-    std::vector<uint8_t> buffer;
-    encode_to_buffer(buffer);
-    return buffer;
-}
-
-std::string BencodeValue::encode_string() const {
-    auto buffer = encode();
-    return std::string(buffer.begin(), buffer.end());
-}
-
-void BencodeValue::encode_to_buffer(std::vector<uint8_t>& buffer) const {
-    switch (type_) {
-        case Type::Integer: {
-            std::string str = "i" + std::to_string(std::get<int64_t>(value_)) + "e";
-            buffer.insert(buffer.end(), str.begin(), str.end());
-            break;
-        }
-        case Type::String: {
-            const auto& str = std::get<std::string>(value_);
-            std::string len_str = std::to_string(str.size()) + ":";
-            buffer.insert(buffer.end(), len_str.begin(), len_str.end());
-            buffer.insert(buffer.end(), str.begin(), str.end());
-            break;
-        }
-        case Type::List: {
-            buffer.push_back('l');
-#if LIBRATS_USE_SHARED_PTR_VARIANT
-            const auto& list = *std::get<std::shared_ptr<BencodeList>>(value_);
-#else
-            const auto& list = std::get<BencodeList>(value_);
-#endif
-            for (const auto& item : list) {
-                item.encode_to_buffer(buffer);
-            }
-            buffer.push_back('e');
-            break;
-        }
-        case Type::Dictionary: {
-            buffer.push_back('d');
-#if LIBRATS_USE_SHARED_PTR_VARIANT
-            const auto& dict = *std::get<std::shared_ptr<BencodeDict>>(value_);
-#else
-            const auto& dict = std::get<BencodeDict>(value_);
-#endif
-            
-            // Sort keys for consistent encoding
-            std::vector<std::string> keys;
-            for (const auto& pair : dict) {
-                keys.push_back(pair.first);
-            }
-            std::sort(keys.begin(), keys.end());
-            
-            for (const auto& key : keys) {
-                // Encode key
-                std::string len_str = std::to_string(key.size()) + ":";
-                buffer.insert(buffer.end(), len_str.begin(), len_str.end());
-                buffer.insert(buffer.end(), key.begin(), key.end());
-                
-                // Encode value
-                dict.at(key).encode_to_buffer(buffer);
-            }
-            buffer.push_back('e');
-            break;
-        }
-    }
-}
-
-BencodeValue BencodeValue::create_integer(int64_t value) {
-    return BencodeValue(value);
-}
-
-BencodeValue BencodeValue::create_string(const std::string& value) {
-    return BencodeValue(value);
-}
-
-BencodeValue BencodeValue::create_list() {
-    BencodeValue result;
-    result.type_ = Type::List;
-#if LIBRATS_USE_SHARED_PTR_VARIANT
-    result.value_ = std::make_shared<BencodeList>();
-#else
-    result.value_ = BencodeList();
-#endif
-    return result;
-}
-
-BencodeValue BencodeValue::create_dict() {
-    BencodeValue result;
-    result.type_ = Type::Dictionary;
-#if LIBRATS_USE_SHARED_PTR_VARIANT
-    result.value_ = std::make_shared<BencodeDict>();
-#else
-    result.value_ = BencodeDict();
-#endif
-    return result;
-}
-
-// BencodeDecoder implementation
-BencodeDecoder::BencodeDecoder(const uint8_t* data, size_t size) : data_(data), size_(size), pos_(0) {}
-
-BencodeValue BencodeDecoder::decode(const std::vector<uint8_t>& data) {
-    return decode(data.data(), data.size());
-}
-
-BencodeValue BencodeDecoder::decode(const std::string& data) {
-    return decode(reinterpret_cast<const uint8_t*>(data.data()), data.size());
-}
-
-BencodeValue BencodeDecoder::decode(const uint8_t* data, size_t size) {
-    BencodeDecoder decoder(data, size);
-    return decoder.decode_value();
-}
-
-BencodeValue BencodeDecoder::decode_value() {
-    if (!has_more()) {
-        throw std::runtime_error("Unexpected end of data");
-    }
-    
-    uint8_t first_byte = current_byte();
-    
-    if (first_byte == 'i') {
-        return decode_integer();
-    } else if (first_byte == 'l') {
-        return decode_list();
-    } else if (first_byte == 'd') {
-        return decode_dict();
-    } else if (first_byte >= '0' && first_byte <= '9') {
-        return decode_string();
-    } else {
-        throw std::runtime_error("Invalid bencode data");
-    }
-}
-
-BencodeValue BencodeDecoder::decode_integer() {
-    if (consume_byte() != 'i') {
-        throw std::runtime_error("Expected 'i' for integer");
-    }
-    
-    std::string num_str;
-    while (has_more() && current_byte() != 'e') {
-        num_str += consume_byte();
-    }
-    
-    if (!has_more() || consume_byte() != 'e') {
-        throw std::runtime_error("Expected 'e' to end integer");
-    }
-    
-    if (num_str.empty()) {
-        throw std::runtime_error("Empty integer");
-    }
-    
-    try {
-        return BencodeValue(std::stoll(num_str));
-    } catch (const std::exception&) {
-        throw std::runtime_error("Invalid integer: " + num_str);
-    }
-}
-
-BencodeValue BencodeDecoder::decode_string() {
-    std::string len_str;
-    while (has_more() && current_byte() != ':') {
-        len_str += consume_byte();
-    }
-    
-    if (!has_more() || consume_byte() != ':') {
-        throw std::runtime_error("Expected ':' in string");
-    }
-    
-    if (len_str.empty()) {
-        throw std::runtime_error("Empty string length");
-    }
-    
-    size_t length;
-    try {
-        length = std::stoull(len_str);
-    } catch (const std::exception&) {
-        throw std::runtime_error("Invalid string length: " + len_str);
-    }
-    
-    if (pos_ + length > size_) {
-        throw std::runtime_error("String length exceeds data size");
-    }
-    
-    std::string str = consume_string(length);
-    return BencodeValue(str);
-}
-
-BencodeValue BencodeDecoder::decode_list() {
-    if (consume_byte() != 'l') {
-        throw std::runtime_error("Expected 'l' for list");
-    }
-    
-    BencodeValue list = BencodeValue::create_list();
-    
-    while (has_more() && current_byte() != 'e') {
-        list.push_back(decode_value());
-    }
-    
-    if (!has_more() || consume_byte() != 'e') {
-        throw std::runtime_error("Expected 'e' to end list");
-    }
-    
-    return list;
-}
-
-BencodeValue BencodeDecoder::decode_dict() {
-    if (consume_byte() != 'd') {
-        throw std::runtime_error("Expected 'd' for dictionary");
-    }
-    
-    BencodeValue dict = BencodeValue::create_dict();
-    
-    while (has_more() && current_byte() != 'e') {
-        // Decode key (must be string)
-        BencodeValue key = decode_string();
-        
-        // Decode value
-        BencodeValue value = decode_value();
-        
-        dict[key.as_string()] = value;
-    }
-    
-    if (!has_more() || consume_byte() != 'e') {
-        throw std::runtime_error("Expected 'e' to end dictionary");
-    }
-    
-    return dict;
-}
-
-uint8_t BencodeDecoder::current_byte() const {
-    if (pos_ >= size_) {
-        throw std::runtime_error("Unexpected end of data");
-    }
-    return data_[pos_];
-}
-
-uint8_t BencodeDecoder::consume_byte() {
-    if (pos_ >= size_) {
-        throw std::runtime_error("Unexpected end of data");
-    }
-    return data_[pos_++];
-}
-
-std::string BencodeDecoder::consume_string(size_t length) {
-    if (pos_ + length > size_) {
-        throw std::runtime_error("String length exceeds data size");
-    }
-    std::string str(reinterpret_cast<const char*>(data_ + pos_), length);
-    pos_ += length;
-    return str;
-}
-
-// Utility functions
-namespace bencode {
-    BencodeValue decode(const std::vector<uint8_t>& data) {
-        return BencodeDecoder::decode(data);
-    }
-    
-    BencodeValue decode(const std::string& data) {
-        return BencodeDecoder::decode(data);
-    }
-    
-    std::vector<uint8_t> encode(const BencodeValue& value) {
-        return value.encode();
-    }
-    
-    std::string encode_string(const BencodeValue& value) {
-        return value.encode_string();
-    }
-}
-
-} // namespace librats 

package/native-src/src/bencode.h

@@ -1,145 +0,0 @@
-#pragma once
-
-#include <vector>
-#include <string>
-#include <unordered_map>
-#include <memory>
-#include <variant>
-#include <cstdint>
-
-// Use shared_ptr variant for GCC 11 and lower compatibility
-#ifndef LIBRATS_USE_SHARED_PTR_VARIANT
-#if defined(__GNUC__) && (__GNUC__ <= 11)
-#define LIBRATS_USE_SHARED_PTR_VARIANT 1
-#else
-#define LIBRATS_USE_SHARED_PTR_VARIANT 0
-#endif
-#endif
-
-namespace librats {
-
-// Forward declarations
-class BencodeValue;
-using BencodeDict = std::unordered_map<std::string, BencodeValue>;
-using BencodeList = std::vector<BencodeValue>;
-
-/**
- * Represents a bencoded value which can be:
- * - Integer (signed 64-bit)
- * - String (byte string)
- * - List (array of bencoded values)
- * - Dictionary (map of string keys to bencoded values)
- */
-class BencodeValue {
-public:
-    enum class Type {
-        Integer,
-        String,
-        List,
-        Dictionary
-    };
-
-    // Constructors
-    BencodeValue();
-    BencodeValue(int64_t value);
-    BencodeValue(const std::string& value);
-    BencodeValue(const char* value);
-    BencodeValue(const BencodeList& value);
-    BencodeValue(const BencodeDict& value);
-    
-    // Copy and move constructors
-    BencodeValue(const BencodeValue& other);
-    BencodeValue(BencodeValue&& other) noexcept;
-    BencodeValue& operator=(const BencodeValue& other);
-    BencodeValue& operator=(BencodeValue&& other) noexcept;
-    
-    ~BencodeValue();
-
-    // Type checking
-    Type get_type() const { return type_; }
-    bool is_integer() const { return type_ == Type::Integer; }
-    bool is_string() const { return type_ == Type::String; }
-    bool is_list() const { return type_ == Type::List; }
-    bool is_dict() const { return type_ == Type::Dictionary; }
-
-    // Value access
-    int64_t as_integer() const;
-    const std::string& as_string() const;
-    const BencodeList& as_list() const;
-    const BencodeDict& as_dict() const;
-
-    // Mutable access
-    BencodeList& as_list();
-    BencodeDict& as_dict();
-
-    // Dictionary operations
-    bool has_key(const std::string& key) const;
-    const BencodeValue& operator[](const std::string& key) const;
-    BencodeValue& operator[](const std::string& key);
-
-    // List operations
-    const BencodeValue& operator[](size_t index) const;
-    BencodeValue& operator[](size_t index);
-    void push_back(const BencodeValue& value);
-    size_t size() const;
-
-    // Encoding
-    std::vector<uint8_t> encode() const;
-    std::string encode_string() const;
-
-    // Static creation methods
-    static BencodeValue create_integer(int64_t value);
-    static BencodeValue create_string(const std::string& value);
-    static BencodeValue create_list();
-    static BencodeValue create_dict();
-
-private:
-    Type type_;
-#if LIBRATS_USE_SHARED_PTR_VARIANT
-    std::variant<int64_t, std::string, std::shared_ptr<BencodeList>, std::shared_ptr<BencodeDict>> value_;
-#else
-    std::variant<int64_t, std::string, BencodeList, BencodeDict> value_;
-#endif
-    
-    void encode_to_buffer(std::vector<uint8_t>& buffer) const;
-};
-
-/**
- * Bencode decoder
- */
-class BencodeDecoder {
-public:
-    static BencodeValue decode(const std::vector<uint8_t>& data);
-    static BencodeValue decode(const std::string& data);
-    static BencodeValue decode(const uint8_t* data, size_t size);
-
-private:
-    const uint8_t* data_;
-    size_t size_;
-    size_t pos_;
-
-    BencodeDecoder(const uint8_t* data, size_t size);
-    
-    BencodeValue decode_value();
-    BencodeValue decode_integer();
-    BencodeValue decode_string();
-    BencodeValue decode_list();
-    BencodeValue decode_dict();
-    
-    bool has_more() const { return pos_ < size_; }
-    uint8_t current_byte() const;
-    uint8_t consume_byte();
-    std::string consume_string(size_t length);
-};
-
-/**
- * Utility functions
- */
-namespace bencode {
-    BencodeValue decode(const std::vector<uint8_t>& data);
-    BencodeValue decode(const std::string& data);
-    std::vector<uint8_t> encode(const BencodeValue& value);
-    std::string encode_string(const BencodeValue& value);
-}
-
-} // namespace librats 

package/native-src/src/bittorrent.cpp

@@ -1,14 +0,0 @@
-/**
- * @file bittorrent.cpp
- * @brief BitTorrent module entry point
- * 
- * This file can be used for any module-level initialization
- * that doesn't belong to a specific component.
- */
-
-#ifdef RATS_SEARCH_FEATURES
-
-// All BitTorrent components are implemented in their respective bt_*.cpp files
-// This file exists for module-level code if needed
-
-#endif // RATS_SEARCH_FEATURES