librats 0.7.2 → 0.9.0

package/native-src/src/io_poller.h

@@ -0,0 +1,138 @@
+#pragma once
+
+/**
+ * @file io_poller.h
+ * @brief Platform-optimal I/O multiplexing abstraction
+ * 
+ * Provides a unified interface over platform-specific I/O multiplexers:
+ * - Linux:       epoll   (O(1) per event, scales to millions of fds)
+ * - macOS/BSD:   kqueue  (O(1) per event, scales to millions of fds)
+ * - Windows:     IOCP    (true async completion ports, O(1) per event)
+ * 
+ * Usage:
+ *   auto poller = IOPoller::create();
+ *   poller->add(fd, PollIn);
+ *   
+ *   PollResult results[64];
+ *   int n = poller->wait(results, 64, 100);  // 100ms timeout
+ *   for (int i = 0; i < n; i++) {
+ *       if (results[i].events & PollIn) handle_read(results[i].fd);
+ *       if (results[i].events & PollOut) handle_write(results[i].fd);
+ *   }
+ */
+
+#include "socket.h"
+
+#include <memory>
+#include <cstdint>
+
+namespace librats {
+
+//=============================================================================
+// Poll Event Flags
+//=============================================================================
+
+/**
+ * @brief I/O event flags for polling
+ */
+enum PollFlags : uint32_t {
+    PollNone = 0,
+    PollIn   = 1 << 0,  ///< Socket is readable (data available or connection accepted)
+    PollOut  = 1 << 1,  ///< Socket is writable (can send or connect completed)
+    PollErr  = 1 << 2,  ///< Error condition on socket
+    PollHup  = 1 << 3,  ///< Hang up / peer disconnected
+};
+
+inline uint32_t operator|(PollFlags a, PollFlags b) {
+    return static_cast<uint32_t>(a) | static_cast<uint32_t>(b);
+}
+
+//=============================================================================
+// Poll Result
+//=============================================================================
+
+/**
+ * @brief Result entry from a poll wait
+ */
+struct PollResult {
+    socket_t fd;        ///< The socket that has events
+    uint32_t events;    ///< Bitmask of PollFlags that occurred
+};
+
+//=============================================================================
+// IOPoller Abstract Interface
+//=============================================================================
+
+/**
+ * @brief Abstract I/O multiplexer
+ * 
+ * Thread-safety:
+ * - add/modify/remove: Safe to call from any thread (epoll_ctl is thread-safe,
+ *   kqueue changes are atomic, WSAPoll rebuilds on wait).
+ * - wait: Should be called from a single I/O thread.
+ * - add/modify/remove can be called concurrently with wait().
+ */
+class IOPoller {
+public:
+    virtual ~IOPoller() = default;
+    
+    /**
+     * @brief Create the platform-optimal poller instance
+     * 
+     * Returns:
+     * - EpollPoller on Linux
+     * - KqueuePoller on macOS/FreeBSD
+     * - IocpPoller on Windows (I/O Completion Ports)
+     */
+    static std::unique_ptr<IOPoller> create();
+    
+    /**
+     * @brief Add a socket to the poll set
+     * 
+     * @param fd Socket to monitor
+     * @param events Bitmask of PollFlags to watch for
+     * @return true on success
+     */
+    virtual bool add(socket_t fd, uint32_t events) = 0;
+    
+    /**
+     * @brief Modify the event mask for a monitored socket
+     * 
+     * @param fd Socket already in the poll set
+     * @param events New bitmask of PollFlags
+     * @return true on success
+     */
+    virtual bool modify(socket_t fd, uint32_t events) = 0;
+    
+    /**
+     * @brief Remove a socket from the poll set
+     * 
+     * @param fd Socket to remove
+     * @return true on success (false if fd was not registered)
+     */
+    virtual bool remove(socket_t fd) = 0;
+    
+    /**
+     * @brief Wait for I/O events
+     * 
+     * Blocks until events occur or timeout expires.
+     * 
+     * @param results Array to fill with ready socket events
+     * @param max_results Maximum entries in results array
+     * @param timeout_ms Timeout in milliseconds (-1 = block forever, 0 = non-blocking)
+     * @return Number of ready descriptors (0 on timeout, -1 on error)
+     */
+    virtual int wait(PollResult* results, int max_results, int timeout_ms) = 0;
+    
+    /**
+     * @brief Get the backend name (for logging/diagnostics)
+     */
+    virtual const char* name() const = 0;
+    
+    // Non-copyable
+    IOPoller() = default;
+    IOPoller(const IOPoller&) = delete;
+    IOPoller& operator=(const IOPoller&) = delete;
+};
+
+} // namespace librats

