librats 0.5.1 → 0.5.3

package/native-src/src/dht.cpp

@@ -210,7 +210,7 @@ bool DhtClient::find_peers(const InfoHash& info_hash, PeerDiscoveryCallback call
     return true;
 }
 
-bool DhtClient::announce_peer(const InfoHash& info_hash, uint16_t port) {
+bool DhtClient::announce_peer(const InfoHash& info_hash, uint16_t port, PeerDiscoveryCallback callback) {
     if (!running_) {
         LOG_DHT_ERROR("DHT client not running");
         return false;
@@ -220,24 +220,64 @@ bool DhtClient::announce_peer(const InfoHash& info_hash, uint16_t port) {
         port = port_;
     }
     
-    LOG_DHT_INFO("Announcing peer for info hash: " << node_id_to_hex(info_hash) << " on port " << port);
+    std::string hash_key = node_id_to_hex(info_hash);
+    LOG_DHT_INFO("Announcing peer for info hash: " << hash_key << " on port " << port);
     
-    // First find nodes close to the info hash and send get_peers to them
-    // This is the proper BEP 5 flow: get_peers -> collect tokens -> announce_peer
-    auto closest_nodes = find_closest_nodes(info_hash, ALPHA);
-    for (const auto& node : closest_nodes) {
-            // Generate transaction ID and track this as a pending announce for KRPC
-            std::string transaction_id = KrpcProtocol::generate_transaction_id();
-            
-            {
-                std::lock_guard<std::mutex> lock(pending_announces_mutex_);
-                pending_announces_.emplace(transaction_id, PendingAnnounce(info_hash, port));
+    // BEP 5 compliant announce: 
+    // 1. Perform iterative Kademlia lookup (like find_peers)
+    // 2. Collect tokens from responding nodes
+    // 3. Send announce_peer to k closest nodes with their tokens
+    
+    // Get initial nodes from routing table
+    auto closest_nodes = find_closest_nodes(info_hash, K_BUCKET_SIZE);
+    
+    if (closest_nodes.empty()) {
+        LOG_DHT_WARN("No nodes in routing table to announce to for info_hash " << hash_key);
+        return false;
+    }
+    
+    DeferredCallbacks deferred;
+    
+    {
+        std::lock_guard<std::mutex> lock(pending_searches_mutex_);
+        
+        // Check if a search/announce is already ongoing for this info_hash
+        auto search_it = pending_searches_.find(hash_key);
+        if (search_it != pending_searches_.end()) {
+            if (search_it->second.is_announce) {
+                LOG_DHT_INFO("Announce already in progress for info hash " << hash_key);
+                return true;
             }
-            
-            auto message = KrpcProtocol::create_get_peers_query(transaction_id, node_id_, info_hash);
-            send_krpc_message(message, node.peer);
+            // Regular find_peers in progress - let it complete, then user can announce again
+            LOG_DHT_WARN("find_peers already in progress for info hash " << hash_key << " - announce will wait");
+            return false;
+        }
+        
+        // Create new search with announce flag
+        PendingSearch new_search(info_hash);
+        new_search.is_announce = true;
+        new_search.announce_port = port;
+        
+        // Add callback if provided - peers discovered during traversal will be returned through it
+        if (callback) {
+            new_search.callbacks.push_back(callback);
+        }
+        
+        // Initialize search_nodes with closest nodes from routing table (already sorted)
+        new_search.search_nodes = std::move(closest_nodes);
+        
+        auto insert_result = pending_searches_.emplace(hash_key, std::move(new_search));
+        PendingSearch& search_ref = insert_result.first->second;
+        
+        LOG_DHT_DEBUG("Initialized announce search with " << search_ref.search_nodes.size() << " nodes from routing table");
+        
+        // Start sending requests
+        add_search_requests(search_ref, deferred);
     }
     
+    // Invoke callbacks outside the lock to avoid deadlock
+    deferred.invoke();
+    
     return true;
 }
 
@@ -262,6 +302,13 @@ bool DhtClient::is_search_active(const InfoHash& info_hash) const {
     return it != pending_searches_.end() && !it->second.is_finished;
 }
 
+bool DhtClient::is_announce_active(const InfoHash& info_hash) const {
+    std::lock_guard<std::mutex> lock(pending_searches_mutex_);
+    std::string hash_key = node_id_to_hex(info_hash);
+    auto it = pending_searches_.find(hash_key);
+    return it != pending_searches_.end() && !it->second.is_finished && it->second.is_announce;
+}
+
 size_t DhtClient::get_active_searches_count() const {
     std::lock_guard<std::mutex> lock(pending_searches_mutex_);
     size_t count = 0;
@@ -273,6 +320,17 @@ size_t DhtClient::get_active_searches_count() const {
     return count;
 }
 
+size_t DhtClient::get_active_announces_count() const {
+    std::lock_guard<std::mutex> lock(pending_searches_mutex_);
+    size_t count = 0;
+    for (const auto& [hash, search] : pending_searches_) {
+        if (!search.is_finished && search.is_announce) {
+            count++;
+        }
+    }
+    return count;
+}
+
 std::vector<Peer> DhtClient::get_default_bootstrap_nodes() {
     return {
         {"router.bittorrent.com", 6881},
@@ -340,9 +398,6 @@ void DhtClient::maintenance_loop() {
             // Cleanup stale peer tokens
             cleanup_stale_peer_tokens();
             
-            // Cleanup stale pending announces
-            cleanup_stale_announces();
-            
             // Cleanup stale pending searches
             cleanup_stale_searches();
             
@@ -402,7 +457,7 @@ void DhtClient::handle_message(const std::vector<uint8_t>& data, const Peer& sen
     handle_krpc_message(*krpc_message, sender);
 }
 
-void DhtClient::add_node(const DhtNode& node, bool confirmed) {
+void DhtClient::add_node(const DhtNode& node, bool confirmed, bool no_verify) {
     std::lock_guard<std::mutex> ping_lock(pending_pings_mutex_);
     std::lock_guard<std::mutex> lock(routing_table_mutex_);
 
@@ -460,7 +515,7 @@ void DhtClient::add_node(const DhtNode& node, bool confirmed) {
         return;
     }
 
-    // All nodes are good - find the "worst" good node for ping verification
+    // All nodes are good - find the "worst" good node for ping verification or replacement
     // Worst = highest RTT among nodes not already being pinged
     DhtNode* worst = nullptr;
     for (auto& existing : bucket) {
@@ -476,6 +531,19 @@ void DhtClient::add_node(const DhtNode& node, bool confirmed) {
         return;
     }
     
+    // If no_verify is set, directly replace the worst node without ping verification
+    if (no_verify) {
+        LOG_DHT_DEBUG("Force adding node " << node_id_to_hex(node.id) 
+                      << " - replacing worst node " << node_id_to_hex(worst->id) 
+                      << " (rtt=" << worst->rtt << "ms) without ping verification");
+        DhtNode new_node = node;
+        if (confirmed) {
+            new_node.fail_count = 0;
+        }
+        *worst = new_node;
+        return;
+    }
+    
     // Initiate ping to worst node - if it doesn't respond, replace with candidate
     LOG_DHT_DEBUG("All nodes good, pinging worst node " << node_id_to_hex(worst->id) 
                   << " (rtt=" << worst->rtt << "ms) to verify");
@@ -502,7 +570,7 @@ std::vector<DhtNode> DhtClient::find_closest_nodes_unlocked(const NodeId& target
     candidates.reserve(count * 3 + K_BUCKET_SIZE * 2);
     
     // Add nodes from ideal bucket
-    if (target_bucket < routing_table_.size()) {
+    if (target_bucket >= 0 && static_cast<size_t>(target_bucket) < routing_table_.size()) {
         const auto& bucket = routing_table_[target_bucket];
         candidates.insert(candidates.end(), bucket.begin(), bucket.end());
         LOG_DHT_DEBUG("Collected " << bucket.size() << " nodes from target bucket " << target_bucket);
@@ -602,11 +670,11 @@ int DhtClient::get_bucket_index(const NodeId& id) {
     NodeId distance = xor_distance(node_id_, id);
     
     // Find the position of the most significant bit
-    for (int i = 0; i < NODE_ID_SIZE; ++i) {
+    for (size_t i = 0; i < NODE_ID_SIZE; ++i) {
         if (distance[i] != 0) {
             for (int j = 7; j >= 0; --j) {
                 if (distance[i] & (1 << j)) {
-                    return i * 8 + (7 - j);
+                    return static_cast<int>(i * 8 + (7 - j));
                 }
             }
         }
@@ -650,10 +718,20 @@ void DhtClient::handle_krpc_message(const KrpcMessage& message, const Peer& send
 void DhtClient::handle_krpc_ping(const KrpcMessage& message, const Peer& sender) {
     LOG_DHT_DEBUG("Handling KRPC PING from " << node_id_to_hex(message.sender_id) << " at " << sender.ip << ":" << sender.port);
     
+#ifdef RATS_SEARCH_FEATURES
+    // Spider mode: check if ignoring requests
+    if (spider_mode_.load() && spider_ignore_.load()) {
+        return;
+    }
+    bool no_verify = spider_mode_.load();
+#else
+    bool no_verify = false;
+#endif
+    
     // Add sender to routing table
     KrpcNode krpc_node(message.sender_id, sender.ip, sender.port);
     DhtNode sender_node = krpc_node_to_dht_node(krpc_node);
-    add_node(sender_node);
+    add_node(sender_node, true, no_verify);
     
     // Respond with ping response
     auto response = KrpcProtocol::create_ping_response(message.transaction_id, node_id_);
@@ -663,10 +741,20 @@ void DhtClient::handle_krpc_ping(const KrpcMessage& message, const Peer& sender)
 void DhtClient::handle_krpc_find_node(const KrpcMessage& message, const Peer& sender) {
     LOG_DHT_DEBUG("Handling KRPC FIND_NODE from " << node_id_to_hex(message.sender_id) << " at " << sender.ip << ":" << sender.port);
     
+#ifdef RATS_SEARCH_FEATURES
+    // Spider mode: check if ignoring requests
+    if (spider_mode_.load() && spider_ignore_.load()) {
+        return;
+    }
+    bool no_verify = spider_mode_.load();
+#else
+    bool no_verify = false;
+#endif
+    
     // Add sender to routing table
     KrpcNode krpc_node(message.sender_id, sender.ip, sender.port);
     DhtNode sender_node = krpc_node_to_dht_node(krpc_node);
-    add_node(sender_node);
+    add_node(sender_node, true, no_verify);
     
     // Find closest nodes
     auto closest_nodes = find_closest_nodes(message.target_id, K_BUCKET_SIZE);
@@ -680,10 +768,20 @@ void DhtClient::handle_krpc_find_node(const KrpcMessage& message, const Peer& se
 void DhtClient::handle_krpc_get_peers(const KrpcMessage& message, const Peer& sender) {
     LOG_DHT_DEBUG("Handling KRPC GET_PEERS from " << node_id_to_hex(message.sender_id) << " at " << sender.ip << ":" << sender.port << " for info_hash " << node_id_to_hex(message.info_hash));
     
+#ifdef RATS_SEARCH_FEATURES
+    // Spider mode: check if ignoring requests
+    if (spider_mode_.load() && spider_ignore_.load()) {
+        return;
+    }
+    bool no_verify = spider_mode_.load();
+#else
+    bool no_verify = false;
+#endif
+    
     // Add sender to routing table
     KrpcNode krpc_node(message.sender_id, sender.ip, sender.port);
     DhtNode sender_node = krpc_node_to_dht_node(krpc_node);
-    add_node(sender_node);
+    add_node(sender_node, true, no_verify);
     
     // Generate a token for this peer
     std::string token = generate_token(sender);
@@ -710,6 +808,20 @@ void DhtClient::handle_krpc_get_peers(const KrpcMessage& message, const Peer& se
 void DhtClient::handle_krpc_announce_peer(const KrpcMessage& message, const Peer& sender) {
     LOG_DHT_DEBUG("Handling KRPC ANNOUNCE_PEER from " << node_id_to_hex(message.sender_id) << " at " << sender.ip << ":" << sender.port);
     
+#ifdef RATS_SEARCH_FEATURES
+    bool is_spider = spider_mode_.load();
+    
+    // Spider mode: check if ignoring requests (but still process announces for callback)
+    // Note: We still want to collect announces even when ignoring other requests
+    
+    // In spider mode, skip token verification for maximum collection
+    if (!is_spider && !verify_token(sender, message.token)) {
+        LOG_DHT_WARN("Invalid token from " << sender.ip << ":" << sender.port << " for KRPC ANNOUNCE_PEER");
+        auto error = KrpcProtocol::create_error(message.transaction_id, KrpcErrorCode::ProtocolError, "Invalid token");
+        send_krpc_message(error, sender);
+        return;
+    }
+#else
     // Verify token
     if (!verify_token(sender, message.token)) {
         LOG_DHT_WARN("Invalid token from " << sender.ip << ":" << sender.port << " for KRPC ANNOUNCE_PEER");
@@ -717,16 +829,37 @@ void DhtClient::handle_krpc_announce_peer(const KrpcMessage& message, const Peer
         send_krpc_message(error, sender);
         return;
     }
+    bool is_spider = false;
+#endif
     
     // Add sender to routing table
     KrpcNode krpc_node(message.sender_id, sender.ip, sender.port);
     DhtNode sender_node = krpc_node_to_dht_node(krpc_node);
-    add_node(sender_node);
+    add_node(sender_node, true, is_spider);
+    
+    // Determine the actual port (BEP 5: implied_port support)
+    uint16_t peer_port = message.port;
     
     // Store the peer announcement
-    Peer announcing_peer(sender.ip, message.port);
+    Peer announcing_peer(sender.ip, peer_port);
     store_announced_peer(message.info_hash, announcing_peer);
     
+#ifdef RATS_SEARCH_FEATURES
+    // Spider mode: invoke announce callback (ensured hash - peer definitely has it)
+    if (is_spider) {
+        SpiderAnnounceCallback callback;
+        {
+            std::lock_guard<std::mutex> lock(spider_callbacks_mutex_);
+            callback = spider_announce_callback_;
+        }
+        if (callback) {
+            LOG_DHT_DEBUG("Spider: invoking announce callback for info_hash " << node_id_to_hex(message.info_hash) 
+                          << " from " << announcing_peer.ip << ":" << announcing_peer.port);
+            callback(message.info_hash, announcing_peer);
+        }
+    }
+#endif
+    
     // Respond with acknowledgment
     auto response = KrpcProtocol::create_announce_peer_response(message.transaction_id, node_id_);
     send_krpc_message(response, sender);
@@ -738,15 +871,21 @@ void DhtClient::handle_krpc_response(const KrpcMessage& message, const Peer& sen
     // Check if this is a ping verification response before normal processing
     handle_ping_verification_response(message.transaction_id, message.response_id, sender);
     
+#ifdef RATS_SEARCH_FEATURES
+    bool no_verify = spider_mode_.load();
+#else
+    bool no_verify = false;
+#endif
+    
     // Add responder to routing table
     KrpcNode krpc_node(message.response_id, sender.ip, sender.port);
     DhtNode sender_node = krpc_node_to_dht_node(krpc_node);
-    add_node(sender_node);
+    add_node(sender_node, true, no_verify);
     
     // Add any nodes from the response (these are nodes we heard about, not confirmed)
     for (const auto& node : message.nodes) {
         DhtNode dht_node = krpc_node_to_dht_node(node);
-        add_node(dht_node, false);  // Not confirmed - just heard about from another node
+        add_node(dht_node, false, no_verify);  // Not confirmed - just heard about from another node
     }
     
     // Check if this is a response to a pending search (get_peers with peers)
@@ -763,9 +902,16 @@ void DhtClient::handle_krpc_response(const KrpcMessage& message, const Peer& sen
         handle_get_peers_empty_response(message.transaction_id, sender);
     }
     
-    // Check if this is a response to a pending announce (get_peers with token)
+    // Save write token if present (needed for announce_peer after traversal completes)
     if (!message.token.empty()) {
-        handle_get_peers_response_for_announce(message.transaction_id, sender, message.token);
+        std::lock_guard<std::mutex> lock(pending_searches_mutex_);
+        auto trans_it = transaction_to_search_.find(message.transaction_id);
+        if (trans_it != transaction_to_search_.end()) {
+            auto search_it = pending_searches_.find(trans_it->second.info_hash_hex);
+            if (search_it != pending_searches_.end()) {
+                save_write_token(search_it->second, trans_it->second.queried_node_id, message.token);
+            }
+        }
     }
     
     // Clean up finished searches AFTER all response data has been processed
@@ -1028,8 +1174,10 @@ void DhtClient::print_statistics() {
     
     // Pending searches statistics
     size_t pending_searches = 0;
+    size_t pending_announces = 0;
     size_t total_search_nodes = 0;
     size_t total_found_peers = 0;
+    size_t total_write_tokens = 0;
     size_t active_transactions = 0;
     {
         std::lock_guard<std::mutex> search_lock(pending_searches_mutex_);
@@ -1038,16 +1186,13 @@ void DhtClient::print_statistics() {
         for (const auto& [hash, search] : pending_searches_) {
             total_search_nodes += search.search_nodes.size();
             total_found_peers += search.found_peers.size();
+            total_write_tokens += search.write_tokens.size();
+            if (search.is_announce) {
+                pending_announces++;
+            }
         }
     }
     
-    // Pending announces statistics
-    size_t pending_announces_count = 0;
-    {
-        std::lock_guard<std::mutex> announce_lock(pending_announces_mutex_);
-        pending_announces_count = pending_announces_.size();
-    }
-    
     // Announced peers statistics
     size_t announced_peers_total = 0;
     size_t announced_peers_infohashes = 0;
@@ -1084,9 +1229,11 @@ void DhtClient::print_statistics() {
                  << ", Max bucket size: " << max_bucket_size << "/" << K_BUCKET_SIZE);
     LOG_DHT_INFO("[ACTIVE OPERATIONS]");
     LOG_DHT_INFO("  Pending searches: " << pending_searches 
-                 << " (nodes: " << total_search_nodes << ", found peers: " << total_found_peers << ")");
+                 << " (announces: " << pending_announces 
+                 << ", nodes: " << total_search_nodes 
+                 << ", peers: " << total_found_peers 
+                 << ", tokens: " << total_write_tokens << ")");
     LOG_DHT_INFO("  Active transactions: " << active_transactions);
-    LOG_DHT_INFO("  Pending announces: " << pending_announces_count);
     LOG_DHT_INFO("  Pending ping verifications: " << pending_pings 
                  << " (nodes being replaced: " << nodes_being_replaced << ")");
     LOG_DHT_INFO("[STORED DATA]");
@@ -1184,9 +1331,9 @@ void DhtClient::refresh_buckets() {
             int byte_index = static_cast<int>(i / 8);
             int bit_index = static_cast<int>(i % 8);
             
-            if (byte_index < NODE_ID_SIZE) {
+            if (static_cast<size_t>(byte_index) < NODE_ID_SIZE) {
                 // Clear the target bit and higher bits
-                for (int j = byte_index; j < NODE_ID_SIZE; ++j) {
+                for (size_t j = static_cast<size_t>(byte_index); j < NODE_ID_SIZE; ++j) {
                     random_id[j] = node_id_[j];
                 }
                 
@@ -1203,23 +1350,6 @@ void DhtClient::refresh_buckets() {
     }
 }
 
-void DhtClient::cleanup_stale_announces() {
-    std::lock_guard<std::mutex> lock(pending_announces_mutex_);
-    
-    auto now = std::chrono::steady_clock::now();
-    auto stale_threshold = std::chrono::minutes(5);  // Remove announces older than 5 minutes
-    
-    auto it = pending_announces_.begin();
-    while (it != pending_announces_.end()) {
-        if (now - it->second.created_at > stale_threshold) {
-            LOG_DHT_DEBUG("Removing stale pending announce for transaction " << it->first);
-            it = pending_announces_.erase(it);
-        } else {
-            ++it;
-        }
-    }
-}
-
 void DhtClient::cleanup_stale_searches() {
     std::lock_guard<std::mutex> lock(pending_searches_mutex_);
     
@@ -1475,24 +1605,6 @@ void DhtClient::cleanup_timed_out_search_requests() {
     }
 }
 
-void DhtClient::handle_get_peers_response_for_announce(const std::string& transaction_id, const Peer& responder, const std::string& token) {
-    std::lock_guard<std::mutex> lock(pending_announces_mutex_);
-    
-    auto it = pending_announces_.find(transaction_id);
-    if (it != pending_announces_.end()) {
-        const auto& pending_announce = it->second;
-        LOG_DHT_DEBUG("Found pending announce for transaction " << transaction_id 
-                      << " - sending announce_peer for info_hash " << node_id_to_hex(pending_announce.info_hash) 
-                      << " to " << responder.ip << ":" << responder.port);
-        
-        // Send announce_peer with the received token
-        send_krpc_announce_peer(responder, pending_announce.info_hash, pending_announce.port, token);
-        
-        // Remove the pending announce since we've handled it
-        pending_announces_.erase(it);
-    }
-}
-
 void DhtClient::handle_get_peers_empty_response(const std::string& transaction_id, const Peer& responder) {
     DeferredCallbacks deferred;
     {
@@ -1796,6 +1908,86 @@ void DhtClient::add_node_to_search(PendingSearch& search, const DhtNode& node) {
     }
 }
 
+void DhtClient::save_write_token(PendingSearch& search, const NodeId& node_id, const std::string& token) {
+    // Save the write token received from a node (BEP 5 compliant)
+    // This token will be used later when sending announce_peer to this node
+    
+    if (token.empty()) {
+        return;
+    }
+    
+    // Only save token if we don't already have one from this node
+    // (first token is usually the valid one)
+    if (search.write_tokens.find(node_id) == search.write_tokens.end()) {
+        search.write_tokens[node_id] = token;
+        LOG_DHT_DEBUG("Saved write token from node " << node_id_to_hex(node_id) 
+                      << " for info_hash " << node_id_to_hex(search.info_hash)
+                      << " (total tokens: " << search.write_tokens.size() << ")");
+    }
+}
+
+void DhtClient::send_announce_to_closest_nodes(PendingSearch& search) {
+    // BEP 5: Send announce_peer to the k closest nodes that:
+    // 1. Responded to our get_peers query
+    // 2. Gave us a valid write token
+    
+    if (!search.is_announce) {
+        return;
+    }
+    
+    std::string hash_key = node_id_to_hex(search.info_hash);
+    
+    LOG_DHT_INFO("Sending announce_peer to closest nodes for info_hash " << hash_key 
+                 << " on port " << search.announce_port);
+    
+    // Collect nodes that responded and have tokens, sorted by distance (closest first)
+    std::vector<std::pair<DhtNode, std::string>> announce_targets;
+    announce_targets.reserve(K_BUCKET_SIZE);
+    
+    for (const auto& node : search.search_nodes) {
+        if (announce_targets.size() >= K_BUCKET_SIZE) {
+            break;  // We have enough targets
+        }
+        
+        // Check if node responded successfully
+        auto state_it = search.node_states.find(node.id);
+        if (state_it == search.node_states.end()) {
+            continue;
+        }
+        if (!(state_it->second & SearchNodeFlags::RESPONDED)) {
+            continue;  // Node didn't respond
+        }
+        
+        // Check if we have a token from this node
+        auto token_it = search.write_tokens.find(node.id);
+        if (token_it == search.write_tokens.end()) {
+            LOG_DHT_DEBUG("Node " << node_id_to_hex(node.id) << " responded but no token - skipping");
+            continue;  // No token from this node
+        }
+        
+        announce_targets.emplace_back(node, token_it->second);
+    }
+    
+    if (announce_targets.empty()) {
+        LOG_DHT_WARN("No nodes with tokens to announce to for info_hash " << hash_key);
+        return;
+    }
+    
+    LOG_DHT_INFO("Announcing to " << announce_targets.size() << " closest nodes with tokens");
+    
+    // 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) << ")");
+        
+        send_krpc_announce_peer(node.peer, search.info_hash, search.announce_port, token);
+    }
+    
+    LOG_DHT_INFO("Announce completed: sent announce_peer to " << announce_targets.size() 
+                 << " nodes for info_hash " << hash_key);
+}
+
 bool DhtClient::add_search_requests(PendingSearch& search, DeferredCallbacks& deferred) {
     // Returns true if search is done (completed or should be finished)
     
@@ -1875,7 +2067,7 @@ bool DhtClient::add_search_requests(PendingSearch& search, DeferredCallbacks& de
         queries_sent++;
     }
     
-    LOG_DHT_DEBUG("Search [" << hash_key << "] progress [ms: " << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - search.created_at).count() << "]:");
+    LOG_DHT_DEBUG((search.is_announce ? "Announce" : "Search") << " [" << hash_key << "] progress [ms: " << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - search.created_at).count() << "]:");
     LOG_DHT_DEBUG(" * search_nodes: " << search.search_nodes.size());
     LOG_DHT_DEBUG(" * queries_sent: " << queries_sent);
     LOG_DHT_DEBUG(" * invoke_count: " << search.invoke_count);
@@ -1903,7 +2095,7 @@ bool DhtClient::add_search_requests(PendingSearch& search, DeferredCallbacks& de
             if (f & SearchNodeFlags::ABANDONED) abandoned_total++;
         }
         
-        LOG_DHT_INFO("=== Search Completed for info_hash " << hash_key << " ===");
+        LOG_DHT_INFO("=== " << (search.is_announce ? "Announce" : "Search") << " Completed for info_hash " << hash_key << " ===");
         LOG_DHT_INFO("  Duration: " << duration_ms << "ms");
         LOG_DHT_INFO("  Total nodes queried: " << queried_total);
         LOG_DHT_INFO("  Total nodes responded: " << responded_total);
@@ -1911,8 +2103,18 @@ bool DhtClient::add_search_requests(PendingSearch& search, DeferredCallbacks& de
         LOG_DHT_INFO("  Nodes with short timeout: " << short_timeout_total);
         LOG_DHT_INFO("  Nodes abandoned (truncation): " << abandoned_total);
         LOG_DHT_INFO("  Final branch_factor: " << search.branch_factor << " (initial: " << ALPHA << ")");
-        LOG_DHT_INFO("  Total peers found: " << search.found_peers.size());
-        LOG_DHT_INFO("  Callbacks to invoke: " << search.callbacks.size());
+        if (search.is_announce) {
+            LOG_DHT_INFO("  Write tokens collected: " << search.write_tokens.size());
+            LOG_DHT_INFO("  Announce port: " << search.announce_port);
+        } else {
+            LOG_DHT_INFO("  Total peers found: " << search.found_peers.size());
+            LOG_DHT_INFO("  Callbacks to invoke: " << search.callbacks.size());
+        }
+        
+        // If this is an announce search, send announce_peer to k closest nodes with tokens
+        if (search.is_announce) {
+            send_announce_to_closest_nodes(search);
+        }
         
         // Collect callbacks for deferred invocation (avoid deadlock - don't call user callbacks while holding mutex)
         deferred.should_invoke = true;
@@ -2038,6 +2240,25 @@ void DhtClient::handle_ping_verification_response(const std::string& transaction
     if (it != pending_pings_.end()) {
         const auto& verification = it->second;
         
+        // Security check: Verify response comes from the IP we pinged
+        // Normalize IPv6-mapped IPv4 addresses (::ffff:x.x.x.x -> x.x.x.x) for comparison
+        auto normalize_ip = [](const std::string& ip) -> std::string {
+            const std::string ipv4_mapped_prefix = "::ffff:";
+            if (ip.compare(0, ipv4_mapped_prefix.size(), ipv4_mapped_prefix) == 0) {
+                return ip.substr(ipv4_mapped_prefix.size());
+            }
+            return ip;
+        };
+        
+        std::string responder_ip_normalized = normalize_ip(responder.ip);
+        std::string expected_ip_normalized = normalize_ip(verification.old_node.peer.ip);
+        
+        if (responder_ip_normalized != expected_ip_normalized) {
+            LOG_DHT_WARN("Ping verification response from wrong IP " << responder.ip 
+                         << " (expected " << verification.old_node.peer.ip << ") - ignoring");
+            return;  // Don't remove from pending_pings_, let it timeout naturally
+        }
+        
         // BEP 5: We pinged the OLD node to check if it's still alive
         if (responder_id == verification.old_node.id) {
             // Calculate RTT
@@ -2064,9 +2285,19 @@ void DhtClient::handle_ping_verification_response(const std::string& transaction
             }
             // Candidate is discarded (not added to routing table)
         } else {
-            LOG_DHT_WARN("Ping verification response from unexpected node " << node_id_to_hex(responder_id) 
-                         << " at " << responder.ip << ":" << responder.port 
-                         << " (expected old node " << node_id_to_hex(verification.old_node.id) << ")");
+            // Different node ID responded from the same IP:port!
+            // This means the old node is gone and this IP now belongs to a different node.
+            // Replace the old node with the candidate.
+            LOG_DHT_DEBUG("Different node " << node_id_to_hex(responder_id) 
+                         << " responded from " << responder.ip << ":" << responder.port 
+                         << " (expected old node " << node_id_to_hex(verification.old_node.id) 
+                         << ") - old node is gone, replacing with candidate " 
+                         << node_id_to_hex(verification.candidate_node.id));
+            
+            // Replace old node with candidate
+            DhtNode candidate = verification.candidate_node;
+            candidate.mark_success();  // The responder just proved it's alive
+            perform_replacement(candidate, verification.old_node, verification.bucket_index);
         }
         
         // Remove tracking entries
@@ -2339,4 +2570,74 @@ void DhtClient::set_data_directory(const std::string& directory) {
     LOG_DHT_DEBUG("Data directory set to: " << data_directory_);
 }
 
+#ifdef RATS_SEARCH_FEATURES
+// ============================================================================
+// SPIDER MODE IMPLEMENTATION
+// ============================================================================
+
+void DhtClient::set_spider_mode(bool enable) {
+    spider_mode_.store(enable);
+    if (enable) {
+        LOG_DHT_INFO("Spider mode ENABLED - aggressive node discovery active");
+    } else {
+        LOG_DHT_INFO("Spider mode DISABLED - normal DHT operation");
+    }
+}
+
+void DhtClient::set_spider_announce_callback(SpiderAnnounceCallback callback) {
+    std::lock_guard<std::mutex> lock(spider_callbacks_mutex_);
+    spider_announce_callback_ = std::move(callback);
+    LOG_DHT_DEBUG("Spider announce callback set");
+}
+
+void DhtClient::set_spider_ignore(bool ignore) {
+    spider_ignore_.store(ignore);
+    LOG_DHT_DEBUG("Spider ignore mode set to " << (ignore ? "true" : "false"));
+}
+
+void DhtClient::spider_walk() {
+    if (!running_) {
+        return;
+    }
+    
+    // Get a random node from the routing table and send find_node
+    DhtNode target_node;
+    bool found = false;
+    
+    {
+        std::lock_guard<std::mutex> lock(routing_table_mutex_);
+        
+        // Collect all nodes from non-empty buckets
+        std::vector<DhtNode*> all_nodes;
+        for (auto& bucket : routing_table_) {
+            for (auto& node : bucket) {
+                all_nodes.push_back(&node);
+            }
+        }
+        
+        if (!all_nodes.empty()) {
+            // Pick a random node
+            static std::random_device rd;
+            static std::mt19937 gen(rd());
+            std::uniform_int_distribution<size_t> dis(0, all_nodes.size() - 1);
+            target_node = *all_nodes[dis(gen)];
+            found = true;
+        }
+    }
+    
+    if (found) {
+        // Generate a random target ID for find_node (like spider.js does)
+        NodeId random_target = generate_node_id();
+        send_krpc_find_node(target_node.peer, random_target);
+        LOG_DHT_DEBUG("Spider walk: sent find_node to " << target_node.peer.ip << ":" << target_node.peer.port);
+    } else {
+        // No nodes in routing table, bootstrap
+        LOG_DHT_DEBUG("Spider walk: no nodes in routing table, re-bootstrapping");
+        for (const auto& bootstrap : get_default_bootstrap_nodes()) {
+            send_krpc_find_node(bootstrap, node_id_);
+        }
+    }
+}
+#endif // RATS_SEARCH_FEATURES
+
 } // namespace librats