librats 1.0.2 → 2.2.0

package/native-src/src/bt_bitfield.h

@@ -1,316 +0,0 @@
-#pragma once
-
-/**
- * @file bt_bitfield.h
- * @brief Efficient bitfield implementation for piece tracking
- * 
- * Provides a memory-efficient bitfield class for tracking which pieces
- * have been downloaded or are available from peers.
- */
-
-#include <vector>
-#include <cstdint>
-#include <cstddef>
-#include <string>
-
-namespace librats {
-
-/**
- * @brief Efficient bit array for tracking pieces
- * 
- * Uses packed uint32_t words for efficient memory usage and fast operations.
- * Bits are stored in big-endian order within each byte to match BitTorrent
- * protocol wire format.
- */
-class Bitfield {
-public:
-    /**
-     * @brief Default constructor - creates empty bitfield
-     */
-    Bitfield() noexcept;
-    
-    /**
-     * @brief Create bitfield with specified number of bits
-     * @param num_bits Number of bits in the bitfield
-     * @param initial_value Initial value for all bits (default: false)
-     */
-    explicit Bitfield(size_t num_bits, bool initial_value = false);
-    
-    /**
-     * @brief Copy constructor
-     */
-    Bitfield(const Bitfield& other);
-    
-    /**
-     * @brief Move constructor
-     */
-    Bitfield(Bitfield&& other) noexcept;
-    
-    /**
-     * @brief Copy assignment
-     */
-    Bitfield& operator=(const Bitfield& other);
-    
-    /**
-     * @brief Move assignment
-     */
-    Bitfield& operator=(Bitfield&& other) noexcept;
-    
-    /**
-     * @brief Destructor
-     */
-    ~Bitfield() = default;
-    
-    //=========================================================================
-    // Bit Operations
-    //=========================================================================
-    
-    /**
-     * @brief Set a bit to 1
-     * @param index Bit index (0-based)
-     */
-    void set_bit(size_t index);
-    
-    /**
-     * @brief Clear a bit to 0
-     * @param index Bit index (0-based)
-     */
-    void clear_bit(size_t index);
-    
-    /**
-     * @brief Get the value of a bit
-     * @param index Bit index (0-based)
-     * @return true if bit is set, false otherwise
-     */
-    bool get_bit(size_t index) const;
-    
-    /**
-     * @brief Operator[] for read access
-     * @param index Bit index
-     * @return true if bit is set
-     */
-    bool operator[](size_t index) const { return get_bit(index); }
-    
-    /**
-     * @brief Set all bits to 1
-     */
-    void set_all();
-    
-    /**
-     * @brief Clear all bits to 0
-     */
-    void clear_all();
-    
-    //=========================================================================
-    // Query Operations
-    //=========================================================================
-    
-    /**
-     * @brief Check if all bits are set
-     * @return true if all bits are 1
-     */
-    bool all_set() const;
-    
-    /**
-     * @brief Check if no bits are set
-     * @return true if all bits are 0
-     */
-    bool none_set() const;
-    
-    /**
-     * @brief Count the number of set bits
-     * @return Number of bits that are 1
-     */
-    size_t count() const;
-    
-    /**
-     * @brief Get the total number of bits
-     * @return Size of the bitfield in bits
-     */
-    size_t size() const noexcept { return num_bits_; }
-    
-    /**
-     * @brief Check if bitfield is empty (size 0)
-     * @return true if no bits
-     */
-    bool empty() const noexcept { return num_bits_ == 0; }
-    
-    /**
-     * @brief Get number of bytes needed to store all bits
-     * @return Number of bytes
-     */
-    size_t num_bytes() const noexcept { return (num_bits_ + 7) / 8; }
-    
-    /**
-     * @brief Get number of 32-bit words used
-     * @return Number of uint32_t words
-     */
-    size_t num_words() const noexcept { return data_.size(); }
-    
-    //=========================================================================
-    // Bitwise Operations
-    //=========================================================================
-    
-    /**
-     * @brief Bitwise AND with another bitfield
-     * @param other Other bitfield (must be same size)
-     * @return Reference to this bitfield
-     */
-    Bitfield& operator&=(const Bitfield& other);
-    
-    /**
-     * @brief Bitwise OR with another bitfield
-     * @param other Other bitfield (must be same size)
-     * @return Reference to this bitfield
-     */
-    Bitfield& operator|=(const Bitfield& other);
-    
-    /**
-     * @brief Bitwise XOR with another bitfield
-     * @param other Other bitfield (must be same size)
-     * @return Reference to this bitfield
-     */
-    Bitfield& operator^=(const Bitfield& other);
-    
-    /**
-     * @brief Bitwise NOT (complement)
-     * @return New bitfield with all bits flipped
-     */
-    Bitfield operator~() const;
-    
-    /**
-     * @brief Check if this bitfield has any bits that other doesn't have
-     * @param other Other bitfield
-     * @return true if (this & ~other) is non-zero
-     */
-    bool has_bits_not_in(const Bitfield& other) const;
-    
-    //=========================================================================
-    // Serialization (Wire Format)
-    //=========================================================================
-    
-    /**
-     * @brief Convert to bytes for wire protocol
-     * 
-     * Returns bytes in big-endian bit order as per BitTorrent spec.
-     * Trailing bits in last byte are set to 0.
-     * 
-     * @return Vector of bytes
-     */
-    std::vector<uint8_t> to_bytes() const;
-    
-    /**
-     * @brief Create bitfield from bytes
-     * 
-     * @param data Pointer to byte data
-     * @param data_len Length of data in bytes
-     * @param num_bits Number of bits (may be less than data_len * 8)
-     * @return New Bitfield
-     */
-    static Bitfield from_bytes(const uint8_t* data, size_t data_len, size_t num_bits);
-    
-    /**
-     * @brief Create bitfield from byte vector
-     * 
-     * @param data Byte vector
-     * @param num_bits Number of bits
-     * @return New Bitfield
-     */
-    static Bitfield from_bytes(const std::vector<uint8_t>& data, size_t num_bits);
-    
-    //=========================================================================
-    // Resize
-    //=========================================================================
-    
-    /**
-     * @brief Resize the bitfield
-     * 
-     * @param new_size New number of bits
-     * @param value Value for new bits if growing
-     */
-    void resize(size_t new_size, bool value = false);
-    
-    //=========================================================================
-    // Iteration Helpers
-    //=========================================================================
-    
-    /**
-     * @brief Find the first set bit
-     * @return Index of first set bit, or size() if none
-     */
-    size_t find_first_set() const;
-    
-    /**
-     * @brief Find the first clear bit
-     * @return Index of first clear bit, or size() if none
-     */
-    size_t find_first_clear() const;
-    
-    /**
-     * @brief Find the next set bit after given index
-     * @param start Starting index (exclusive)
-     * @return Index of next set bit, or size() if none
-     */
-    size_t find_next_set(size_t start) const;
-    
-    /**
-     * @brief Find the next clear bit after given index
-     * @param start Starting index (exclusive)
-     * @return Index of next clear bit, or size() if none
-     */
-    size_t find_next_clear(size_t start) const;
-    
-    //=========================================================================
-    // Comparison
-    //=========================================================================
-    
-    bool operator==(const Bitfield& other) const;
-    bool operator!=(const Bitfield& other) const { return !(*this == other); }
-    
-    //=========================================================================
-    // Debug
-    //=========================================================================
-    
-    /**
-     * @brief Convert to string representation for debugging
-     * @return String of '0' and '1' characters
-     */
-    std::string to_string() const;
-    
-private:
-    std::vector<uint32_t> data_;  ///< Packed bit storage
-    size_t num_bits_;             ///< Total number of bits
-    
-    /**
-     * @brief Clear trailing bits that are beyond num_bits_
-     * 
-     * Called after operations that might set bits beyond the valid range
-     */
-    void clear_trailing_bits();
-    
-    /**
-     * @brief Count set bits in a 32-bit word (popcount)
-     */
-    static size_t popcount32(uint32_t x);
-};
-
-//=============================================================================
-// Free Functions
-//=============================================================================
-
-/**
- * @brief Bitwise AND of two bitfields
- */
-Bitfield operator&(const Bitfield& a, const Bitfield& b);
-
-/**
- * @brief Bitwise OR of two bitfields
- */
-Bitfield operator|(const Bitfield& a, const Bitfield& b);
-
-/**
- * @brief Bitwise XOR of two bitfields
- */
-Bitfield operator^(const Bitfield& a, const Bitfield& b);
-
-} // namespace librats

