librats 0.5.3 → 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

@@ -147,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.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()) {}
     

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)
@@ -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:

package/native-src/src/librats_bittorrent.cpp

@@ -162,6 +162,71 @@ void RatsClient::get_torrent_metadata(const std::string& info_hash_hex,
     bittorrent_client_->get_torrent_metadata_by_hash(info_hash_hex, callback);
 }
 
+//=============================================================================
+// Spider Mode API Implementation (requires RATS_SEARCH_FEATURES)
+//=============================================================================
+
+void RatsClient::set_spider_mode(bool enable) {
+    if (!dht_client_) {
+        LOG_CLIENT_WARN("DHT client not available, cannot set spider mode");
+        return;
+    }
+    
+    dht_client_->set_spider_mode(enable);
+    LOG_CLIENT_INFO("Spider mode " << (enable ? "enabled" : "disabled"));
+}
+
+bool RatsClient::is_spider_mode() const {
+    if (!dht_client_) {
+        return false;
+    }
+    return dht_client_->is_spider_mode();
+}
+
+void RatsClient::set_spider_announce_callback(SpiderAnnounceCallback callback) {
+    if (!dht_client_) {
+        LOG_CLIENT_WARN("DHT client not available, cannot set spider callback");
+        return;
+    }
+    
+    // Wrap the callback to convert types from DhtClient format to RatsClient format
+    dht_client_->set_spider_announce_callback(
+        [callback](const InfoHash& info_hash, const Peer& peer) {
+            if (callback) {
+                std::string info_hash_hex = node_id_to_hex(info_hash);
+                std::string peer_address = peer.ip + ":" + std::to_string(peer.port);
+                callback(info_hash_hex, peer_address);
+            }
+        });
+    
+    LOG_CLIENT_DEBUG("Spider announce callback set");
+}
+
+void RatsClient::set_spider_ignore(bool ignore) {
+    if (!dht_client_) {
+        LOG_CLIENT_WARN("DHT client not available, cannot set spider ignore");
+        return;
+    }
+    
+    dht_client_->set_spider_ignore(ignore);
+    LOG_CLIENT_DEBUG("Spider ignore mode " << (ignore ? "enabled" : "disabled"));
+}
+
+bool RatsClient::is_spider_ignoring() const {
+    if (!dht_client_) {
+        return false;
+    }
+    return dht_client_->is_spider_ignoring();
+}
+
+void RatsClient::spider_walk() {
+    if (!dht_client_) {
+        return;
+    }
+    
+    dht_client_->spider_walk();
+}
+
 }
 
 #endif // RATS_SEARCH_FEATURES

package/native-src/src/logger.cpp

@@ -0,0 +1,11 @@
+#include "logger.h"
+
+namespace librats {
+
+Logger& Logger::getInstance() {
+    static Logger instance;
+    return instance;
+}
+
+} // namespace librats
+

package/native-src/src/logger.h

