librats 0.5.1 → 0.5.3

package/native-src/src/dht.h

@@ -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
@@ -198,9 +208,10 @@ public:
      * Announce that this node is a peer for a specific info hash
      * @param info_hash The info hash to announce
      * @param port The port to announce (0 for DHT port)
+     * @param callback Optional callback to receive discovered peers during traversal
      * @return true if announcement started successfully, false otherwise
      */
-    bool announce_peer(const InfoHash& info_hash, uint16_t port = 0);
+    bool announce_peer(const InfoHash& info_hash, uint16_t port = 0, PeerDiscoveryCallback callback = nullptr);
     
     /**
      * Get our node ID
@@ -227,18 +238,79 @@ public:
      */
     bool is_search_active(const InfoHash& info_hash) const;
     
+    /**
+     * Check if an announce is currently active for an info hash
+     * @param info_hash The info hash to check
+     * @return true if announce is active, false otherwise
+     */
+    bool is_announce_active(const InfoHash& info_hash) const;
+    
     /**
      * Get number of active searches
      * @return Number of active searches
      */
     size_t get_active_searches_count() const;
     
+    /**
+     * Get number of active announces
+     * @return Number of active announces
+     */
+    size_t get_active_announces_count() const;
+    
     /**
      * Check if DHT is running
      * @return true if running, false otherwise
      */
     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
@@ -279,10 +351,9 @@ private:
     // 1. pending_pings_mutex_           (Ping verification state, nodes_being_replaced_)
     // 2. pending_searches_mutex_        (Search state and transaction mappings)
     // 3. routing_table_mutex_           (core routing data)
-    // 4. pending_announces_mutex_       (Announce state)
-    // 5. announced_peers_mutex_         (Stored peer data)
-    // 6. peer_tokens_mutex_             (Token validation data)
-    // 7. shutdown_mutex_                (Lowest priority - can be locked independently)
+    // 4. announced_peers_mutex_         (Stored peer data)
+    // 5. peer_tokens_mutex_             (Token validation data)
+    // 6. shutdown_mutex_                (Lowest priority - can be locked independently)
     //
     // Routing table (k-buckets)
     std::vector<std::vector<DhtNode>> routing_table_;
@@ -301,17 +372,6 @@ private:
     std::mutex peer_tokens_mutex_;  // Lock order: 6
     
 
-    // Pending announce tracking (for BEP 5 compliance)
-    struct PendingAnnounce {
-        InfoHash info_hash;
-        uint16_t port;
-        std::chrono::steady_clock::time_point created_at;
-        
-        PendingAnnounce(const InfoHash& hash, uint16_t p)
-            : info_hash(hash), port(p), created_at(std::chrono::steady_clock::now()) {}
-    };
-    std::unordered_map<std::string, PendingAnnounce> pending_announces_;
-    std::mutex pending_announces_mutex_;  // Lock order: 4
     
     // Pending find_peers tracking (to map transaction IDs to info_hash)
     struct PendingSearch {
@@ -332,9 +392,16 @@ private:
         // Callbacks to invoke when peers are found (supports multiple concurrent searches for same info_hash)
         std::vector<PeerDiscoveryCallback> callbacks;
         
+        // Announce support: tokens collected during traversal (BEP 5 compliant)
+        // Maps node_id -> write_token received from that node
+        std::unordered_map<NodeId, std::string> write_tokens;
+        bool is_announce;                           // true if this search is for announce_peer
+        uint16_t announce_port;                     // port to announce (only valid if is_announce)
+        
         PendingSearch(const InfoHash& hash)
             : info_hash(hash), created_at(std::chrono::steady_clock::now()), 
-              invoke_count(0), branch_factor(ALPHA), is_finished(false) {}
+              invoke_count(0), branch_factor(ALPHA), is_finished(false),
+              is_announce(false), announce_port(0) {}
     };
     std::unordered_map<std::string, PendingSearch> pending_searches_; // info_hash (hex) -> PendingSearch
     mutable std::mutex pending_searches_mutex_;  // Lock order: 2
