librats 0.7.0 → 0.7.2

package/native-src/src/librats.h

@@ -48,9 +48,10 @@ struct RatsPeer {
     // Handshake-related fields
     enum class HandshakeState {
         PENDING,        // Handshake not started
-        SENT,          // Handshake sent, waiting for response
-        COMPLETED,     // Handshake completed successfully
-        FAILED         // Handshake failed
+        SENT,           // Handshake sent, waiting for response
+        NOISE_PENDING,  // Rats handshake done, Noise handshake in progress
+        COMPLETED,      // Handshake completed successfully (including Noise if enabled)
+        FAILED          // Handshake failed
     };
     
     HandshakeState handshake_state;         // Current handshake state
@@ -635,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
@@ -990,6 +998,20 @@ public:
     // Logging Control API
     // =========================================================================
     
+    /**
+     * Enable or disable console logging
+     * When disabled, log messages will not be printed to stdout/stderr
+     * File logging (if enabled) will still work
+     * @param enabled Whether to enable console logging (default: true)
+     */
+    void set_console_logging_enabled(bool enabled);
+    
+    /**
+     * Check if console logging is currently enabled
+     * @return true if console logging is enabled
+     */
+    bool is_console_logging_enabled() const;
+    
     /**
      * Enable or disable file logging
      * When enabled, logs will be written to "rats.log" by default
@@ -1069,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
      */
@@ -2046,15 +2082,16 @@ private:
         std::string message_type;
         int64_t timestamp;
         bool encryption_enabled;  // Whether peer supports/wants encryption
+        uint16_t listen_port;     // Peer's listening port for peer exchange
     };
 
     std::string create_handshake_message(const std::string& message_type, const std::string& our_peer_id) const;
-    bool parse_handshake_message(const std::string& message, HandshakeMessage& out_msg) const;
+    bool parse_handshake_message(const std::vector<uint8_t>& data, HandshakeMessage& out_msg) const;
     bool validate_handshake_message(const HandshakeMessage& msg) const;
-    bool is_handshake_message(const std::string& message) const;
+    bool is_handshake_message(const std::vector<uint8_t>& data) const;
     bool send_handshake(socket_t socket, const std::string& our_peer_id);
     bool send_handshake_unlocked(socket_t socket, const std::string& our_peer_id);
-    bool handle_handshake_message(socket_t socket, const std::string& peer_hash_id, const std::string& message);
+    bool handle_handshake_message(socket_t socket, const std::string& peer_hash_id, const std::vector<uint8_t>& data);
     void check_handshake_timeouts();
     void log_handshake_completion_unlocked(const RatsPeer& peer);
 

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

@@ -161,6 +161,14 @@ char* rats_get_connection_statistics_json(rats_client_t handle) {
     return rats_strdup_owned(json.dump());
 }
 
+void rats_set_console_logging_enabled(int enabled) {
+    Logger::getInstance().set_console_logging_enabled(enabled != 0);
+}
+
+int rats_is_console_logging_enabled(void) {
+    return Logger::getInstance().is_console_logging_enabled() ? 1 : 0;
+}
+
 void rats_set_logging_enabled(int enabled) {
     // Global logger control through any client instance is awkward; use singleton
     Logger::getInstance().set_file_logging_enabled(enabled != 0);
@@ -229,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

@@ -41,6 +41,8 @@ RATS_API char** rats_get_peer_ids(rats_client_t client, int* count); // caller m
 RATS_API char* rats_get_peer_info_json(rats_client_t client, const char* peer_id); // caller must free
 
 // Logging controls (optional helpers)
+RATS_API void rats_set_console_logging_enabled(int enabled);
+RATS_API int rats_is_console_logging_enabled(void);
 RATS_API void rats_set_logging_enabled(int enabled);
 RATS_API void rats_set_log_level(const char* level_str); // "DEBUG", "INFO", "WARN", "ERROR"
 RATS_API void rats_set_log_file_path(rats_client_t client, const char* file_path);
@@ -51,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_encryption.cpp

@@ -103,6 +103,11 @@ std::vector<uint8_t> RatsClient::get_peer_handshake_hash(const std::string& peer
 }
 
 bool RatsClient::send_noise_message(socket_t socket, const uint8_t* data, size_t len) {
+    // Get socket-specific mutex for thread-safe sending
+    // This prevents race conditions with other threads sending rats protocol messages
+    auto socket_mutex = get_socket_send_mutex(socket);
+    std::lock_guard<std::mutex> send_lock(*socket_mutex);
+    
     // Send length-prefixed message for Noise handshake
     uint32_t network_len = htonl(static_cast<uint32_t>(len));
     

package/native-src/src/librats_logging.cpp

@@ -14,6 +14,18 @@ namespace librats {
 // Logging Control API Implementation
 //=============================================================================
 
+void RatsClient::set_console_logging_enabled(bool enabled) {
+    Logger::getInstance().set_console_logging_enabled(enabled);
+    // Only log if console is enabled, otherwise we're silently disabling
+    if (enabled) {
+        LOG_CLIENT_INFO("Console logging enabled");
+    }
+}
+
+bool RatsClient::is_console_logging_enabled() const {
+    return Logger::getInstance().is_console_logging_enabled();
+}
+
 void RatsClient::set_logging_enabled(bool enabled) {
     LOG_CLIENT_INFO("Setting file logging " << (enabled ? "enabled" : "disabled"));
     
@@ -124,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

@@ -59,6 +59,17 @@ public:
         timestamps_enabled_ = enabled;
     }
     
+    // Console logging configuration
+    void set_console_logging_enabled(bool enabled) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        console_logging_enabled_ = enabled;
+    }
+    
+    bool is_console_logging_enabled() const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return console_logging_enabled_;
+    }
+    
     // File logging configuration
     void set_file_logging_enabled(bool enabled) {
         std::lock_guard<std::mutex> lock(mutex_);
@@ -89,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_);
@@ -147,13 +169,15 @@ public:
         // Add message
         console_oss << " " << message << std::endl;
         
-        // Output to appropriate console stream
-        if (level >= LogLevel::ERROR) {
-            std::cerr << console_oss.str();
-            std::cerr.flush();
-        } else {
-            std::cout << console_oss.str();
-            std::cout.flush();
+        // Output to appropriate console stream (if console logging is enabled)
+        if (console_logging_enabled_) {
+            if (level >= LogLevel::ERROR) {
+                std::cerr << console_oss.str();
+                std::cerr.flush();
+            } else {
+                std::cout << console_oss.str();
+                std::cout.flush();
+            }
         }
         
         // Also write to file if file logging is enabled
@@ -164,8 +188,9 @@ public:
 
 private:
     Logger() : min_level_(LogLevel::INFO), colors_enabled_(true), timestamps_enabled_(true),
-               file_logging_enabled_(false), max_log_file_size_(10 * 1024 * 1024), 
-               max_log_files_(5), current_file_size_(0) {
+               console_logging_enabled_(true), file_logging_enabled_(false), 
+               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));
         
@@ -317,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
@@ -337,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--) {
@@ -355,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_;
@@ -366,6 +411,9 @@ private:
     bool timestamps_enabled_;
     bool is_terminal_;
     
+    // Console logging control
+    bool console_logging_enabled_;
+    
     // File logging members
     bool file_logging_enabled_;
     std::string log_file_path_;
@@ -373,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