package/native-src/src/bt_choker.cpp

@@ -1,228 +0,0 @@
-#include "bt_choker.h"
-#include "bt_peer_connection.h"
-
-#include <algorithm>
-#include <random>
-
-namespace librats {
-
-//=============================================================================
-// Constructor
-//=============================================================================
-
-Choker::Choker()
-    : optimistic_peer_(nullptr)
-    , optimistic_rotation_index_(0) {
-    last_rechoke_ = std::chrono::steady_clock::now();
-    last_optimistic_rotation_ = std::chrono::steady_clock::now();
-}
-
-Choker::Choker(const ChokerConfig& config)
-    : config_(config)
-    , optimistic_peer_(nullptr)
-    , optimistic_rotation_index_(0) {
-    last_rechoke_ = std::chrono::steady_clock::now();
-    last_optimistic_rotation_ = std::chrono::steady_clock::now();
-}
-
-void Choker::set_config(const ChokerConfig& config) {
-    config_ = config;
-}
-
-bool Choker::should_rechoke() const {
-    auto now = std::chrono::steady_clock::now();
-    return (now - last_rechoke_) >= config_.rechoke_interval;
-}
-
-//=============================================================================
-// Main Choking Algorithm
-//=============================================================================
-
-ChokeResult Choker::run(std::vector<ChokePeerInfo>& peers) {
-    last_rechoke_ = std::chrono::steady_clock::now();
-    
-    if (config_.seed_mode) {
-        return run_seed_mode(peers);
-    } else {
-        return run_download_mode(peers);
-    }
-}
-
-ChokeResult Choker::run_download_mode(std::vector<ChokePeerInfo>& peers) {
-    ChokeResult result;
-    
-    if (peers.empty()) {
-        return result;
-    }
-    
-    // Check if we should rotate optimistic unchoke
-    auto now = std::chrono::steady_clock::now();
-    if ((now - last_optimistic_rotation_) >= config_.optimistic_interval) {
-        rotate_optimistic(peers);
-    }
-    
-    // Sort peers by download rate (best first)
-    // Only consider peers that are interested in us
-    std::vector<ChokePeerInfo*> interested_peers;
-    for (auto& peer : peers) {
-        if (peer.peer_interested && peer.connection != nullptr) {
-            interested_peers.push_back(&peer);
-        }
-    }
-    
-    std::sort(interested_peers.begin(), interested_peers.end(),
-        [](const ChokePeerInfo* a, const ChokePeerInfo* b) {
-            // Prefer peers with higher download rate to us
-            return a->download_rate > b->download_rate;
-        });
-    
-    // Determine how many slots we have (excluding optimistic)
-    size_t regular_slots = config_.max_uploads;
-    if (optimistic_peer_ != nullptr) {
-        regular_slots = config_.max_uploads > 0 ? config_.max_uploads - 1 : 0;
-    }
-    
-    // Unchoke the top peers
-    size_t unchoked = 0;
-    for (auto* peer : interested_peers) {
-        if (peer->connection == optimistic_peer_) {
-            // Already counted as optimistic
-            if (peer->am_choking) {
-                result.to_unchoke.push_back(peer->connection);
-                peer->am_choking = false;
-                peer->last_unchoke = now;
-            }
-            continue;
-        }
-        
-        if (unchoked < regular_slots) {
-            if (peer->am_choking) {
-                result.to_unchoke.push_back(peer->connection);
-                peer->am_choking = false;
-                peer->last_unchoke = now;
-            }
-            ++unchoked;
-        } else {
-            if (!peer->am_choking) {
-                result.to_choke.push_back(peer->connection);
-                peer->am_choking = true;
-            }
-        }
-    }
-    
-    // Choke peers who are no longer interested
-    for (auto& peer : peers) {
-        if (!peer.peer_interested && !peer.am_choking && peer.connection != nullptr) {
-            // Could optionally keep them unchoked for a bit
-            // For now, choke them
-            result.to_choke.push_back(peer.connection);
-            peer.am_choking = true;
-        }
-    }
-    
-    return result;
-}
-
-ChokeResult Choker::run_seed_mode(std::vector<ChokePeerInfo>& peers) {
-    ChokeResult result;
-    
-    if (peers.empty()) {
-        return result;
-    }
-    
-    auto now = std::chrono::steady_clock::now();
-    
-    // In seed mode, we prioritize upload rate and round-robin fairness
-    // Sort by upload rate, but give some randomness
-    std::vector<ChokePeerInfo*> interested_peers;
-    for (auto& peer : peers) {
-        if (peer.peer_interested && peer.connection != nullptr) {
-            interested_peers.push_back(&peer);
-        }
-    }
-    
-    // Sort by upload rate (how fast we're uploading to them)
-    // and time since last unchoke for fairness
-    std::sort(interested_peers.begin(), interested_peers.end(),
-        [now](const ChokePeerInfo* a, const ChokePeerInfo* b) {
-            // Prioritize peers we haven't unchoked recently
-            auto a_time = std::chrono::duration_cast<std::chrono::seconds>(
-                now - a->last_unchoke).count();
-            auto b_time = std::chrono::duration_cast<std::chrono::seconds>(
-                now - b->last_unchoke).count();
-            
-            // Mix of upload speed and fairness
-            double a_score = a->upload_rate + (a_time * 10.0);
-            double b_score = b->upload_rate + (b_time * 10.0);
-            
-            return a_score > b_score;
-        });
-    
-    // Unchoke top N
-    size_t unchoked = 0;
-    for (auto* peer : interested_peers) {
-        if (unchoked < config_.max_uploads) {
-            if (peer->am_choking) {
-                result.to_unchoke.push_back(peer->connection);
-                peer->am_choking = false;
-                peer->last_unchoke = now;
-            }
-            ++unchoked;
-        } else {
-            if (!peer->am_choking) {
-                result.to_choke.push_back(peer->connection);
-                peer->am_choking = true;
-            }
-        }
-    }
-    
-    return result;
-}
-
-void Choker::rotate_optimistic(std::vector<ChokePeerInfo>& peers) {
-    last_optimistic_rotation_ = std::chrono::steady_clock::now();
-    
-    // Find peers that are currently choked and interested
-    std::vector<ChokePeerInfo*> candidates;
-    for (auto& peer : peers) {
-        if (peer.am_choking && peer.peer_interested && peer.connection != nullptr) {
-            candidates.push_back(&peer);
-        }
-    }
-    
-    if (candidates.empty()) {
-        optimistic_peer_ = nullptr;
-        return;
-    }
-    
-    // Prefer peers that have been connected for a short time (new peers)
-    // to give them a chance to prove themselves
-    std::sort(candidates.begin(), candidates.end(),
-        [](const ChokePeerInfo* a, const ChokePeerInfo* b) {
-            return a->connected_at > b->connected_at;  // Newer first
-        });
-    
-    // Pick with some randomness weighted towards newer peers
-    size_t index = 0;
-    if (candidates.size() > 1) {
-        // Prefer first 1/4 of candidates (newer)
-        size_t range = (std::max)(candidates.size() / 4, size_t(1));
-        
-        static thread_local std::mt19937 gen(std::random_device{}());
-        std::uniform_int_distribution<size_t> dis(0, range - 1);
-        index = dis(gen);
-    }
-    
-    ChokePeerInfo* selected = candidates[index];
-    selected->is_optimistic = true;
-    optimistic_peer_ = selected->connection;
-    
-    // Clear optimistic flag from previous peer
-    for (auto& peer : peers) {
-        if (peer.connection != optimistic_peer_) {
-            peer.is_optimistic = false;
-        }
-    }
-}
-
-} // namespace librats