package/native-src/src/krpc.cpp

@@ -183,6 +183,15 @@ BencodeValue KrpcProtocol::encode_query(const KrpcMessage& message) {
             break;
     }
     
+    // BEP 32: advertise which node families we want back
+    if (!message.want.empty()) {
+        BencodeValue want_list = BencodeValue::create_list();
+        for (const auto& w : message.want) {
+            want_list.push_back(BencodeValue(w));
+        }
+        args["want"] = want_list;
+    }
+
     root["a"] = args;
     return root;
 }
@@ -198,13 +207,24 @@ BencodeValue KrpcProtocol::encode_response(const KrpcMessage& message) {
     BencodeValue response = BencodeValue::create_dict();
     response["id"] = BencodeValue(node_id_to_string(message.response_id));
     
-    // Add nodes if present
+    // Add nodes if present. BEP 32: IPv4 nodes go in "nodes" (26 bytes each),
+    // IPv6 nodes go in "nodes6" (38 bytes each).
     if (!message.nodes.empty()) {
-        std::string compact_nodes;
+        std::string compact_nodes_v4;
+        std::string compact_nodes_v6;
         for (const auto& node : message.nodes) {
-            compact_nodes += compact_node_info(node);
+            if (network_utils::is_valid_ipv6(node.ip)) {
+                compact_nodes_v6 += compact_node_info(node);
+            } else {
+                compact_nodes_v4 += compact_node_info(node);
+            }
+        }
+        if (!compact_nodes_v4.empty()) {
+            response["nodes"] = BencodeValue(compact_nodes_v4);
+        }
+        if (!compact_nodes_v6.empty()) {
+            response["nodes6"] = BencodeValue(compact_nodes_v6);
         }
-        response["nodes"] = BencodeValue(compact_nodes);
     }
     
     // Add peers if present
@@ -220,8 +240,18 @@ BencodeValue KrpcProtocol::encode_response(const KrpcMessage& message) {
     if (!message.token.empty()) {
         response["token"] = BencodeValue(message.token);
     }
-    
+
     root["r"] = response;
+
+    // BEP 42: echo the requester's external address as a top-level "ip" field
+    // (compact 6-byte IPv4 / 18-byte IPv6 ip+port).
+    if (!message.external_ip.empty()) {
+        std::string compact = compact_peer_info(Peer(message.external_ip, message.external_port));
+        if (!compact.empty()) {
+            root["ip"] = BencodeValue(compact);
+        }
+    }
+
     return root;
 }
 
@@ -295,7 +325,17 @@ std::unique_ptr<KrpcMessage> KrpcProtocol::decode_query(const BencodeValue& data
     }
     
     message->sender_id = string_to_node_id(args["id"].as_string());
-    
+
+    // BEP 32: optional "want" list specifying desired node families
+    if (args.has_key("want")) {
+        const BencodeValue& want_list = args["want"];
+        if (want_list.is_list()) {
+            for (size_t i = 0; i < want_list.size(); ++i) {
+                message->want.push_back(want_list[i].as_string());
+            }
+        }
+    }
+
     switch (message->query_type) {
         case KrpcQueryType::Ping:
             // No additional arguments
@@ -347,10 +387,15 @@ std::unique_ptr<KrpcMessage> KrpcProtocol::decode_response(const BencodeValue& d
     
     message->response_id = string_to_node_id(response["id"].as_string());
     
-    // Parse nodes if present
+    // Parse nodes if present (BEP 32: "nodes" = IPv4, "nodes6" = IPv6)
     if (response.has_key("nodes")) {
         std::string compact_nodes = response["nodes"].as_string();
-        message->nodes = parse_compact_node_info(compact_nodes);
+        message->nodes = parse_compact_node_info(compact_nodes, /*ipv6=*/false);
+    }
+    if (response.has_key("nodes6")) {
+        std::string compact_nodes6 = response["nodes6"].as_string();
+        auto nodes6 = parse_compact_node_info(compact_nodes6, /*ipv6=*/true);
+        message->nodes.insert(message->nodes.end(), nodes6.begin(), nodes6.end());
     }
     
     // Parse peers if present
@@ -369,7 +414,16 @@ std::unique_ptr<KrpcMessage> KrpcProtocol::decode_response(const BencodeValue& d
     if (response.has_key("token")) {
         message->token = response["token"].as_string();
     }
-    
+
+    // BEP 42: top-level "ip" field tells us our external address as the responder sees it.
+    if (data.has_key("ip")) {
+        auto endpoints = parse_compact_peer_info(data["ip"].as_string());
+        if (!endpoints.empty()) {
+            message->external_ip = endpoints[0].ip;
+            message->external_port = endpoints[0].port;
+        }
+    }
+
     return message;
 }
 
@@ -415,132 +469,143 @@ NodeId KrpcProtocol::string_to_node_id(const std::string& str) {
     return id;
 }
 
-std::string KrpcProtocol::compact_peer_info(const Peer& peer) {
-    std::string result;
-    result.reserve(6);
-    
-    // Convert IP address to 4 bytes
-    if (network_utils::is_valid_ipv4(peer.ip)) {
-        struct in_addr addr;
-        if (inet_pton(AF_INET, peer.ip.c_str(), &addr) == 1) {
-            uint32_t ip = ntohl(addr.s_addr);
-            result += static_cast<char>((ip >> 24) & 0xFF);
-            result += static_cast<char>((ip >> 16) & 0xFF);
-            result += static_cast<char>((ip >> 8) & 0xFF);
-            result += static_cast<char>(ip & 0xFF);
-        } else {
-            // Invalid IP, use 0.0.0.0
-            result += "\x00\x00\x00\x00";
+// Append a compact IP address (4 bytes for IPv4, 16 bytes for IPv6) to `out`.
+// Returns the number of address bytes written, or 0 on failure.
+static size_t append_compact_address(const std::string& ip, std::string& out) {
+    if (network_utils::is_valid_ipv6(ip)) {
+        struct in6_addr addr6;
+        if (inet_pton(AF_INET6, ip.c_str(), &addr6) == 1) {
+            out.append(reinterpret_cast<const char*>(addr6.s6_addr), 16);
+            return 16;
         }
-    } else {
-        // Not IPv4, use 0.0.0.0
-        result += "\x00\x00\x00\x00";
+        return 0;
     }
-    
+
+    struct in_addr addr;
+    if (inet_pton(AF_INET, ip.c_str(), &addr) == 1) {
+        uint32_t v = ntohl(addr.s_addr);
+        out += static_cast<char>((v >> 24) & 0xFF);
+        out += static_cast<char>((v >> 16) & 0xFF);
+        out += static_cast<char>((v >> 8) & 0xFF);
+        out += static_cast<char>(v & 0xFF);
+        return 4;
+    }
+    // Invalid IPv4, use 0.0.0.0
+    out.append(4, '\x00');
+    return 4;
+}
+
+// Read a compact IP address of `addr_len` bytes (4=IPv4, 16=IPv6) at compact_info[offset]
+// into a printable string.
+static std::string read_compact_address(const std::string& compact_info, size_t offset, size_t addr_len) {
+    if (addr_len == 16) {
+        struct in6_addr addr6;
+        memcpy(addr6.s6_addr, compact_info.data() + offset, 16);
+        char ip_str[INET6_ADDRSTRLEN];
+        inet_ntop(AF_INET6, &addr6, ip_str, INET6_ADDRSTRLEN);
+        return std::string(ip_str);
+    }
+
+    struct in_addr addr;
+    uint32_t ip = 0;
+    ip |= (static_cast<uint8_t>(compact_info[offset]) << 24);
+    ip |= (static_cast<uint8_t>(compact_info[offset + 1]) << 16);
+    ip |= (static_cast<uint8_t>(compact_info[offset + 2]) << 8);
+    ip |= static_cast<uint8_t>(compact_info[offset + 3]);
+    addr.s_addr = htonl(ip);
+    char ip_str[INET_ADDRSTRLEN];
+    inet_ntop(AF_INET, &addr, ip_str, INET_ADDRSTRLEN);
+    return std::string(ip_str);
+}
+
+std::string KrpcProtocol::compact_peer_info(const Peer& peer) {
+    std::string result;
+    result.reserve(18);
+
+    // IP address (4 bytes IPv4 / 16 bytes IPv6)
+    append_compact_address(peer.ip, result);
+
     // Convert port to 2 bytes (network byte order)
     result += static_cast<char>((peer.port >> 8) & 0xFF);
     result += static_cast<char>(peer.port & 0xFF);
-    
+
     return result;
 }
 
 std::string KrpcProtocol::compact_node_info(const KrpcNode& node) {
     std::string result;
-    result.reserve(26);
-    
+    result.reserve(38);
+
     // Node ID (20 bytes)
     result += node_id_to_string(node.id);
-    
-    // IP address (4 bytes)
-    if (network_utils::is_valid_ipv4(node.ip)) {
-        struct in_addr addr;
-        if (inet_pton(AF_INET, node.ip.c_str(), &addr) == 1) {
-            uint32_t ip = ntohl(addr.s_addr);
-            result += static_cast<char>((ip >> 24) & 0xFF);
-            result += static_cast<char>((ip >> 16) & 0xFF);
-            result += static_cast<char>((ip >> 8) & 0xFF);
-            result += static_cast<char>(ip & 0xFF);
-        } else {
-            // Invalid IP, use 0.0.0.0
-            result += "\x00\x00\x00\x00";
-        }
-    } else {
-        // Not IPv4, use 0.0.0.0
-        result += "\x00\x00\x00\x00";
-    }
-    
+
+    // IP address (4 bytes IPv4 / 16 bytes IPv6)
+    append_compact_address(node.ip, result);
+
     // Port (2 bytes, network byte order)
     result += static_cast<char>((node.port >> 8) & 0xFF);
     result += static_cast<char>(node.port & 0xFF);
-    
+
     return result;
 }
 
 std::vector<Peer> KrpcProtocol::parse_compact_peer_info(const std::string& compact_info) {
     std::vector<Peer> peers;
-    
-    if (compact_info.size() % 6 != 0) {
+
+    // BEP 5/BEP 7: each "values" entry is a single compact peer: 6 bytes (IPv4) or 18 bytes (IPv6).
+    // Detect the family from the entry length. An exact length of 18 is treated as one IPv6 peer;
+    // otherwise we chunk by 6 (some implementations concatenate multiple IPv4 peers).
+    size_t record_size = 6;
+    size_t addr_len = 4;
+    if (compact_info.size() == 18) {
+        record_size = 18;
+        addr_len = 16;
+    } else if (compact_info.size() % 6 != 0) {
         LOG_KRPC_WARN("Invalid compact peer info size: " << compact_info.size());
         return peers;
     }
-    
-    for (size_t i = 0; i < compact_info.size(); i += 6) {
-        // Extract IP address (4 bytes)
-        uint32_t ip = 0;
-        ip |= (static_cast<uint8_t>(compact_info[i]) << 24);
-        ip |= (static_cast<uint8_t>(compact_info[i + 1]) << 16);
-        ip |= (static_cast<uint8_t>(compact_info[i + 2]) << 8);
-        ip |= static_cast<uint8_t>(compact_info[i + 3]);
-        
-        struct in_addr addr;
-        addr.s_addr = htonl(ip);
-        char ip_str[INET_ADDRSTRLEN];
-        inet_ntop(AF_INET, &addr, ip_str, INET_ADDRSTRLEN);
-        
-        // Extract port (2 bytes)
+
+    for (size_t i = 0; i + record_size <= compact_info.size(); i += record_size) {
+        std::string ip_str = read_compact_address(compact_info, i, addr_len);
+
         uint16_t port = 0;
-        port |= (static_cast<uint8_t>(compact_info[i + 4]) << 8);
-        port |= static_cast<uint8_t>(compact_info[i + 5]);
-        
+        port |= (static_cast<uint8_t>(compact_info[i + addr_len]) << 8);
+        port |= static_cast<uint8_t>(compact_info[i + addr_len + 1]);
+
         peers.emplace_back(ip_str, port);
     }
-    
+
     return peers;
 }
 
-std::vector<KrpcNode> KrpcProtocol::parse_compact_node_info(const std::string& compact_info) {
+std::vector<KrpcNode> KrpcProtocol::parse_compact_node_info(const std::string& compact_info, bool ipv6) {
     std::vector<KrpcNode> nodes;
-    
-    if (compact_info.size() % 26 != 0) {
-        LOG_KRPC_WARN("Invalid compact node info size: " << compact_info.size());
+
+    const size_t addr_len = ipv6 ? 16 : 4;
+    const size_t record_size = 20 + addr_len + 2;  // 26 (IPv4) or 38 (IPv6)
+
+    if (compact_info.size() % record_size != 0) {
+        LOG_KRPC_WARN("Invalid compact node info size: " << compact_info.size()
+                      << " (expected multiple of " << record_size << ")");
         return nodes;
     }
-    
-    for (size_t i = 0; i < compact_info.size(); i += 26) {
+
+    for (size_t i = 0; i < compact_info.size(); i += record_size) {
         // Extract node ID (20 bytes)
         NodeId node_id;
         std::copy_n(compact_info.begin() + i, 20, node_id.begin());
-        
-        // Extract IP address (4 bytes)
-        uint32_t ip = 0;
-        ip |= (static_cast<uint8_t>(compact_info[i + 20]) << 24);
-        ip |= (static_cast<uint8_t>(compact_info[i + 21]) << 16);
-        ip |= (static_cast<uint8_t>(compact_info[i + 22]) << 8);
-        ip |= static_cast<uint8_t>(compact_info[i + 23]);
-        
-        struct in_addr addr;
-        addr.s_addr = htonl(ip);
-        char ip_str[INET_ADDRSTRLEN];
-        inet_ntop(AF_INET, &addr, ip_str, INET_ADDRSTRLEN);
-        
+
+        // Extract IP address (4 or 16 bytes)
+        std::string ip_str = read_compact_address(compact_info, i + 20, addr_len);
+
         // Extract port (2 bytes)
         uint16_t port = 0;
-        port |= (static_cast<uint8_t>(compact_info[i + 24]) << 8);
-        port |= static_cast<uint8_t>(compact_info[i + 25]);
-        
+        port |= (static_cast<uint8_t>(compact_info[i + 20 + addr_len]) << 8);
+        port |= static_cast<uint8_t>(compact_info[i + 20 + addr_len + 1]);
+
         nodes.emplace_back(node_id, ip_str, port);
     }
-    
+
     return nodes;
 }
 

package/native-src/src/krpc.h

@@ -71,15 +71,26 @@ struct KrpcMessage {
     bool implied_port;  // BEP 5: if true, use UDP source port instead of 'port' field
     std::string token;
     
+    // BEP 32: requested node families for queries ("n4" and/or "n6").
+    // Empty means "no want specified" (responder defaults to the family the request arrived on).
+    std::vector<std::string> want;
+
     // For responses
     NodeId response_id;
-    std::vector<KrpcNode> nodes;
+    std::vector<KrpcNode> nodes;  // may mix IPv4/IPv6 nodes; encoder splits into nodes/nodes6
     std::vector<Peer> peers;
-    
+
+    // BEP 42: top-level "ip" field (compact ip+port).
+    // On responses we SEND: the requester's external address, so they can learn how the
+    // network sees them and derive a compliant node ID.
+    // On responses we RECEIVE: our own external address as observed by the responder.
+    std::string external_ip;
+    uint16_t external_port = 0;
+
     // For errors
     KrpcErrorCode error_code;
     std::string error_message;
-    
+
     KrpcMessage() : type(KrpcMessageType::Query), query_type(KrpcQueryType::Ping), sender_id(), target_id(), info_hash(), port(0), implied_port(false), response_id(), error_code(KrpcErrorCode::GenericError) {}
 };
 
@@ -123,10 +134,13 @@ public:
      */
     static std::string node_id_to_string(const NodeId& id);
     static NodeId string_to_node_id(const std::string& str);
+    // Compact encodings auto-select IPv4 (6/26 bytes) or IPv6 (18/38 bytes) based on the address.
     static std::string compact_peer_info(const Peer& peer);
     static std::string compact_node_info(const KrpcNode& node);
+    // parse_compact_peer_info detects the family from the string length (one peer per string).
     static std::vector<Peer> parse_compact_peer_info(const std::string& compact_info);
-    static std::vector<KrpcNode> parse_compact_node_info(const std::string& compact_info);
+    // parse_compact_node_info reads fixed-size records; pass ipv6=true for 38-byte ("nodes6") records.
+    static std::vector<KrpcNode> parse_compact_node_info(const std::string& compact_info, bool ipv6 = false);
 
 private:
     static BencodeValue encode_query(const KrpcMessage& message);