librats 0.5.2 → 0.5.4

package/binding.gyp

@@ -2,6 +2,7 @@
   "targets": [
     {
       "target_name": "librats",
+      "product_name": "librats",
       "sources": [
         "src/librats_node.cpp"
       ],

package/native-src/CMakeLists.txt

@@ -64,6 +64,15 @@ project(librats VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH})
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
+# Flags
+# Compiler warnings configuration
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+    # additional checks by compiler to found errors ealy on
+    add_compile_options(-Wall -Wextra -Wpedantic)
+    # not show unused stuff, useful for development
+    add_compile_options(-Wno-unused-parameter -Wno-unused-variable -Wno-unused-but-set-variable)
+endif()
+
 # Options
 option(RATS_BUILD_EXAMPLES "Build examples" ON)
 option(RATS_BUILD_TESTS "Build unit tests" ON)
@@ -138,6 +147,7 @@ set(LIBRARY_SOURCES
     src/fs.cpp
     src/fs.h
     src/logger.h
+    src/logger.cpp
     src/noise.cpp
     src/noise.h
     src/encrypted_socket.cpp

package/native-src/src/dht.cpp

@@ -457,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_);
 
@@ -515,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) {
@@ -531,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");
@@ -557,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);
@@ -657,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));
                 }
             }
         }
@@ -705,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_);
@@ -718,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);
@@ -735,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);
@@ -765,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");
@@ -772,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);
@@ -793,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)
@@ -1247,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];
                 }
                 
@@ -2156,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
@@ -2182,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
@@ -2457,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 

package/native-src/src/dht.h