package/native-src/src/bt_choker.h

@@ -1,147 +0,0 @@
-#pragma once
-
-/**
- * @file bt_choker.h
- * @brief BitTorrent choking algorithm
- * 
- * Implements the tit-for-tat choking algorithm for fair bandwidth distribution.
- * Includes optimistic unchoking for discovering faster peers.
- */
-
-#include <vector>
-#include <chrono>
-#include <cstdint>
-#include <functional>
-
-namespace librats {
-
-// Forward declaration
-class BtPeerConnection;
-
-/**
- * @brief Configuration for the choking algorithm
- */
-struct ChokerConfig {
-    size_t max_uploads;                      ///< Maximum unchoked peers (default: 4)
-    std::chrono::seconds rechoke_interval;   ///< How often to re-evaluate (default: 10s)
-    std::chrono::seconds optimistic_interval;///< Optimistic unchoke rotation (default: 30s)
-    bool seed_mode;                          ///< Use seed choking algorithm
-    
-    ChokerConfig()
-        : max_uploads(4)
-        , rechoke_interval(10)
-        , optimistic_interval(30)
-        , seed_mode(false) {}
-};
-
-/**
- * @brief Peer info for choking decisions
- */
-struct ChokePeerInfo {
-    BtPeerConnection* connection;
-    double download_rate;       ///< Bytes/sec we're downloading from peer
-    double upload_rate;         ///< Bytes/sec we're uploading to peer
-    bool am_choking;           ///< Are we choking this peer?
-    bool am_interested;        ///< Are we interested in this peer?
-    bool peer_interested;      ///< Is peer interested in us?
-    bool is_optimistic;        ///< Is this the optimistic unchoke slot?
-    bool is_snubbed;           ///< Has peer not sent data recently?
-    
-    std::chrono::steady_clock::time_point last_unchoke;
-    std::chrono::steady_clock::time_point connected_at;
-    
-    ChokePeerInfo() 
-        : connection(nullptr)
-        , download_rate(0), upload_rate(0)
-        , am_choking(true), am_interested(false), peer_interested(false)
-        , is_optimistic(false), is_snubbed(false) {}
-};
-
-/**
- * @brief Result of a choking decision
- */
-struct ChokeResult {
-    std::vector<BtPeerConnection*> to_choke;    ///< Peers to choke
-    std::vector<BtPeerConnection*> to_unchoke;  ///< Peers to unchoke
-};
-
-/**
- * @brief Manages choking decisions for BitTorrent peers
- * 
- * The choking algorithm ensures fair bandwidth distribution:
- * - Unchoke top N peers based on download rate (reciprocation)
- * - One optimistic unchoke slot rotates to discover new fast peers
- * - Special handling for seed mode (upload-only)
- * 
- * Thread-safe: Call run_choker() from a single thread.
- */
-class Choker {
-public:
-    /**
-     * @brief Create a choker with default config
-     */
-    Choker();
-    
-    /**
-     * @brief Create a choker with custom config
-     */
-    explicit Choker(const ChokerConfig& config);
-    
-    /**
-     * @brief Set configuration
-     */
-    void set_config(const ChokerConfig& config);
-    
-    /**
-     * @brief Get current configuration
-     */
-    const ChokerConfig& config() const { return config_; }
-    
-    /**
-     * @brief Set whether we're in seed mode
-     */
-    void set_seed_mode(bool seed) { config_.seed_mode = seed; }
-    
-    /**
-     * @brief Run the choking algorithm
-     * 
-     * @param peers Current peer information
-     * @return Choking decisions
-     */
-    ChokeResult run(std::vector<ChokePeerInfo>& peers);
-    
-    /**
-     * @brief Check if it's time to rechoke
-     */
-    bool should_rechoke() const;
-    
-    /**
-     * @brief Get the optimistically unchoked peer
-     */
-    BtPeerConnection* optimistic_peer() const { return optimistic_peer_; }
-    
-private:
-    /**
-     * @brief Run download mode choking (we're leeching)
-     */
-    ChokeResult run_download_mode(std::vector<ChokePeerInfo>& peers);
-    
-    /**
-     * @brief Run seed mode choking (we're seeding)
-     */
-    ChokeResult run_seed_mode(std::vector<ChokePeerInfo>& peers);
-    
-    /**
-     * @brief Select new optimistic unchoke peer
-     */
-    void rotate_optimistic(std::vector<ChokePeerInfo>& peers);
-    
-    ChokerConfig config_;
-    BtPeerConnection* optimistic_peer_;
-    
-    std::chrono::steady_clock::time_point last_rechoke_;
-    std::chrono::steady_clock::time_point last_optimistic_rotation_;
-    size_t optimistic_rotation_index_;
-};
-
-} // namespace librats