@@ -391,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();
@@ -414,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);
@@ -434,10 +509,6 @@ private:
     void refresh_buckets();
     void print_statistics();
     
-    // Pending announce management
-    void cleanup_stale_announces();
-    void handle_get_peers_response_for_announce(const std::string& transaction_id, const Peer& responder, const std::string& token);
-    
     // Pending search management
     void cleanup_stale_searches();
     void cleanup_timed_out_search_requests();
@@ -445,8 +516,10 @@ private:
     void handle_get_peers_response_for_search(const std::string& transaction_id, const Peer& responder, const std::vector<Peer>& peers);
     void handle_get_peers_response_with_nodes(const std::string& transaction_id, const Peer& responder, const std::vector<KrpcNode>& nodes);
     void handle_get_peers_empty_response(const std::string& transaction_id, const Peer& responder);
+    void save_write_token(PendingSearch& search, const NodeId& node_id, const std::string& token);
     bool add_search_requests(PendingSearch& search, DeferredCallbacks& deferred);
     void add_node_to_search(PendingSearch& search, const DhtNode& node);
+    void send_announce_to_closest_nodes(PendingSearch& search);
     
     // Peer announcement storage management
     void store_announced_peer(const InfoHash& info_hash, const Peer& peer);

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/librats.cpp

@@ -52,15 +52,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>();
     
@@ -1817,7 +1817,8 @@ bool RatsClient::find_peers_by_hash(const std::string& content_hash, std::functi
     });
 }
 
-bool RatsClient::announce_for_hash(const std::string& content_hash, uint16_t port) {
+bool RatsClient::announce_for_hash(const std::string& content_hash, uint16_t port,
+                                   std::function<void(const std::vector<std::string>&)> callback) {
     if (!dht_client_ || !dht_client_->is_running()) {
         LOG_CLIENT_ERROR("DHT client not running");
         return false;
@@ -1832,10 +1833,25 @@ bool RatsClient::announce_for_hash(const std::string& content_hash, uint16_t por
         port = listen_port_;
     }
     
-    LOG_CLIENT_INFO("Announcing for content hash: " << content_hash << " on port " << port);
+    LOG_CLIENT_INFO("Announcing for content hash: " << content_hash << " on port " << port
+                   << (callback ? " with peer callback" : ""));
     
     InfoHash info_hash = hex_to_node_id(content_hash);
-    return dht_client_->announce_peer(info_hash, port);
+    
+    // Create wrapper callback that converts Peer to string addresses (if callback provided)
+    PeerDiscoveryCallback peer_callback = nullptr;
+    if (callback) {
+        peer_callback = [callback](const std::vector<Peer>& peers, const InfoHash& hash) {
+            std::vector<std::string> peer_addresses;
+            peer_addresses.reserve(peers.size());
+            for (const auto& peer : peers) {
+                peer_addresses.push_back(peer.ip + ":" + std::to_string(peer.port));
+            }
+            callback(peer_addresses);
+        };
+    }
+    
+    return dht_client_->announce_peer(info_hash, port, peer_callback);
 }
 
 bool RatsClient::is_dht_running() const {
@@ -1931,46 +1947,23 @@ void RatsClient::automatic_discovery_loop() {
         }
     }
 
-    // Search immediately
-    search_rats_peers();
-    
-    {
-        std::unique_lock<std::mutex> lock(shutdown_mutex_);
-        if (shutdown_cv_.wait_for(lock, std::chrono::seconds(10), [this] { return !auto_discovery_running_.load() || !running_.load(); })) {
-            LOG_CLIENT_INFO("Automatic peer discovery loop stopped during search delay");
-            return;
-        }
-    }
-    
-    // Announce immediately
+    // Announce immediately - this also discovers peers during traversal
     announce_rats_peer();
 
     auto last_announce = std::chrono::steady_clock::now();
-    auto last_search = std::chrono::steady_clock::now();
     
     while (auto_discovery_running_.load()) {
         auto now = std::chrono::steady_clock::now();
         
-        if (get_peer_count() == 0) {
-            // No peers: aggressive search and announce
-            if (now - last_search >= std::chrono::seconds(5)) {
-                search_rats_peers();
-                last_search = now;
-            }
-            if (now - last_announce >= std::chrono::seconds(20)) {
-                announce_rats_peer();
-                last_announce = now;
-            }
-        } else {
-            // Peers connected: less aggressive, similar to original logic
-            if (now - last_search >= std::chrono::minutes(5)) {
-                search_rats_peers();
-                last_search = now;
-            }
-            if (now - last_announce >= std::chrono::minutes(10)) {
-                announce_rats_peer();
-                last_announce = 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
+        
+        if (now - last_announce >= interval) {
+            announce_rats_peer();
+            last_announce = now;
         }
         
         // Use conditional variable for responsive shutdown
@@ -1994,8 +1987,35 @@ void RatsClient::announce_rats_peer() {
     std::string discovery_hash = get_discovery_hash();
     LOG_CLIENT_INFO("Announcing peer for discovery hash: " << discovery_hash << " on port " << listen_port_);
     
-    if (announce_for_hash(discovery_hash, listen_port_)) {
-        LOG_CLIENT_DEBUG("Successfully announced peer for discovery");
+    InfoHash info_hash = hex_to_node_id(discovery_hash);
+
+    if (dht_client_->is_announce_active(info_hash)) {
+        LOG_CLIENT_WARN("Announce already in progress for info hash: " << node_id_to_hex(info_hash));
+        return;
+    }
+    
+    // Use announce with callback - combines announce and find_peers in one traversal
+    // Peers discovered during traversal will be returned through the callback
+    if (announce_for_hash(discovery_hash, listen_port_, [this, info_hash](const std::vector<std::string>& peer_addresses) {
+        LOG_CLIENT_INFO("Announce discovered " << peer_addresses.size() << " peers during traversal");
+        
+        // Convert peer addresses to Peer objects for handle_dht_peer_discovery()
+        std::vector<Peer> peers;
+        peers.reserve(peer_addresses.size());
+        for (const auto& peer_address : peer_addresses) {
+            std::string ip;
+            int port;
+            if (parse_address_string(peer_address, ip, port)) {
+                peers.push_back(Peer(ip, port));
+            }
+        }
+        
+        // Auto-connect to discovered peers
+        if (!peers.empty()) {
+            handle_dht_peer_discovery(peers, info_hash);
+        }
+    })) {
+        LOG_CLIENT_DEBUG("Successfully started announce with peer discovery for discovery hash");
     } else {
         LOG_CLIENT_WARN("Failed to announce peer for discovery");
     }

package/native-src/src/librats.h

@@ -606,12 +606,15 @@ public:
                            std::function<void(const std::vector<std::string>&)> callback);
 
     /**
-     * Announce our presence for a content hash
+     * Announce our presence for a content hash with optional peer discovery callback
+     * If callback is provided, peers discovered during DHT traversal will be returned through it
      * @param content_hash Hash to announce for (40-character hex string)
      * @param port Port to announce (default: our listen port)
+     * @param callback Optional function to call with discovered peers during traversal
      * @return true if announced successfully
      */
-    bool announce_for_hash(const std::string& content_hash, uint16_t port = 0);
+    bool announce_for_hash(const std::string& content_hash, uint16_t port = 0,
+                          std::function<void(const std::vector<std::string>&)> callback = nullptr);
 
     /**
      * Check if DHT is currently running

package/native-src/src/librats_c.cpp

@@ -386,13 +386,29 @@ int rats_is_dht_running(rats_client_t handle) {
     return wrap->client->is_dht_running() ? 1 : 0;
 }
 
-rats_error_t rats_announce_for_hash(rats_client_t handle, const char* content_hash, int port) {
+rats_error_t rats_announce_for_hash(rats_client_t handle, const char* content_hash, int port,
+                                    rats_peers_found_cb callback, void* user_data) {
     if (!handle || !content_hash) return RATS_ERROR_INVALID_PARAMETER;
     if (strlen(content_hash) != 40) return RATS_ERROR_INVALID_PARAMETER; // SHA1 hash must be 40 chars
     rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
     
     uint16_t announce_port = (port <= 0) ? 0 : static_cast<uint16_t>(port);
-    return wrap->client->announce_for_hash(std::string(content_hash), announce_port) ? 
+    
+    // Create C++ callback wrapper if C callback is provided
+    std::function<void(const std::vector<std::string>&)> cpp_callback = nullptr;
+    if (callback) {
+        cpp_callback = [callback, user_data](const std::vector<std::string>& peers) {
+            // Convert vector to C-style array
+            std::vector<const char*> c_peers;
+            c_peers.reserve(peers.size());
+            for (const auto& peer : peers) {
+                c_peers.push_back(peer.c_str());
+            }
+            callback(user_data, c_peers.data(), static_cast<int>(c_peers.size()));
+        };
+    }
+    
+    return wrap->client->announce_for_hash(std::string(content_hash), announce_port, cpp_callback) ? 
            RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
 }
 

package/native-src/src/librats_c.h

@@ -82,6 +82,7 @@ typedef void (*rats_json_cb)(void* user_data, const char* peer_id, const char* j
 typedef void (*rats_disconnect_cb)(void* user_data, const char* peer_id);
 typedef void (*rats_peer_discovered_cb)(void* user_data, const char* host, int port, const char* service_name);
 typedef void (*rats_message_cb)(void* user_data, const char* peer_id, const char* message_data);
+typedef void (*rats_peers_found_cb)(void* user_data, const char** peer_addresses, int count);
 
 // Peer configuration
 RATS_API rats_error_t rats_set_max_peers(rats_client_t client, int max_peers);
@@ -106,7 +107,8 @@ RATS_API int rats_broadcast_json(rats_client_t client, const char* json_str);
 RATS_API rats_error_t rats_start_dht_discovery(rats_client_t client, int dht_port);
 RATS_API void rats_stop_dht_discovery(rats_client_t client);
 RATS_API int rats_is_dht_running(rats_client_t client);
-RATS_API rats_error_t rats_announce_for_hash(rats_client_t client, const char* content_hash, int port);
+RATS_API rats_error_t rats_announce_for_hash(rats_client_t client, const char* content_hash, int port,
+                                               rats_peers_found_cb callback, void* user_data);
 RATS_API size_t rats_get_dht_routing_table_size(rats_client_t client);
 
 // Automatic discovery

package/native-src/src/librats_mdns.cpp

@@ -45,6 +45,11 @@ bool RatsClient::start_mdns_discovery(const std::string& service_instance_name,
     // Create mDNS client
     mdns_client_ = std::make_unique<MdnsClient>(instance_name, listen_port_);
     
+    // Set service type based on protocol name (e.g., "_rats-search._tcp.local.")
+    std::string protocol_name = get_protocol_name();
+    std::string service_type = "_" + protocol_name + "._tcp.local.";
+    mdns_client_->set_service_type(service_type);
+    
     // Set service discovery callback
     mdns_client_->set_service_callback([this](const MdnsService& service, bool is_new) {
         handle_mdns_service_discovery(service, is_new);

package/native-src/src/mdns.cpp

@@ -25,6 +25,7 @@ namespace librats {
 MdnsClient::MdnsClient(const std::string& service_instance_name, uint16_t service_port)
     : service_instance_name_(service_instance_name),
       service_port_(service_port),
+      service_type_(LIBRATS_SERVICE_TYPE),  // Default service type
       multicast_socket_(INVALID_SOCKET_VALUE),
       running_(false),
       announcing_(false),
@@ -279,6 +280,11 @@ void MdnsClient::set_query_interval(std::chrono::seconds interval) {
     query_interval_ = interval;
 }
 
+void MdnsClient::set_service_type(const std::string& service_type) {
+    service_type_ = service_type;
+    LOG_MDNS_INFO("Service type set to: " << service_type_);
+}
+
 bool MdnsClient::create_multicast_socket() {
     multicast_socket_ = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
     if (!librats::is_valid_socket(multicast_socket_)) {
@@ -540,7 +546,7 @@ void MdnsClient::process_query(const DnsMessage& query, const std::string& sende
         bool should_respond = false;
         
         // Check if the question is asking for our service type
-        if (question.name == LIBRATS_SERVICE_TYPE && question.type == DnsRecordType::PTR) {
+        if (question.name == service_type_ && question.type == DnsRecordType::PTR) {
             should_respond = true;
         }
         
@@ -627,7 +633,7 @@ void MdnsClient::extract_service_from_response(const DnsMessage& response, const
 }
 
 bool MdnsClient::is_librats_service(const std::string& service_name) const {
-    return service_name == LIBRATS_SERVICE_TYPE;
+    return service_name == service_type_;
 }
 
 void MdnsClient::add_or_update_service(const MdnsService& service) {
@@ -668,8 +674,8 @@ DnsMessage MdnsClient::create_query_message() {
     query.header.flags = static_cast<uint16_t>(MdnsFlags::QUERY);
     query.header.question_count = 1;
     
-    // Add question for librats services
-    DnsQuestion question(LIBRATS_SERVICE_TYPE, DnsRecordType::PTR, DnsRecordClass::CLASS_IN);
+    // Add question for services with our service type
+    DnsQuestion question(service_type_, DnsRecordType::PTR, DnsRecordClass::CLASS_IN);
     query.questions.push_back(question);
     
     return query;
@@ -689,7 +695,7 @@ DnsMessage MdnsClient::create_announcement_message() {
     }
     
     // Create PTR record
-    DnsResourceRecord ptr_record = create_ptr_record(LIBRATS_SERVICE_TYPE, our_service_name);
+    DnsResourceRecord ptr_record = create_ptr_record(service_type_, our_service_name);
     announcement.answers.push_back(ptr_record);
     
     // Create SRV record
@@ -1120,11 +1126,11 @@ std::string MdnsClient::create_service_instance_name(const std::string& instance
         clean_name = "librats-node";
     }
     
-    return clean_name + "." + LIBRATS_SERVICE_TYPE;
+    return clean_name + "." + service_type_;
 }
 
 std::string MdnsClient::extract_instance_name_from_service(const std::string& service_name) {
-    size_t pos = service_name.find("." + LIBRATS_SERVICE_TYPE);
+    size_t pos = service_name.find("." + service_type_);
     if (pos != std::string::npos) {
         return service_name.substr(0, pos);
     }

package/native-src/src/mdns.h

@@ -152,11 +152,13 @@ public:
     // Configuration
     void set_announcement_interval(std::chrono::seconds interval);
     void set_query_interval(std::chrono::seconds interval);
+    void set_service_type(const std::string& service_type);
     
 private:
     // Core properties
     std::string service_instance_name_;
     uint16_t service_port_;
+    std::string service_type_;  // Dynamic service type (e.g., "_rats-search._tcp.local.")
     std::map<std::string, std::string> txt_records_;
     
     // Network properties

package/native-src/src/noise.cpp

@@ -10,7 +10,9 @@
 #ifdef _WIN32
     #include <windows.h>
     #include <bcrypt.h>
-    #pragma comment(lib, "bcrypt.lib")
+    #ifdef _MSC_VER
+        #pragma comment(lib, "bcrypt.lib")
+    #endif
 #else
     #include <fcntl.h>
     #include <unistd.h>

package/native-src/src/os.cpp

@@ -11,7 +11,9 @@
     #include <sysinfoapi.h>
     #include <versionhelpers.h>
     #include <intrin.h>
-    #pragma comment(lib, "version.lib")
+    #ifdef _MSC_VER
+        #pragma comment(lib, "version.lib")
+    #endif
 #elif __APPLE__
     #include <sys/utsname.h>
     #include <sys/sysctl.h>

package/native-src/src/socket.h

@@ -8,7 +8,9 @@
 #ifdef _WIN32
     #include <winsock2.h>
     #include <ws2tcpip.h>
-    #pragma comment(lib, "ws2_32.lib")
+    #ifdef _MSC_VER
+        #pragma comment(lib, "ws2_32.lib")
+    #endif
     typedef SOCKET socket_t;
     #define INVALID_SOCKET_VALUE INVALID_SOCKET
     #define SOCKET_ERROR_VALUE SOCKET_ERROR

package/native-src/src/stun.cpp

@@ -106,7 +106,7 @@ std::vector<uint8_t> StunClient::create_binding_request() {
     std::mt19937 gen(rd());
     std::uniform_int_distribution<> dis(0, 255);
     
-    for (int i = 0; i < stun::TRANSACTION_ID_SIZE; ++i) {
+    for (size_t i = 0; i < stun::TRANSACTION_ID_SIZE; ++i) {
         request[8 + i] = static_cast<uint8_t>(dis(gen));
     }
     
@@ -226,7 +226,7 @@ void StunClient::generate_transaction_id(uint8_t* transaction_id) {
     std::mt19937 gen(rd());
     std::uniform_int_distribution<> dis(0, 255);
     
-    for (int i = 0; i < stun::TRANSACTION_ID_SIZE; ++i) {
+    for (size_t i = 0; i < stun::TRANSACTION_ID_SIZE; ++i) {
         transaction_id[i] = static_cast<uint8_t>(dis(gen));
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "librats",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "Node.js bindings for librats - A high-performance peer-to-peer networking library",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/librats_node.cpp

@@ -473,7 +473,52 @@ private:
         std::string content_hash = info[0].As<Napi::String>().Utf8Value();
         int port = info[1].As<Napi::Number>().Int32Value();
         
-        rats_error_t result = rats_announce_for_hash(client_, content_hash.c_str(), port);
+        // Check if optional callback is provided
+        rats_peers_found_cb c_callback = nullptr;
+        void* callback_user_data = nullptr;
+        Napi::ThreadSafeFunction* tsfn_ptr = nullptr;
+        
+        if (info.Length() >= 3 && info[2].IsFunction()) {
+            // Create thread-safe function for callback
+            auto tsfn = new Napi::ThreadSafeFunction();
+            *tsfn = Napi::ThreadSafeFunction::New(
+                env,
+                info[2].As<Napi::Function>(),
+                "AnnounceForHashCallback",
+                0,
+                1,
+                [](Napi::Env) {} // Release callback
+            );
+            tsfn_ptr = tsfn;
+            
+            c_callback = [](void* user_data, const char** peer_addresses, int count) {
+                auto* tsfn = static_cast<Napi::ThreadSafeFunction*>(user_data);
+                if (!tsfn) return;
+                
+                // Copy peer addresses for async callback
+                std::vector<std::string>* peers = new std::vector<std::string>();
+                for (int i = 0; i < count; i++) {
+                    if (peer_addresses[i]) {
+                        peers->push_back(peer_addresses[i]);
+                    }
+                }
+                
+                tsfn->BlockingCall(peers, [](Napi::Env env, Napi::Function jsCallback, std::vector<std::string>* data) {
+                    Napi::Array arr = Napi::Array::New(env, data->size());
+                    for (size_t i = 0; i < data->size(); i++) {
+                        arr.Set(static_cast<uint32_t>(i), Napi::String::New(env, (*data)[i]));
+                    }
+                    jsCallback.Call({arr});
+                    delete data;
+                });
+                
+                tsfn->Release();
+                delete tsfn;
+            };
+            callback_user_data = tsfn_ptr;
+        }
+        
+        rats_error_t result = rats_announce_for_hash(client_, content_hash.c_str(), port, c_callback, callback_user_data);
         return Napi::Boolean::New(env, result == RATS_SUCCESS);
     }