librats 0.7.0 → 0.7.2

package/native-src/src/dht.cpp

@@ -62,8 +62,19 @@ bool DhtClient::start() {
     }
     
     socket_ = create_udp_socket(port_, bind_address_);
+	// Fallback to free port
+    if (!is_valid_socket(socket_) && port_ > 0) {
+        // Requested port is not available, try ephemeral port as fallback
+        int original_port = port_;
+        LOG_DHT_WARN("UDP port " << original_port << " is not available, falling back to ephemeral port");
+        socket_ = create_udp_socket(0, bind_address_);
+        if (is_valid_socket(socket_)) {
+            port_ = get_bound_port(socket_);
+            LOG_DHT_INFO("Fell back from port " << original_port << " to ephemeral port " << port_);
+        }
+    }
     if (!is_valid_socket(socket_)) {
-        LOG_DHT_ERROR("Failed to create dual-stack UDP socket");
+        LOG_DHT_ERROR("Failed to create dual-stack UDP socket on port " << port_);
         return false;
     }
     
@@ -380,7 +391,7 @@ void DhtClient::network_loop() {
     
     while (running_) {
         Peer sender;
-        auto data = receive_udp_data(socket_, 1500, sender);  // MTU size
+        auto data = receive_udp_data(socket_, 1500, sender, -1);  // MTU size, blocking
         
         if (!data.empty()) {
             LOG_DHT_DEBUG("Received " << data.size() << " bytes from " << sender.ip << ":" << sender.port);
@@ -937,7 +948,8 @@ void DhtClient::handle_krpc_announce_peer(const KrpcMessage& message, const Peer
     }
     
     // Determine the actual port (BEP 5: implied_port support)
-    uint16_t peer_port = message.port;
+    // If implied_port is set, use the UDP source port instead of the explicit port field
+    uint16_t peer_port = message.implied_port ? sender.port : message.port;
     
     // Store the peer announcement
     Peer announcing_peer(sender.ip, peer_port);
@@ -1072,7 +1084,7 @@ bool DhtClient::send_krpc_message(const KrpcMessage& message, const Peer& peer)
     }
     
     LOG_DHT_DEBUG("Sending KRPC message (" << data.size() << " bytes) to " << peer.ip << ":" << peer.port);
-    int result = send_udp_data(socket_, data, peer);
+    int result = send_udp_data(socket_, data, peer.ip, peer.port);
     
     if (result > 0) {
         LOG_DHT_DEBUG("Successfully sent KRPC message to " << peer.ip << ":" << peer.port);
@@ -1101,9 +1113,9 @@ void DhtClient::send_krpc_get_peers(const Peer& peer, const InfoHash& info_hash)
     send_krpc_message(message, peer);
 }
 
-void DhtClient::send_krpc_announce_peer(const Peer& peer, const InfoHash& info_hash, uint16_t port, const std::string& token) {
+void DhtClient::send_krpc_announce_peer(const Peer& peer, const InfoHash& info_hash, uint16_t port, const std::string& token, bool implied_port) {
     std::string transaction_id = KrpcProtocol::generate_transaction_id();
-    auto message = KrpcProtocol::create_announce_peer_query(transaction_id, node_id_, info_hash, port, token);
+    auto message = KrpcProtocol::create_announce_peer_query(transaction_id, node_id_, info_hash, port, token, implied_port);
     send_krpc_message(message, peer);
 }
 
@@ -2138,13 +2150,19 @@ void DhtClient::send_announce_to_closest_nodes(PendingSearch& search) {
     
     LOG_DHT_INFO("Announcing to " << announce_targets.size() << " closest nodes with tokens");
     
+    // BEP 5: Use implied_port when the announce port is the same as the DHT port.
+    // This tells the receiving node to use the UDP source port from the packet,
+    // which is more accurate when behind NAT.
+    bool use_implied_port = (search.announce_port == port_);
+    
     // Send announce_peer to each target
     for (const auto& [node, token] : announce_targets) {
         LOG_DHT_DEBUG("Sending announce_peer to node " << node_id_to_hex(node.id) 
                       << " at " << node.peer.ip << ":" << node.peer.port
-                      << " with token (distance: " << get_bucket_index(node.id) << ")");
+                      << " with token (distance: " << get_bucket_index(node.id) << ")"
+                      << (use_implied_port ? " [implied_port]" : ""));
         
-        send_krpc_announce_peer(node.peer, search.info_hash, search.announce_port, token);
+        send_krpc_announce_peer(node.peer, search.info_hash, search.announce_port, token, use_implied_port);
     }
     
     LOG_DHT_INFO("Announce completed: sent announce_peer to " << announce_targets.size() 

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,14 +459,15 @@ 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
         }
         
         // ----- 2. DECRYPT IF NEEDED -----
-        std::string data;
+        // Use vector directly to avoid unnecessary string conversions
+        std::vector<uint8_t> data;
         
         if (noise_handshake_done) {
             std::string current_peer_id;
@@ -492,16 +504,18 @@ void RatsClient::handle_client(socket_t client_socket, const std::string& peer_h
                 }
                 
                 plaintext.resize(pt_len);
-                data = std::string(plaintext.begin(), plaintext.end());
+                data = std::move(plaintext);
                 LOG_CLIENT_DEBUG("Decrypted message from " << current_peer_id << " (" << pt_len << " bytes)");
             } else {
-                data = std::string(received_bytes.begin(), received_bytes.end());
+                data = std::move(received_bytes);
             }
         } else {
-            data = std::string(received_bytes.begin(), received_bytes.end());
+            data = std::move(received_bytes);
         }
         
-        LOG_CLIENT_DEBUG("Received data from " << peer_hash_id << ": " << data.substr(0, 50) << (data.length() > 50 ? "..." : ""));
+        // Log first 50 bytes for debugging
+        size_t log_len = (std::min)(data.size(), static_cast<size_t>(50));
+        LOG_CLIENT_DEBUG("Received data from " << peer_hash_id << ": " << std::string(data.begin(), data.begin() + log_len) << (data.size() > 50 ? "..." : ""));
         
         // ----- 3. CONNECTION STATE CHECK (during handshake phase only) -----
         if (!handshake_completed) {
@@ -531,51 +545,75 @@ void RatsClient::handle_client(socket_t client_socket, const std::string& peer_h
         }
         
         // ----- 4. HANDSHAKE PHASE -----
-        if (is_handshake_message(data)) {
+        // Only check for handshake messages BEFORE handshake is completed
+        // This avoids expensive JSON parsing on every message after handshake
+        if (!handshake_completed && is_handshake_message(data)) {
             if (!handle_handshake_message(client_socket, peer_hash_id, data)) {
                 LOG_CLIENT_ERROR("Failed to handle handshake message from " << peer_hash_id);
                 break;
             }
             
-            // Check if handshake just completed
+            // Check if rats handshake just completed (COMPLETED or NOISE_PENDING state)
             if (!handshake_completed) {
                 RatsPeer peer_copy;
-                bool just_completed = false;
+                bool rats_handshake_done = false;
+                bool needs_noise_handshake = false;
                 
                 {
                     std::lock_guard<std::mutex> lock(peers_mutex_);
                     auto sock_it = socket_to_peer_id_.find(client_socket);
                     if (sock_it != socket_to_peer_id_.end()) {
                         auto peer_it = peers_.find(sock_it->second);
-                        if (peer_it != peers_.end() && peer_it->second.is_handshake_completed()) {
-                            just_completed = true;
-                            peer_copy = peer_it->second;
+                        if (peer_it != peers_.end()) {
+                            // Check if rats handshake completed (either COMPLETED or NOISE_PENDING)
+                            if (peer_it->second.is_handshake_completed()) {
+                                rats_handshake_done = true;
+                                peer_copy = peer_it->second;
+                            } else if (peer_it->second.handshake_state == RatsPeer::HandshakeState::NOISE_PENDING) {
+                                rats_handshake_done = true;
+                                needs_noise_handshake = true;
+                                peer_copy = peer_it->second;
+                            }
                         }
                     }
                 }
                 
                 // ----- POST-HANDSHAKE ACTIONS -----
-                if (just_completed) {
-                    handshake_completed = true;
-                    LOG_CLIENT_INFO("Handshake completed for peer " << peer_hash_id << " (peer_id: " << peer_copy.peer_id << ")");
+                if (rats_handshake_done) {
+                    LOG_CLIENT_INFO("Rats handshake completed for peer " << peer_hash_id << " (peer_id: " << peer_copy.peer_id << ")");
                     
                     // Remove from reconnection queue if present (successful connection)
                     remove_from_reconnect_queue(peer_copy.peer_id);
                     
                     // Noise encryption handshake - only if BOTH sides support encryption
                     // peer_copy.encryption_enabled is already negotiated in handle_handshake_message()
-                    if (peer_copy.encryption_enabled) {
+                    if (needs_noise_handshake) {
                         LOG_CLIENT_INFO("Starting Noise handshake for peer " << peer_copy.peer_id);
                         if (perform_noise_handshake(client_socket, peer_copy.peer_id, peer_copy.is_outgoing)) {
                             noise_handshake_done = true;
                             LOG_CLIENT_INFO("Noise handshake successful for peer " << peer_copy.peer_id);
+                            
+                            // Update state to COMPLETED after successful Noise handshake
+                            {
+                                std::lock_guard<std::mutex> lock(peers_mutex_);
+                                auto sock_it = socket_to_peer_id_.find(client_socket);
+                                if (sock_it != socket_to_peer_id_.end()) {
+                                    auto peer_it = peers_.find(sock_it->second);
+                                    if (peer_it != peers_.end()) {
+                                        peer_it->second.handshake_state = RatsPeer::HandshakeState::COMPLETED;
+                                        log_handshake_completion_unlocked(peer_it->second);
+                                    }
+                                }
+                            }
                         } else {
                             LOG_CLIENT_ERROR("Noise handshake failed for peer " << peer_copy.peer_id);
+                            // Connection will be closed due to failed Noise handshake
+                            break;
                         }
-                    } else {
-                        LOG_CLIENT_DEBUG("Skipping Noise handshake for peer " << peer_copy.peer_id << " - encryption not negotiated");
                     }
                     
+                    handshake_completed = true;
+                    
                     // Connection callback
                     if (connection_callback_) {
                         connection_callback_(client_socket, peer_copy.peer_id);
@@ -621,11 +659,11 @@ void RatsClient::handle_client(socket_t client_socket, const std::string& peer_h
             continue;
         }
         
-        std::vector<uint8_t> received_data(data.begin(), data.end());
+        // Use data directly - no need for extra copy
         MessageHeader header;
         std::vector<uint8_t> payload;
         
-        if (!parse_message_with_header(received_data, header, payload)) {
+        if (!parse_message_with_header(data, header, payload)) {
             LOG_CLIENT_WARN("No header found in message from " << peer_hash_id);
             continue;
         }
@@ -741,14 +779,15 @@ std::string RatsClient::create_handshake_message(const std::string& message_type
     handshake_msg["message_type"] = message_type;
     handshake_msg["timestamp"] = timestamp;
     handshake_msg["encryption_enabled"] = is_encryption_enabled();
+    handshake_msg["listen_port"] = listen_port_;
     
     return handshake_msg.dump();
 }
 
-bool RatsClient::parse_handshake_message(const std::string& message, HandshakeMessage& out_msg) const {
+bool RatsClient::parse_handshake_message(const std::vector<uint8_t>& data, HandshakeMessage& out_msg) const {
     try {
-        // Use nlohmann::json for proper JSON parsing
-        nlohmann::json json_msg = nlohmann::json::parse(message);
+        // Use nlohmann::json with iterators to avoid string conversion
+        nlohmann::json json_msg = nlohmann::json::parse(data.begin(), data.end());
         
         // Clear the output structure
         out_msg = HandshakeMessage{};
@@ -762,6 +801,8 @@ bool RatsClient::parse_handshake_message(const std::string& message, HandshakeMe
         out_msg.timestamp = json_msg.value("timestamp", static_cast<int64_t>(0));
         // Parse encryption_enabled (default to false for backward compatibility)
         out_msg.encryption_enabled = json_msg.value("encryption_enabled", false);
+        // Parse listen_port (default to 0 for backward compatibility with older clients)
+        out_msg.listen_port = json_msg.value("listen_port", static_cast<uint16_t>(0));
         
         return true;
         
@@ -823,37 +864,30 @@ bool RatsClient::validate_handshake_message(const HandshakeMessage& msg) const {
     return true;
 }
 
-bool RatsClient::is_handshake_message(const std::string& message) const {
+bool RatsClient::is_handshake_message(const std::vector<uint8_t>& data) const {
     try {
-        std::string json_to_parse = message;
-        
         // Check if message has our message header (starts with "RATS" magic)
-        std::vector<uint8_t> message_data(message.begin(), message.end());
         MessageHeader header;
         std::vector<uint8_t> payload;
         
-        if (parse_message_with_header(message_data, header, payload)) {
+        if (parse_message_with_header(data, header, payload)) {
             // Message has valid header - extract the JSON payload
             if (header.type == MessageDataType::STRING || header.type == MessageDataType::JSON) {
-                json_to_parse = std::string(payload.begin(), payload.end());
-            } else {
-                // Handshake messages should be string/JSON type
-                return false;
+                // Parse the JSON message directly from payload
+                nlohmann::json json_msg = nlohmann::json::parse(payload.begin(), payload.end());
+                std::string expected_protocol;
+                {
+                    std::lock_guard<std::mutex> lock(protocol_config_mutex_);
+                    expected_protocol = custom_protocol_name_;
+                }
+                return json_msg.value("protocol", "") == expected_protocol && 
+                       json_msg.value("message_type", "") == "handshake";
             }
-        } else {
-            // Message has no header
+            // Handshake messages should be string/JSON type
             return false;
         }
-        
-        // Parse the JSON message
-        nlohmann::json json_msg = nlohmann::json::parse(json_to_parse);
-        std::string expected_protocol;
-        {
-            std::lock_guard<std::mutex> lock(protocol_config_mutex_);
-            expected_protocol = custom_protocol_name_;
-        }
-        return json_msg.value("protocol", "") == expected_protocol && 
-               json_msg.value("message_type", "") == "handshake";
+        // Message has no header
+        return false;
     } catch (const std::exception&) {
         return false;
     }
@@ -874,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;
@@ -898,28 +932,25 @@ bool RatsClient::send_handshake(socket_t socket, const std::string& our_peer_id)
     return send_handshake_unlocked(socket, our_peer_id);
 }
 
-bool RatsClient::handle_handshake_message(socket_t socket, const std::string& peer_hash_id, const std::string& message) {
-    // Extract JSON payload from message header if present
-    std::string json_to_parse = message;
-    std::vector<uint8_t> message_data(message.begin(), message.end());
+bool RatsClient::handle_handshake_message(socket_t socket, const std::string& peer_hash_id, const std::vector<uint8_t>& data) {
+    // Extract JSON payload from message header
     MessageHeader header;
     std::vector<uint8_t> payload;
     
-    if (parse_message_with_header(message_data, header, payload)) {
-        // Message has valid header - extract the JSON payload
-        if (header.type == MessageDataType::STRING || header.type == MessageDataType::JSON) {
-            json_to_parse = std::string(payload.begin(), payload.end());
-        } else {
-            LOG_CLIENT_ERROR("Invalid message type for handshake: " << static_cast<int>(header.type));
-            return false;
-        }
-    } else {
+    if (!parse_message_with_header(data, header, payload)) {
         LOG_CLIENT_ERROR("Failed to parse handshake message header from " << peer_hash_id);
         return false;
     }
     
+    // Message has valid header - check the type
+    if (header.type != MessageDataType::STRING && header.type != MessageDataType::JSON) {
+        LOG_CLIENT_ERROR("Invalid message type for handshake: " << static_cast<int>(header.type));
+        return false;
+    }
+    
+    // Parse handshake message directly from payload (no string conversion)
     HandshakeMessage handshake_msg;
-    if (!parse_handshake_message(json_to_parse, handshake_msg)) {
+    if (!parse_handshake_message(payload, handshake_msg)) {
         LOG_CLIENT_ERROR("Failed to parse handshake message from " << peer_hash_id);
         return false;
     }
@@ -995,12 +1026,35 @@ bool RatsClient::handle_handshake_message(socket_t socket, const std::string& pe
                     << ", remote=" << remote_encryption 
                     << ", result=" << peer.encryption_enabled);
     
+    // For incoming connections, update port to the peer's actual listen port
+    // This is critical for peer exchange to work correctly
+    if (!peer.is_outgoing && handshake_msg.listen_port > 0) {
+        // Remove old address mapping
+        address_to_peer_id_.erase(peer.normalized_address);
+        
+        // Update port and normalized address
+        peer.port = handshake_msg.listen_port;
+        peer.normalized_address = normalize_peer_address(peer.ip, peer.port);
+        
+        // Add new address mapping
+        address_to_peer_id_[peer.normalized_address] = peer.peer_id;
+        
+        LOG_CLIENT_INFO("Updated incoming peer port to listen_port: " << peer.ip << ":" << peer.port);
+    }
+    
     // Simplified handshake logic - just one message type
     if (peer.handshake_state == RatsPeer::HandshakeState::PENDING) {
         // This is an incoming handshake - send our handshake back
         if (send_handshake_unlocked(socket, get_our_peer_id())) {
-            peer.handshake_state = RatsPeer::HandshakeState::COMPLETED;
-            log_handshake_completion_unlocked(peer);
+            // If encryption is enabled, we need to do Noise handshake first
+            // Set NOISE_PENDING to prevent other threads from sending messages
+            if (peer.encryption_enabled) {
+                peer.handshake_state = RatsPeer::HandshakeState::NOISE_PENDING;
+                LOG_CLIENT_DEBUG("Rats handshake done, entering NOISE_PENDING state for " << peer_hash_id);
+            } else {
+                peer.handshake_state = RatsPeer::HandshakeState::COMPLETED;
+                log_handshake_completion_unlocked(peer);
+            }
             
             // Append to historical peers file after successful connection
             append_peer_to_historical_file(peer);
@@ -1013,8 +1067,15 @@ bool RatsClient::handle_handshake_message(socket_t socket, const std::string& pe
         }
     } else if (peer.handshake_state == RatsPeer::HandshakeState::SENT) {
         // This is a response to our handshake
-        peer.handshake_state = RatsPeer::HandshakeState::COMPLETED;
-        log_handshake_completion_unlocked(peer);
+        // If encryption is enabled, we need to do Noise handshake first
+        // Set NOISE_PENDING to prevent other threads from sending messages
+        if (peer.encryption_enabled) {
+            peer.handshake_state = RatsPeer::HandshakeState::NOISE_PENDING;
+            LOG_CLIENT_DEBUG("Rats handshake done, entering NOISE_PENDING state for " << peer_hash_id);
+        } else {
+            peer.handshake_state = RatsPeer::HandshakeState::COMPLETED;
+            log_handshake_completion_unlocked(peer);
+        }
         
         // Append to historical peers file after successful connection
         append_peer_to_historical_file(peer);
@@ -1362,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;
 }
 
@@ -1922,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");
     
@@ -1943,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;
         }
@@ -2377,8 +2465,8 @@ nlohmann::json RatsClient::create_peer_exchange_message(const RatsPeer& peer) {
     payload["peer_id"] = peer.peer_id;
     payload["connection_type"] = peer.is_outgoing ? "outgoing" : "incoming";
     
-    // Create rats message
-    return create_rats_message("peer", payload, peer.peer_id);
+    // Create rats message - use OUR peer_id as sender, not the advertised peer's id
+    return create_rats_message("peer", payload, get_our_peer_id());
 }
 
 void RatsClient::broadcast_peer_exchange_message(const RatsPeer& new_peer) {