librats 0.5.2 → 0.5.3

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)

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

@@ -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/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>();
     

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.2",
+  "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",