librats 0.5.2 → 0.5.4

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/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/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

@@ -25,12 +25,14 @@ 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),
       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();
@@ -279,6 +281,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_)) {
@@ -330,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) {
@@ -345,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, 
@@ -359,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;
 }
 
@@ -368,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) {
@@ -540,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 == LIBRATS_SERVICE_TYPE && question.type == DnsRecordType::PTR) {
+        if (is_librats_service(question.name) && question.type == DnsRecordType::PTR) {
             should_respond = true;
         }
         
@@ -557,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);
         }
@@ -574,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();
@@ -584,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");
@@ -627,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 == LIBRATS_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) {
@@ -668,8 +725,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 +746,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
@@ -807,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 {
@@ -825,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;
@@ -917,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) {
@@ -926,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()) {
@@ -950,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;
     }
@@ -1058,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;
@@ -1094,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];
     }
@@ -1120,11 +1200,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

@@ -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;
 };
@@ -152,11 +155,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
@@ -185,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();
@@ -221,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);
@@ -236,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/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