@@ -34,11 +34,8 @@ enum class LogLevel {
 
 class Logger {
 public:
-    // Singleton pattern
-    static Logger& getInstance() {
-        static Logger instance;
-        return instance;
-    }
+    // Singleton pattern - implementation in logger.cpp to ensure single instance across TUs
+    static Logger& getInstance();
     
     // Delete copy constructor and assignment operator
     Logger(const Logger&) = delete;

package/native-src/src/mdns.cpp

@@ -31,7 +31,8 @@ MdnsClient::MdnsClient(const std::string& service_instance_name, uint16_t servic
       announcing_(false),
       discovering_(false),
       announcement_interval_(std::chrono::seconds(60)),
-      query_interval_(std::chrono::seconds(30)) {
+      query_interval_(std::chrono::seconds(30)),
+      rng_(std::random_device{}()) {
     
     // Get local network information
     local_hostname_ = get_local_hostname();
@@ -336,10 +337,18 @@ bool MdnsClient::join_multicast_group() {
         return false;
     }
     
-    // Join IPv4 multicast group
+    // Get local interface address for multicast binding
+    in_addr local_interface{};
+    if (local_ip_address_.empty() || local_ip_address_ == "127.0.0.1") {
+        local_interface.s_addr = INADDR_ANY;
+    } else {
+        inet_pton(AF_INET, local_ip_address_.c_str(), &local_interface);
+    }
+    
+    // Join IPv4 multicast group on specific interface
     ip_mreq mreq{};
     inet_pton(AF_INET, MDNS_MULTICAST_IPv4.c_str(), &mreq.imr_multiaddr);
-    mreq.imr_interface.s_addr = INADDR_ANY;
+    mreq.imr_interface = local_interface;
     
     if (setsockopt(multicast_socket_, IPPROTO_IP, IP_ADD_MEMBERSHIP, 
                    reinterpret_cast<const char*>(&mreq), sizeof(mreq)) < 0) {
@@ -351,6 +360,16 @@ bool MdnsClient::join_multicast_group() {
         return false;
     }
     
+    // Set outgoing multicast interface (critical for Windows!)
+    if (setsockopt(multicast_socket_, IPPROTO_IP, IP_MULTICAST_IF,
+                   reinterpret_cast<const char*>(&local_interface), sizeof(local_interface)) < 0) {
+#ifdef _WIN32
+        LOG_MDNS_WARN("Failed to set multicast interface (error: " << WSAGetLastError() << ")");
+#else
+        LOG_MDNS_WARN("Failed to set multicast interface (error: " << strerror(errno) << ")");
+#endif
+    }
+    
     // Set multicast TTL
     int ttl = 255;
     if (setsockopt(multicast_socket_, IPPROTO_IP, IP_MULTICAST_TTL, 
@@ -365,7 +384,7 @@ bool MdnsClient::join_multicast_group() {
         LOG_MDNS_WARN("Failed to disable multicast loopback");
     }
     
-    LOG_MDNS_DEBUG("Joined IPv4 multicast group: " << MDNS_MULTICAST_IPv4);
+    LOG_MDNS_INFO("Joined IPv4 multicast group: " << MDNS_MULTICAST_IPv4 << " on interface " << local_ip_address_);
     return true;
 }
 
@@ -374,9 +393,17 @@ bool MdnsClient::leave_multicast_group() {
         return false;
     }
     
+    // Use same interface as when joining
+    in_addr local_interface{};
+    if (local_ip_address_.empty() || local_ip_address_ == "127.0.0.1") {
+        local_interface.s_addr = INADDR_ANY;
+    } else {
+        inet_pton(AF_INET, local_ip_address_.c_str(), &local_interface);
+    }
+    
     ip_mreq mreq{};
     inet_pton(AF_INET, MDNS_MULTICAST_IPv4.c_str(), &mreq.imr_multiaddr);
-    mreq.imr_interface.s_addr = INADDR_ANY;
+    mreq.imr_interface = local_interface;
     
     if (setsockopt(multicast_socket_, IPPROTO_IP, IP_DROP_MEMBERSHIP, 
                    reinterpret_cast<const char*>(&mreq), sizeof(mreq)) < 0) {
@@ -546,7 +573,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 == service_type_ && question.type == DnsRecordType::PTR) {
+        if (is_librats_service(question.name) && question.type == DnsRecordType::PTR) {
             should_respond = true;
         }
         
@@ -563,10 +590,8 @@ void MdnsClient::process_query(const DnsMessage& query, const std::string& sende
             std::vector<uint8_t> packet = serialize_dns_message(response);
             
             // Add a small random delay to avoid response collisions
-            std::random_device rd;
-            std::mt19937 gen(rd());
             std::uniform_int_distribution<> dis(20, 120);
-            std::this_thread::sleep_for(std::chrono::milliseconds(dis(gen)));
+            std::this_thread::sleep_for(std::chrono::milliseconds(dis(rng_)));
             
             send_multicast_packet(packet);
         }
@@ -580,6 +605,12 @@ void MdnsClient::process_response(const DnsMessage& response, const std::string&
 }
 
 void MdnsClient::extract_service_from_response(const DnsMessage& response, const std::string& sender_ip) {
+    // Validate raw_packet is available for DNS compression resolution
+    if (response.raw_packet.empty()) {
+        LOG_MDNS_WARN("Cannot extract service: raw_packet is empty");
+        return;
+    }
+    
     MdnsService service;
     service.ip_address = sender_ip;
     service.last_seen = std::chrono::steady_clock::now();
@@ -590,23 +621,31 @@ void MdnsClient::extract_service_from_response(const DnsMessage& response, const
     
     // Process all answer records
     for (const auto& record : response.answers) {
-        if (record.type == DnsRecordType::PTR && is_librats_service(record.name)) {
-            // Extract service instance name from PTR record data
-            size_t offset = 0;
-            service.service_name = read_dns_name(record.data, offset);
-            has_ptr = true;
-            LOG_MDNS_DEBUG("Found PTR record: " << service.service_name);
+        LOG_MDNS_DEBUG("Processing record: type=" << static_cast<int>(record.type) << " name=" << record.name);
+        
+        if (record.type == DnsRecordType::PTR) {
+            // Check if this is our service type
+            if (is_librats_service(record.name)) {
+                // Extract service instance name from PTR record data
+                size_t offset = record.data_offset_in_packet;
+                service.service_name = read_dns_name(response.raw_packet, offset);
+                has_ptr = true;
+                LOG_MDNS_DEBUG("Found PTR record: " << service.service_name);
+            } else {
+                LOG_MDNS_DEBUG("Skipping PTR record - not our service type: " << record.name << " (expected: " << service_type_ << ")");
+            }
         }
         else if (record.type == DnsRecordType::SRV) {
-            // Extract SRV record data
+            // Extract SRV record data using full packet for DNS compression
             uint16_t priority, weight;
-            if (decode_srv_record(record.data, priority, weight, service.port, service.host_name)) {
+            if (decode_srv_record(response.raw_packet, record.data_offset_in_packet,
+                                  priority, weight, service.port, service.host_name)) {
                 has_srv = true;
                 LOG_MDNS_DEBUG("Found SRV record: " << service.host_name << ":" << service.port);
             }
         }
         else if (record.type == DnsRecordType::TXT) {
-            // Extract TXT record data
+            // TXT records don't use DNS compression, use data directly
             service.txt_records = decode_txt_record(record.data);
             has_txt = true;
             LOG_MDNS_DEBUG("Found TXT record with " << service.txt_records.size() << " entries");
@@ -633,7 +672,19 @@ void MdnsClient::extract_service_from_response(const DnsMessage& response, const
 }
 
 bool MdnsClient::is_librats_service(const std::string& service_name) const {
-    return service_name == service_type_;
+    // Normalize both names - remove trailing dots for comparison
+    std::string name1 = service_name;
+    std::string name2 = service_type_;
+    
+    // Remove trailing dots
+    while (!name1.empty() && name1.back() == '.') name1.pop_back();
+    while (!name2.empty() && name2.back() == '.') name2.pop_back();
+    
+    // Case-insensitive comparison
+    std::transform(name1.begin(), name1.end(), name1.begin(), ::tolower);
+    std::transform(name2.begin(), name2.end(), name2.begin(), ::tolower);
+    
+    return name1 == name2;
 }
 
 void MdnsClient::add_or_update_service(const MdnsService& service) {
@@ -813,11 +864,42 @@ std::vector<uint8_t> MdnsClient::serialize_dns_message(const DnsMessage& message
     return buffer;
 }
 
+bool MdnsClient::read_resource_records(const std::vector<uint8_t>& data, size_t& offset,
+                                        uint16_t count, std::vector<DnsResourceRecord>& records) {
+    records.clear();
+    records.reserve(count);
+    
+    for (uint16_t i = 0; i < count; ++i) {
+        DnsResourceRecord record;
+        record.name = read_dns_name(data, offset);
+        record.type = static_cast<DnsRecordType>(read_uint16(data, offset));
+        record.record_class = static_cast<DnsRecordClass>(read_uint16(data, offset));
+        record.ttl = read_uint32(data, offset);
+        uint16_t data_length = read_uint16(data, offset);
+        
+        if (offset + data_length > data.size()) {
+            return false;
+        }
+        
+        // Store offset for DNS compression resolution
+        record.data_offset_in_packet = offset;
+        record.data.assign(data.begin() + offset, data.begin() + offset + data_length);
+        offset += data_length;
+        
+        records.push_back(std::move(record));
+    }
+    
+    return true;
+}
+
 bool MdnsClient::deserialize_dns_message(const std::vector<uint8_t>& data, DnsMessage& message) {
     if (data.size() < 12) { // Minimum DNS header size
         return false;
     }
     
+    // Store raw packet for DNS compression resolution
+    message.raw_packet = data;
+    
     size_t offset = 0;
     
     try {
@@ -831,62 +913,24 @@ bool MdnsClient::deserialize_dns_message(const std::vector<uint8_t>& data, DnsMe
         
         // Read questions
         message.questions.clear();
+        message.questions.reserve(message.header.question_count);
         for (uint16_t i = 0; i < message.header.question_count; ++i) {
             DnsQuestion question;
             question.name = read_dns_name(data, offset);
             question.type = static_cast<DnsRecordType>(read_uint16(data, offset));
             question.record_class = static_cast<DnsRecordClass>(read_uint16(data, offset));
-            message.questions.push_back(question);
+            message.questions.push_back(std::move(question));
         }
         
-        // Read answers
-        message.answers.clear();
-        for (uint16_t i = 0; i < message.header.answer_count; ++i) {
-            DnsResourceRecord record;
-            record.name = read_dns_name(data, offset);
-            record.type = static_cast<DnsRecordType>(read_uint16(data, offset));
-            record.record_class = static_cast<DnsRecordClass>(read_uint16(data, offset));
-            record.ttl = read_uint32(data, offset);
-            uint16_t data_length = read_uint16(data, offset);
-            
-            if (offset + data_length > data.size()) {
-                return false;
-            }
-            
-            record.data.assign(data.begin() + offset, data.begin() + offset + data_length);
-            offset += data_length;
-            
-            message.answers.push_back(record);
+        // Read answers, authorities, and additionals
+        if (!read_resource_records(data, offset, message.header.answer_count, message.answers)) {
+            return false;
         }
-        
-        // Read authorities (skip for simplicity)
-        for (uint16_t i = 0; i < message.header.authority_count; ++i) {
-            read_dns_name(data, offset); // name
-            read_uint16(data, offset); // type
-            read_uint16(data, offset); // class
-            read_uint32(data, offset); // ttl
-            uint16_t data_length = read_uint16(data, offset);
-            offset += data_length;
+        if (!read_resource_records(data, offset, message.header.authority_count, message.authorities)) {
+            return false;
         }
-        
-        // Read additionals
-        message.additionals.clear();
-        for (uint16_t i = 0; i < message.header.additional_count; ++i) {
-            DnsResourceRecord record;
-            record.name = read_dns_name(data, offset);
-            record.type = static_cast<DnsRecordType>(read_uint16(data, offset));
-            record.record_class = static_cast<DnsRecordClass>(read_uint16(data, offset));
-            record.ttl = read_uint32(data, offset);
-            uint16_t data_length = read_uint16(data, offset);
-            
-            if (offset + data_length > data.size()) {
-                return false;
-            }
-            
-            record.data.assign(data.begin() + offset, data.begin() + offset + data_length);
-            offset += data_length;
-            
-            message.additionals.push_back(record);
+        if (!read_resource_records(data, offset, message.header.additional_count, message.additionals)) {
+            return false;
         }
         
         return true;
@@ -923,8 +967,9 @@ std::string MdnsClient::read_dns_name(const std::vector<uint8_t>& buffer, size_t
     bool jumped = false;
     size_t original_offset = offset;
     int jumps = 0;
+    const int max_jumps = 10;
     
-    while (offset < buffer.size() && jumps < 10) {
+    while (offset < buffer.size() && jumps < max_jumps) {
         uint8_t length = buffer[offset++];
         
         if (length == 0) {
@@ -932,20 +977,39 @@ std::string MdnsClient::read_dns_name(const std::vector<uint8_t>& buffer, size_t
         }
         
         if ((length & 0xC0) == 0xC0) {
-            // Compression pointer
+            // Compression pointer - need one more byte
+            if (offset >= buffer.size()) {
+                LOG_MDNS_WARN("Truncated DNS compression pointer");
+                break;
+            }
+            
             if (!jumped) {
                 original_offset = offset + 1;
                 jumped = true;
             }
             
             uint16_t pointer = ((length & 0x3F) << 8) | buffer[offset++];
+            
+            // Validate pointer doesn't point beyond buffer or forward (potential loop)
+            if (pointer >= buffer.size()) {
+                LOG_MDNS_WARN("Invalid DNS compression pointer: " << pointer << " >= " << buffer.size());
+                break;
+            }
+            
             offset = pointer;
             jumps++;
             continue;
         }
         
+        // Check for invalid label length (> 63 bytes per RFC 1035)
+        if (length > 63) {
+            LOG_MDNS_WARN("Invalid DNS label length: " << static_cast<int>(length));
+            break;
+        }
+        
         if (offset + length > buffer.size()) {
-            break; // Invalid length
+            LOG_MDNS_WARN("DNS label extends beyond buffer");
+            break;
         }
         
         if (!name.empty()) {
@@ -956,6 +1020,10 @@ std::string MdnsClient::read_dns_name(const std::vector<uint8_t>& buffer, size_t
         offset += length;
     }
     
+    if (jumps >= max_jumps) {
+        LOG_MDNS_WARN("Too many DNS compression jumps, possible loop");
+    }
+    
     if (jumped) {
         offset = original_offset;
     }
@@ -1064,18 +1132,20 @@ std::vector<uint8_t> MdnsClient::encode_srv_record(uint16_t priority, uint16_t w
     return data;
 }
 
-bool MdnsClient::decode_srv_record(const std::vector<uint8_t>& srv_data, uint16_t& priority, uint16_t& weight, uint16_t& port, std::string& target) {
-    if (srv_data.size() < 6) {
+bool MdnsClient::decode_srv_record(const std::vector<uint8_t>& full_packet, size_t data_offset,
+                                   uint16_t& priority, uint16_t& weight, uint16_t& port, std::string& target) {
+    if (data_offset + 6 > full_packet.size()) {
         return false;
     }
     
-    size_t offset = 0;
+    size_t offset = data_offset;
     
     try {
-        priority = read_uint16(srv_data, offset);
-        weight = read_uint16(srv_data, offset);
-        port = read_uint16(srv_data, offset);
-        target = read_dns_name(srv_data, offset);
+        priority = read_uint16(full_packet, offset);
+        weight = read_uint16(full_packet, offset);
+        port = read_uint16(full_packet, offset);
+        // Use full packet for proper DNS compression resolution
+        target = read_dns_name(full_packet, offset);
         return true;
     } catch (const std::exception&) {
         return false;
@@ -1100,14 +1170,18 @@ std::string MdnsClient::get_local_hostname() {
 std::string MdnsClient::get_local_ip_address() {
     auto addresses = librats::network_utils::get_local_interface_addresses();
     
-    // Prefer non-loopback IPv4 addresses
+    // Prefer non-loopback, non-APIPA IPv4 addresses
     for (const auto& addr : addresses) {
         if (addr != "127.0.0.1" && addr != "::1" && addr.find(':') == std::string::npos) {
+            // Skip APIPA addresses (169.254.x.x) - these are link-local fallback addresses
+            if (addr.rfind("169.254.", 0) == 0) {
+                continue;
+            }
             return addr;
         }
     }
     
-    // Fall back to first available address
+    // Fall back to first available address (even APIPA if that's all we have)
     if (!addresses.empty()) {
         return addresses[0];
     }

package/native-src/src/mdns.h

@@ -13,6 +13,7 @@
 #include <map>
 #include <cstdint>
 #include <condition_variable>
+#include <random>
 
 namespace librats {
 
@@ -98,10 +99,11 @@ struct DnsResourceRecord {
     DnsRecordClass record_class;
     uint32_t ttl;
     std::vector<uint8_t> data;
+    size_t data_offset_in_packet;  // Offset of data in original packet for DNS compression
     
-    DnsResourceRecord() : type(DnsRecordType::PTR), record_class(DnsRecordClass::CLASS_IN), ttl(120) {}
+    DnsResourceRecord() : type(DnsRecordType::PTR), record_class(DnsRecordClass::CLASS_IN), ttl(120), data_offset_in_packet(0) {}
     DnsResourceRecord(const std::string& n, DnsRecordType t, DnsRecordClass c, uint32_t ttl_val) 
-        : name(n), type(t), record_class(c), ttl(ttl_val) {}
+        : name(n), type(t), record_class(c), ttl(ttl_val), data_offset_in_packet(0) {}
 };
 
 // Complete DNS message structure
@@ -111,6 +113,7 @@ struct DnsMessage {
     std::vector<DnsResourceRecord> answers;
     std::vector<DnsResourceRecord> authorities;
     std::vector<DnsResourceRecord> additionals;
+    std::vector<uint8_t> raw_packet;  // Original packet for DNS compression resolution
     
     DnsMessage() = default;
 };
@@ -187,6 +190,9 @@ private:
     std::chrono::seconds announcement_interval_;
     std::chrono::seconds query_interval_;
     
+    // Random number generator for response delays
+    mutable std::mt19937 rng_;
+    
     // Socket operations
     bool create_multicast_socket();
     bool join_multicast_group();
@@ -223,6 +229,8 @@ private:
     // DNS serialization/deserialization
     std::vector<uint8_t> serialize_dns_message(const DnsMessage& message);
     bool deserialize_dns_message(const std::vector<uint8_t>& data, DnsMessage& message);
+    bool read_resource_records(const std::vector<uint8_t>& data, size_t& offset, 
+                               uint16_t count, std::vector<DnsResourceRecord>& records);
     
     // DNS name compression helpers
     void write_dns_name(std::vector<uint8_t>& buffer, const std::string& name);
@@ -238,7 +246,8 @@ private:
     
     // SRV record helpers
     std::vector<uint8_t> encode_srv_record(uint16_t priority, uint16_t weight, uint16_t port, const std::string& target);
-    bool decode_srv_record(const std::vector<uint8_t>& srv_data, uint16_t& priority, uint16_t& weight, uint16_t& port, std::string& target);
+    bool decode_srv_record(const std::vector<uint8_t>& full_packet, size_t data_offset,
+                           uint16_t& priority, uint16_t& weight, uint16_t& port, std::string& target);
     
     // Utility functions
     std::string get_local_hostname();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "librats",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "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

@@ -190,7 +190,7 @@ public:
         return exports;
     }
     
-    RatsClient(const Napi::CallbackInfo& info) : Napi::ObjectWrap<RatsClient>(info) {
+    RatsClient(const Napi::CallbackInfo& info) : Napi::ObjectWrap<RatsClient>(info), client_(nullptr) {
         Napi::Env env = info.Env();
         
         if (info.Length() < 1 || !info[0].IsNumber()) {
@@ -199,6 +199,10 @@ public:
         }
         
         int port = info[0].As<Napi::Number>().Int32Value();
+        if (port < 0 || port > 65535) {
+            Napi::RangeError::New(env, "Port number must be between 0 and 65535").ThrowAsJavaScriptException();
+            return;
+        }
         client_ = rats_create(port);
         
         if (!client_) {
@@ -208,7 +212,7 @@ public:
     }
     
     ~RatsClient() {
-        if (client_) {
+        if (client_ != nullptr) {
             // Clean up callbacks
             connection_callbacks.erase(client_);
             string_callbacks.erase(client_);
@@ -232,7 +236,9 @@ private:
     }
     
     void Stop(const Napi::CallbackInfo& info) {
-        rats_stop(client_);
+        if (client_ != nullptr) {
+            rats_stop(client_);
+        }
     }
     
     Napi::Value Connect(const Napi::CallbackInfo& info) {