@@ -76,7 +76,7 @@ struct DhtNode {
     // Number of consecutive failures (0xff = never pinged, 0 = confirmed good)
     uint8_t fail_count = 0xff;
     
-    DhtNode() : last_seen(std::chrono::steady_clock::now()) {}
+    DhtNode() : id(), last_seen(std::chrono::steady_clock::now()) {}
     DhtNode(const NodeId& id, const Peer& peer)
         : id(id), peer(peer), last_seen(std::chrono::steady_clock::now()) {}
     
@@ -127,6 +127,16 @@ struct DhtNode {
  */
 using PeerDiscoveryCallback = std::function<void(const std::vector<Peer>& peers, const InfoHash& info_hash)>;
 
+#ifdef RATS_SEARCH_FEATURES
+/**
+ * Spider mode callback
+ * Called when a peer announces they have a torrent (announce_peer request received)
+ * @param info_hash The info hash being announced
+ * @param peer The peer that is announcing (with the port they specified)
+ */
+using SpiderAnnounceCallback = std::function<void(const InfoHash& info_hash, const Peer& peer)>;
+#endif // RATS_SEARCH_FEATURES
+
 /**
  * Deferred callbacks structure for avoiding deadlock
  * Callbacks are collected while holding the mutex, then invoked after releasing it
@@ -253,6 +263,54 @@ public:
      */
     bool is_running() const { return running_; }
     
+#ifdef RATS_SEARCH_FEATURES
+    // ============================================================================
+    // SPIDER MODE - Aggressive node discovery and announce collection
+    // ============================================================================
+    
+    /**
+     * Enable spider mode
+     * In spider mode:
+     * - Nodes are added to routing table without ping verification
+     * - All announce_peer requests from other peers are collected via callback
+     * @param enable true to enable spider mode, false to disable
+     */
+    void set_spider_mode(bool enable);
+    
+    /**
+     * Check if spider mode is enabled
+     * @return true if spider mode is enabled
+     */
+    bool is_spider_mode() const { return spider_mode_; }
+    
+    /**
+     * Set callback for announce_peer requests (spider mode)
+     * Called when other peers announce they have a torrent
+     * @param callback The callback to invoke
+     */
+    void set_spider_announce_callback(SpiderAnnounceCallback callback);
+    
+    /**
+     * Set spider ignore mode - when true, incoming requests are not processed
+     * Similar to rate limiting in the original spider implementation
+     * @param ignore true to ignore incoming requests, false to process them
+     */
+    void set_spider_ignore(bool ignore);
+    
+    /**
+     * Check if spider ignore mode is enabled
+     * @return true if ignoring incoming requests
+     */
+    bool is_spider_ignoring() const { return spider_ignore_; }
+    
+    /**
+     * Trigger a single spider walk iteration
+     * Sends find_node to a random node from the routing table
+     * Should be called from external loop at desired frequency
+     */
+    void spider_walk();
+#endif // RATS_SEARCH_FEATURES
+    
     /**
      * Get default BitTorrent DHT bootstrap nodes
      * @return Vector of bootstrap nodes
@@ -400,6 +458,14 @@ private:
     std::condition_variable shutdown_cv_;
     std::mutex shutdown_mutex_;  // Lock order: 7 (can be locked independently)
     
+#ifdef RATS_SEARCH_FEATURES
+    // Spider mode state
+    std::atomic<bool> spider_mode_{false};
+    std::atomic<bool> spider_ignore_{false};  // When true, ignore incoming requests
+    SpiderAnnounceCallback spider_announce_callback_;
+    std::mutex spider_callbacks_mutex_;  // Protects spider callbacks
+#endif // RATS_SEARCH_FEATURES
+    
     // Helper functions
     void network_loop();
     void maintenance_loop();
@@ -423,7 +489,7 @@ private:
     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 add_node(const DhtNode& node, bool confirmed = true);
+    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);
     std::vector<DhtNode> find_closest_nodes_unlocked(const NodeId& target, size_t count = K_BUCKET_SIZE);
     int get_bucket_index(const NodeId& id);

package/native-src/src/ice.cpp

@@ -477,8 +477,8 @@ StunAddress NatTypeDetector::get_mapped_address_different_port(const std::string
 
 IceAgent::IceAgent(IceRole role, const IceConfig& config)
     : role_(role), config_(config), running_(false), state_(IceConnectionState::NEW),
-      udp_socket_(INVALID_SOCKET_VALUE), tcp_socket_(INVALID_SOCKET_VALUE),
-      selected_pair_(IceCandidate(), IceCandidate()) {
+      selected_pair_(IceCandidate(), IceCandidate()),
+      udp_socket_(INVALID_SOCKET_VALUE), tcp_socket_(INVALID_SOCKET_VALUE) {
     
     // Initialize NAT detector
     nat_detector_ = std::make_unique<NatTypeDetector>();

package/native-src/src/krpc.h

@@ -50,7 +50,7 @@ struct KrpcNode {
     std::string ip;
     uint16_t port;
     
-    KrpcNode() : port(0) {}
+    KrpcNode() : id(), port(0) {}
     KrpcNode(const NodeId& node_id, const std::string& ip_addr, uint16_t port_num)
         : id(node_id), ip(ip_addr), port(port_num) {}
 };
@@ -79,7 +79,7 @@ struct KrpcMessage {
     KrpcErrorCode error_code;
     std::string error_message;
     
-    KrpcMessage() : type(KrpcMessageType::Query), query_type(KrpcQueryType::Ping), port(0), error_code(KrpcErrorCode::GenericError) {}
+    KrpcMessage() : type(KrpcMessageType::Query), query_type(KrpcQueryType::Ping), sender_id(), target_id(), info_hash(), port(0), response_id(), error_code(KrpcErrorCode::GenericError) {}
 };
 
 /**

package/native-src/src/librats.cpp

@@ -14,6 +14,7 @@
 #include <sstream>
 #include <iomanip>
 #include <stdexcept>
+#include <string_view>
 
 #ifdef TESTING
 #define LOG_CLIENT_DEBUG(message) LOG_DEBUG("client", "[pointer: " << this << "] " << message)
@@ -52,15 +53,15 @@ RatsClient::RatsClient(int listen_port, int max_peers, const NatTraversalConfig&
     : listen_port_(listen_port), 
       bind_address_(bind_address),
       max_peers_(max_peers),
-      nat_config_(nat_config),
       server_socket_(INVALID_SOCKET_VALUE),
       running_(false),
-      auto_discovery_running_(false),
+      nat_config_(nat_config),
+      data_directory_("."),
       encryption_enabled_(false),
       detected_nat_type_(NatType::UNKNOWN),
-      data_directory_("."),
       custom_protocol_name_("rats"),
-      custom_protocol_version_("1.0") {
+      custom_protocol_version_("1.0"),
+      auto_discovery_running_(false) {
     // Initialize STUN client
     stun_client_ = std::make_unique<StunClient>();
     
@@ -1253,6 +1254,8 @@ void RatsClient::add_ignored_address(const std::string& ip_address) {
     }
 }
 
+//common localhost addresses
+static constexpr std::array<std::string_view,4> localhost_addrs{"127.0.0.1", "::1", "0.0.0.0", "::"};
 
 // Local interface address blocking methods
 void RatsClient::initialize_local_addresses() {
@@ -1264,10 +1267,9 @@ void RatsClient::initialize_local_addresses() {
     local_interface_addresses_ = network_utils::get_local_interface_addresses();
     
     // Add common localhost addresses if not already present
-    std::vector<std::string> localhost_addrs = {"127.0.0.1", "::1", "0.0.0.0", "::"};
     for (const auto& addr : localhost_addrs) {
         if (std::find(local_interface_addresses_.begin(), local_interface_addresses_.end(), addr) == local_interface_addresses_.end()) {
-            local_interface_addresses_.push_back(addr);
+            local_interface_addresses_.emplace_back(addr);
         }
     }
     
@@ -1287,10 +1289,9 @@ void RatsClient::refresh_local_addresses() {
     local_interface_addresses_ = network_utils::get_local_interface_addresses();
     
     // Add common localhost addresses if not already present
-    std::vector<std::string> localhost_addrs = {"127.0.0.1", "::1", "0.0.0.0", "::"};
     for (const auto& addr : localhost_addrs) {
         if (std::find(local_interface_addresses_.begin(), local_interface_addresses_.end(), addr) == local_interface_addresses_.end()) {
-            local_interface_addresses_.push_back(addr);
+            local_interface_addresses_.emplace_back(addr);
         }
     }
     
@@ -1808,7 +1809,7 @@ bool RatsClient::find_peers_by_hash(const std::string& content_hash, std::functi
         // Convert Peer to string addresses for callback
         std::vector<std::string> peer_addresses;
         for (const auto& peer : peers) {
-            peer_addresses.push_back(peer.ip + ":" + std::to_string(peer.port));
+            peer_addresses.emplace_back(peer.ip + ":" + std::to_string(peer.port));
         }
         
         if (callback) {

package/native-src/src/librats.h

@@ -80,6 +80,7 @@ struct RatsPeer {
     
     RatsPeer() : handshake_state(HandshakeState::PENDING), 
                  peer_count(0), encryption_enabled(false), noise_handshake_completed(false),
+                 remote_static_key(),
                  ice_enabled(false), ice_state(IceConnectionState::NEW),
                  detected_nat_type(NatType::UNKNOWN), rtt_ms(0), packet_loss_percent(0),
                  transport_protocol("UDP") {
@@ -1453,6 +1454,60 @@ public:
      */
     void get_torrent_metadata(const std::string& info_hash_hex, 
                              std::function<void(const TorrentInfo&, bool, const std::string&)> callback);
+    
+    // =========================================================================
+    // Spider Mode API (requires RATS_SEARCH_FEATURES)
+    // =========================================================================
+    
+    /**
+     * Spider announce callback type
+     * Called when a peer announces they have a torrent (announce_peer request received)
+     * @param info_hash The info hash being announced (as hex string)
+     * @param peer_address The peer that is announcing (ip:port format)
+     */
+    using SpiderAnnounceCallback = std::function<void(const std::string& info_hash, const std::string& peer_address)>;
+    
+    /**
+     * Enable spider mode on DHT
+     * In spider mode:
+     * - Nodes are added to routing table without ping verification
+     * - All announce_peer requests from other peers are collected via callback
+     * @param enable true to enable spider mode, false to disable
+     */
+    void set_spider_mode(bool enable);
+    
+    /**
+     * Check if spider mode is enabled
+     * @return true if spider mode is enabled
+     */
+    bool is_spider_mode() const;
+    
+    /**
+     * Set callback for announce_peer requests (spider mode)
+     * Called when other peers announce they have a torrent
+     * @param callback The callback to invoke
+     */
+    void set_spider_announce_callback(SpiderAnnounceCallback callback);
+    
+    /**
+     * Set spider ignore mode - when true, incoming requests are not processed
+     * Useful for rate limiting in spider mode
+     * @param ignore true to ignore incoming requests, false to process them
+     */
+    void set_spider_ignore(bool ignore);
+    
+    /**
+     * Check if spider ignore mode is enabled
+     * @return true if ignoring incoming requests
+     */
+    bool is_spider_ignoring() const;
+    
+    /**
+     * Trigger a single spider walk iteration
+     * Sends find_node to a random node from the routing table
+     * Call this periodically at desired frequency to expand routing table
+     */
+    void spider_walk();
 #endif // RATS_SEARCH_FEATURES
 
 private: