librats 0.7.1 → 0.7.2

package/native-src/src/dht.h

@@ -541,7 +541,7 @@ private:
     void send_krpc_ping(const Peer& peer);
     void send_krpc_find_node(const Peer& peer, const NodeId& target);
     void send_krpc_get_peers(const Peer& peer, const InfoHash& info_hash);
-    void send_krpc_announce_peer(const Peer& peer, const InfoHash& info_hash, uint16_t port, const std::string& token);
+    void send_krpc_announce_peer(const Peer& peer, const InfoHash& info_hash, uint16_t port, const std::string& token, bool implied_port = false);
     
     void add_node(const DhtNode& node, bool confirmed = true, bool no_verify = false);
     std::vector<DhtNode> find_closest_nodes(const NodeId& target, size_t count = K_BUCKET_SIZE);

package/native-src/src/ice.cpp

@@ -281,7 +281,7 @@ bool IceManager::ensure_socket() {
         return false;
     }
     
-    local_port_ = static_cast<uint16_t>(get_ephemeral_port(socket_));
+    local_port_ = static_cast<uint16_t>(get_bound_port(socket_));
     LOG_ICE_DEBUG("Created ICE socket on port " << local_port_);
     return true;
 }

package/native-src/src/krpc.cpp

@@ -60,7 +60,7 @@ KrpcMessage KrpcProtocol::create_get_peers_query(const std::string& transaction_
     return message;
 }
 
-KrpcMessage KrpcProtocol::create_announce_peer_query(const std::string& transaction_id, const NodeId& sender_id, const InfoHash& info_hash, uint16_t port, const std::string& token) {
+KrpcMessage KrpcProtocol::create_announce_peer_query(const std::string& transaction_id, const NodeId& sender_id, const InfoHash& info_hash, uint16_t port, const std::string& token, bool implied_port) {
     KrpcMessage message;
     message.type = KrpcMessageType::Query;
     message.transaction_id = transaction_id;
@@ -68,6 +68,7 @@ KrpcMessage KrpcProtocol::create_announce_peer_query(const std::string& transact
     message.sender_id = sender_id;
     message.info_hash = info_hash;
     message.port = port;
+    message.implied_port = implied_port;
     message.token = token;
     return message;
 }
@@ -176,6 +177,9 @@ BencodeValue KrpcProtocol::encode_query(const KrpcMessage& message) {
             args["info_hash"] = BencodeValue(node_id_to_string(message.info_hash));
             args["port"] = BencodeValue(static_cast<int64_t>(message.port));
             args["token"] = BencodeValue(message.token);
+            if (message.implied_port) {
+                args["implied_port"] = BencodeValue(static_cast<int64_t>(1));
+            }
             break;
     }
     
@@ -316,6 +320,9 @@ std::unique_ptr<KrpcMessage> KrpcProtocol::decode_query(const BencodeValue& data
             if (args.has_key("token")) {
                 message->token = args["token"].as_string();
             }
+            if (args.has_key("implied_port")) {
+                message->implied_port = (args["implied_port"].as_integer() != 0);
+            }
             break;
     }
     

package/native-src/src/krpc.h

@@ -68,6 +68,7 @@ struct KrpcMessage {
     NodeId target_id;
     InfoHash info_hash;
     uint16_t port;
+    bool implied_port;  // BEP 5: if true, use UDP source port instead of 'port' field
     std::string token;
     
     // For responses
@@ -79,7 +80,7 @@ struct KrpcMessage {
     KrpcErrorCode error_code;
     std::string error_message;
     
-    KrpcMessage() : type(KrpcMessageType::Query), query_type(KrpcQueryType::Ping), sender_id(), target_id(), info_hash(), port(0), response_id(), error_code(KrpcErrorCode::GenericError) {}
+    KrpcMessage() : type(KrpcMessageType::Query), query_type(KrpcQueryType::Ping), sender_id(), target_id(), info_hash(), port(0), implied_port(false), response_id(), error_code(KrpcErrorCode::GenericError) {}
 };
 
 /**
@@ -96,7 +97,7 @@ public:
     static KrpcMessage create_ping_query(const std::string& transaction_id, const NodeId& sender_id);
     static KrpcMessage create_find_node_query(const std::string& transaction_id, const NodeId& sender_id, const NodeId& target_id);
     static KrpcMessage create_get_peers_query(const std::string& transaction_id, const NodeId& sender_id, const InfoHash& info_hash);
-    static KrpcMessage create_announce_peer_query(const std::string& transaction_id, const NodeId& sender_id, const InfoHash& info_hash, uint16_t port, const std::string& token);
+    static KrpcMessage create_announce_peer_query(const std::string& transaction_id, const NodeId& sender_id, const InfoHash& info_hash, uint16_t port, const std::string& token, bool implied_port = false);
     
     static KrpcMessage create_ping_response(const std::string& transaction_id, const NodeId& response_id);
     static KrpcMessage create_find_node_response(const std::string& transaction_id, const NodeId& response_id, const std::vector<KrpcNode>& nodes);

package/native-src/src/librats.cpp

@@ -146,16 +146,27 @@ bool RatsClient::start() {
     initialize_local_addresses();
     
     // Create dual-stack server socket (supports both IPv4 and IPv6)
-   server_socket_ = create_tcp_server(listen_port_, 5, bind_address_);
+    server_socket_ = create_tcp_server(listen_port_, 5, bind_address_);
+	// Fallback to free port
+    if (!is_valid_socket(server_socket_) && listen_port_ > 0) {
+        // Requested port is not available, try ephemeral port as fallback
+        int original_port = listen_port_;
+        LOG_CLIENT_WARN("TCP port " << original_port << " is not available, falling back to ephemeral port");
+        server_socket_ = create_tcp_server(0, 5, bind_address_);
+        if (is_valid_socket(server_socket_)) {
+            listen_port_ = get_bound_port(server_socket_);
+            LOG_CLIENT_INFO("Fell back from port " << original_port << " to ephemeral port " << listen_port_);
+        }
+    }
     if (!is_valid_socket(server_socket_)) {
-        LOG_CLIENT_ERROR("Failed to create dual-stack server socket on port " << listen_port_ <<
+        LOG_CLIENT_ERROR("Failed to create server socket on port " << listen_port_ <<
                         (bind_address_.empty() ? "" : " bound to " + bind_address_));
         return false;
     }
     
     // Update listen_port_ with actual bound port if ephemeral port was requested
     if (listen_port_ == 0) {
-        listen_port_ = get_ephemeral_port(server_socket_);
+        listen_port_ = get_bound_port(server_socket_);
         if (listen_port_ == 0) {
             LOG_CLIENT_WARN("Failed to get actual bound port - using port 0");
         } else {
@@ -448,7 +459,7 @@ void RatsClient::handle_client(socket_t client_socket, const std::string& peer_h
         
         // ----- 1. RECEIVE DATA -----
         LOG_CLIENT_DEBUG("Receiving data from socket " << client_socket);
-        std::vector<uint8_t> received_bytes = receive_tcp_message_framed(client_socket);
+        std::vector<uint8_t> received_bytes = receive_tcp_message(client_socket);
         
         if (received_bytes.empty()) {
             break; // Connection closed or error
@@ -897,7 +908,7 @@ bool RatsClient::send_handshake_unlocked(socket_t socket, const std::string& our
     auto socket_mutex = get_socket_send_mutex(socket);
     std::lock_guard<std::mutex> send_lock(*socket_mutex);
     
-    int sent = send_tcp_message_framed(socket, message_with_header);
+    int sent = send_tcp_message(socket, message_with_header);
     if (sent <= 0) {
         LOG_CLIENT_ERROR("Failed to send handshake to socket " << socket);
         return false;
@@ -1412,12 +1423,12 @@ bool RatsClient::send_binary_to_peer_unlocked(socket_t socket, const std::vector
         LOG_CLIENT_DEBUG("Sending encrypted message to " << peer_id_for_logging << " (" << ct_len << " bytes)");
         
         // Send encrypted message using framed protocol
-        int sent = send_tcp_message_framed(socket, ciphertext);
+        int sent = send_tcp_message(socket, ciphertext);
         return sent > 0;
     }
     
     // Unencrypted path - use framed messages for reliable large message handling
-    int sent = send_tcp_message_framed(socket, message_with_header);
+    int sent = send_tcp_message(socket, message_with_header);
     return sent > 0;
 }
 
@@ -1972,6 +1983,33 @@ bool RatsClient::is_automatic_discovery_running() const {
     return auto_discovery_running_.load();
 }
 
+std::chrono::seconds RatsClient::calculate_discovery_interval() const {
+    int peer_count = get_peer_count();
+    
+    // No peers - aggressive discovery
+    if (peer_count == 0) {
+        return std::chrono::seconds(15);
+    }
+    
+    // Calculate fill ratio
+    float fill_ratio = static_cast<float>(peer_count) / static_cast<float>(max_peers_);
+    
+    // Graduated intervals based on fill ratio
+    if (fill_ratio < 0.25f) {
+        // Less than 25% full - still fairly aggressive
+        return std::chrono::seconds(60);       // 1 minute
+    } else if (fill_ratio < 0.50f) {
+        // 25-50% full - moderate
+        return std::chrono::seconds(180);      // 3 minutes
+    } else if (fill_ratio < 0.75f) {
+        // 50-75% full - relaxed
+        return std::chrono::seconds(600);      // 10 minutes
+    } else {
+        // 75-100% full - very relaxed (mostly just re-announcing)
+        return std::chrono::seconds(1800);     // 30 minutes
+    }
+}
+
 void RatsClient::automatic_discovery_loop() {
     LOG_CLIENT_INFO("Automatic peer discovery loop started");
     
@@ -1993,12 +2031,12 @@ void RatsClient::automatic_discovery_loop() {
         auto now = std::chrono::steady_clock::now();
         
         // Announce combines both announcing our presence and discovering peers
-        // Adjust frequency based on whether we have peers
-        auto interval = (get_peer_count() == 0) 
-            ? std::chrono::seconds(15)    // Aggressive when no peers
-            : std::chrono::minutes(10);   // Less aggressive when connected
+        // Interval scales based on peer count: aggressive when empty, relaxed when nearly full
+        auto interval = calculate_discovery_interval();
         
         if (now - last_announce >= interval) {
+            LOG_CLIENT_DEBUG("Discovery interval: " << interval.count() << "s (peers: " 
+                            << get_peer_count() << "/" << max_peers_ << ")");
             announce_rats_peer();
             last_announce = now;
         }

package/native-src/src/librats.h

@@ -636,6 +636,13 @@ public:
      */
     bool is_automatic_discovery_running() const;
     
+    /**
+     * Calculate discovery interval based on current peer count
+     * Uses graduated scaling: more aggressive when fewer peers, less aggressive when nearly full
+     * @return Discovery interval in seconds
+     */
+    std::chrono::seconds calculate_discovery_interval() const;
+    
     /**
      * Get the discovery hash for current protocol configuration
      * @return Discovery hash based on current protocol name and version
@@ -1084,6 +1091,20 @@ public:
      */
     void set_log_retention_count(int count);
     
+    /**
+     * Enable or disable log rotation on application startup
+     * When enabled, the existing log file will be rotated when logging starts,
+     * so each application run gets a fresh log file
+     * @param enabled Whether to rotate logs on startup (default: false)
+     */
+    void set_log_rotate_on_startup(bool enabled);
+    
+    /**
+     * Check if log rotation on startup is enabled
+     * @return true if rotate on startup is enabled
+     */
+    bool is_log_rotate_on_startup_enabled() const;
+    
     /**
      * Clear/reset the current log file
      */

package/native-src/src/librats_bittorrent.cpp

@@ -248,12 +248,13 @@ void RatsClient::get_torrent_metadata_from_peer(const InfoHash& info_hash,
         return;
     }
     
-    LOG_CLIENT_INFO("Fetching metadata from peer " << peer_ip << ":" << peer_port << " (fast path)");
+    LOG_CLIENT_INFO("Fetching metadata from peer " << peer_ip << ":" << peer_port << " (fast path, no DHT)");
     
     // Add magnet in metadata-only mode (empty save_path) and immediately add the peer
+    // skip_dht_search=true to avoid network-wide DHT queries - we only want this specific peer
     std::string hash_hex = info_hash_to_hex(info_hash);
     std::string magnet = "magnet:?xt=urn:btih:" + hash_hex;
-    auto torrent = bittorrent_client_->add_magnet(magnet, "");
+    auto torrent = bittorrent_client_->add_magnet(magnet, "", true /* skip_dht_search */);
     
     if (!torrent) {
         if (callback) {

package/native-src/src/librats_c.cpp

@@ -237,6 +237,18 @@ void rats_set_log_retention_count(rats_client_t handle, int count) {
     wrap->client->set_log_retention_count(count);
 }
 
+void rats_set_log_rotate_on_startup(rats_client_t handle, int enabled) {
+    if (!handle) return;
+    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
+    wrap->client->set_log_rotate_on_startup(enabled != 0);
+}
+
+int rats_is_log_rotate_on_startup_enabled(rats_client_t handle) {
+    if (!handle) return 0;
+    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
+    return wrap->client->is_log_rotate_on_startup_enabled() ? 1 : 0;
+}
+
 void rats_clear_log_file(rats_client_t handle) {
     if (!handle) return;
     rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);

package/native-src/src/librats_c.h

@@ -53,6 +53,8 @@ RATS_API void rats_set_log_timestamps_enabled(rats_client_t client, int enabled)
 RATS_API int rats_is_log_timestamps_enabled(rats_client_t client);
 RATS_API void rats_set_log_rotation_size(rats_client_t client, size_t max_size_bytes);
 RATS_API void rats_set_log_retention_count(rats_client_t client, int count);
+RATS_API void rats_set_log_rotate_on_startup(rats_client_t client, int enabled);
+RATS_API int rats_is_log_rotate_on_startup_enabled(rats_client_t client);
 RATS_API void rats_clear_log_file(rats_client_t client);
 
 // Error codes

package/native-src/src/librats_logging.cpp

@@ -136,6 +136,15 @@ void RatsClient::set_log_retention_count(int count) {
     LOG_CLIENT_INFO("Log retention count set to: " << count << " files");
 }
 
+void RatsClient::set_log_rotate_on_startup(bool enabled) {
+    Logger::getInstance().set_rotate_on_startup(enabled);
+    LOG_CLIENT_INFO("Log rotation on startup " << (enabled ? "enabled" : "disabled"));
+}
+
+bool RatsClient::is_log_rotate_on_startup_enabled() const {
+    return Logger::getInstance().is_rotate_on_startup_enabled();
+}
+
 void RatsClient::clear_log_file() {
     Logger& logger = Logger::getInstance();
     std::string log_path = logger.get_log_file_path();

package/native-src/src/logger.h

@@ -100,6 +100,17 @@ public:
         max_log_files_ = count;
     }
     
+    // Rotate on startup configuration
+    void set_rotate_on_startup(bool enabled) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        rotate_on_startup_ = enabled;
+    }
+    
+    bool is_rotate_on_startup_enabled() const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return rotate_on_startup_;
+    }
+    
     // Get current file logging status
     bool is_file_logging_enabled() const {
         std::lock_guard<std::mutex> lock(mutex_);
@@ -178,7 +189,8 @@ public:
 private:
     Logger() : min_level_(LogLevel::INFO), colors_enabled_(true), timestamps_enabled_(true),
                console_logging_enabled_(true), file_logging_enabled_(false), 
-               max_log_file_size_(10 * 1024 * 1024), max_log_files_(5), current_file_size_(0) {
+               max_log_file_size_(10 * 1024 * 1024), max_log_files_(5), current_file_size_(0),
+               rotate_on_startup_(false), startup_rotation_done_(false) {
         // Check if we're outputting to a terminal
         is_terminal_ = isatty(fileno(stdout));
         
@@ -330,6 +342,19 @@ private:
             }
         }
         
+        // Perform rotation on startup if enabled and not yet done this session
+        if (rotate_on_startup_ && !startup_rotation_done_) {
+            // Check if the log file exists and has content
+            if (file_exists(log_file_path_.c_str())) {
+                std::ifstream check_file(log_file_path_, std::ios::ate);
+                if (check_file.is_open() && check_file.tellg() > 0) {
+                    check_file.close();
+                    rotate_log_files_impl();
+                }
+            }
+            startup_rotation_done_ = true;
+        }
+        
         log_file_.open(log_file_path_, std::ios::app);
         if (log_file_.is_open()) {
             // Get current file size
@@ -350,6 +375,16 @@ private:
         if (log_file_path_.empty() || max_log_files_ <= 0) return;
         
         close_log_file();
+        rotate_log_files_impl();
+        
+        // Reopen the log file (new empty file)
+        open_log_file();
+    }
+    
+    // Internal rotation implementation - does not close/open files
+    // Called directly when we need to rotate before opening (e.g., on startup)
+    void rotate_log_files_impl() {
+        if (log_file_path_.empty() || max_log_files_ <= 0) return;
         
         // Move existing log files
         for (int i = max_log_files_ - 1; i >= 1; i--) {
@@ -368,9 +403,6 @@ private:
         // Move current log file to .1
         std::string backup_name = log_file_path_ + ".1";
         std::rename(log_file_path_.c_str(), backup_name.c_str());
-        
-        // Reopen the log file (new empty file)
-        open_log_file();
     }
     
     mutable std::mutex mutex_;
@@ -389,6 +421,10 @@ private:
     size_t max_log_file_size_;
     int max_log_files_;
     size_t current_file_size_;
+    
+    // Rotate on startup members
+    bool rotate_on_startup_;
+    bool startup_rotation_done_;  // Tracks if we've already done startup rotation for this session
 };
 
 } // namespace librats