librats 1.0.2 → 2.2.0

package/native-src/src/{krpc.cpp → librats/dht/krpc.cpp}

@@ -1,8 +1,5 @@
-#include "krpc.h"
-#include "network_utils.h"
-#include "logger.h"
-#include <random>
-#include <chrono>
+#include "librats/dht/krpc.h"
+#include "librats/util/logger.h"
 #include <sstream>
 #include <iomanip>
 #include <cstring>
@@ -16,16 +13,15 @@
     #include <netinet/in.h>
 #endif
 
-// KRPC module logging macros
-#define LOG_KRPC_DEBUG(message) LOG_DEBUG("krpc", message)
-#define LOG_KRPC_INFO(message)  LOG_INFO("krpc", message)
-#define LOG_KRPC_WARN(message)  LOG_WARN("krpc", message)
-#define LOG_KRPC_ERROR(message) LOG_ERROR("krpc", message)
+// KRPC module logging macros. Tagged "dht.krpc" to sit under the DHT dot-namespace
+// alongside dht.find / dht.route / dht.rpc — the codec is used only by the DHT.
+#define LOG_KRPC_DEBUG(message) LOG_DEBUG("dht.krpc", message)
+#define LOG_KRPC_INFO(message)  LOG_INFO("dht.krpc", message)
+#define LOG_KRPC_WARN(message)  LOG_WARN("dht.krpc", message)
+#define LOG_KRPC_ERROR(message) LOG_ERROR("dht.krpc", message)
 
 namespace librats {
 
-std::atomic<uint32_t> KrpcProtocol::transaction_counter_ = 0;
-
 KrpcProtocol::KrpcProtocol() {}
 
 KrpcProtocol::~KrpcProtocol() {}
@@ -91,7 +87,7 @@ KrpcMessage KrpcProtocol::create_find_node_response(const std::string& transacti
     return message;
 }
 
-KrpcMessage KrpcProtocol::create_get_peers_response(const std::string& transaction_id, const NodeId& response_id, const std::vector<Peer>& peers, const std::string& token) {
+KrpcMessage KrpcProtocol::create_get_peers_response(const std::string& transaction_id, const NodeId& response_id, const std::vector<Address>& peers, const std::string& token) {
     KrpcMessage message;
     message.type = KrpcMessageType::Response;
     message.transaction_id = transaction_id;
@@ -213,7 +209,7 @@ BencodeValue KrpcProtocol::encode_response(const KrpcMessage& message) {
         std::string compact_nodes_v4;
         std::string compact_nodes_v6;
         for (const auto& node : message.nodes) {
-            if (network_utils::is_valid_ipv6(node.ip)) {
+            if (node.ip.is_v6()) {
                 compact_nodes_v6 += compact_node_info(node);
             } else {
                 compact_nodes_v4 += compact_node_info(node);
@@ -245,8 +241,8 @@ BencodeValue KrpcProtocol::encode_response(const KrpcMessage& message) {
 
     // 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 (!message.external_ip.is_unspecified()) {
+        std::string compact = compact_peer_info(Address(message.external_ip, message.external_port));
         if (!compact.empty()) {
             root["ip"] = BencodeValue(compact);
         }
@@ -450,22 +446,6 @@ std::unique_ptr<KrpcMessage> KrpcProtocol::decode_error(const BencodeValue& data
 }
 
 // Utility functions
-std::string KrpcProtocol::generate_transaction_id() {
-    // A predictable transaction ID lets an off-path attacker forge responses to our queries and
-    // poison lookups. We make the ID unpredictable (2 random bytes) while keeping it collision-free
-    // (2 monotonic counter bytes guarantee uniqueness among any 65536 consecutive/outstanding
-    // transactions). The result is a 4-byte opaque binary string echoed back verbatim in KRPC.
-    static thread_local std::mt19937 rng(std::random_device{}());
-    uint32_t counter = transaction_counter_.fetch_add(1, std::memory_order_relaxed);
-    uint16_t rnd = static_cast<uint16_t>(rng() & 0xFFFF);
-    char tid[4];
-    tid[0] = static_cast<char>((rnd >> 8) & 0xFF);
-    tid[1] = static_cast<char>(rnd & 0xFF);
-    tid[2] = static_cast<char>((counter >> 8) & 0xFF);
-    tid[3] = static_cast<char>(counter & 0xFF);
-    return std::string(tid, sizeof(tid));
-}
-
 std::string KrpcProtocol::node_id_to_string(const NodeId& id) {
     return std::string(id.begin(), id.end());
 }
@@ -481,56 +461,27 @@ NodeId KrpcProtocol::string_to_node_id(const std::string& str) {
     return id;
 }
 
-// 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;
-        }
-        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);
+// Append a numeric IpAddress in compact form (its 4 or 16 raw bytes) to `out`.
+// Returns the number of address bytes written, or 0 for an unspecified address.
+static size_t append_compact_address(const IpAddress& ip, std::string& out) {
+    const ByteView b = ip.bytes();
+    if (b.empty()) {  // unspecified — emit 0.0.0.0 to keep the record length valid
+        out.append(4, '\x00');
         return 4;
     }
-    // Invalid IPv4, use 0.0.0.0
-    out.append(4, '\x00');
-    return 4;
+    out.append(reinterpret_cast<const char*>(b.data()), b.size());
+    return b.size();
 }
 
 // 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);
+// straight into an IpAddress — a memcpy of the raw bytes, no inet_ntop. The caller
+// has already validated that [offset, offset+addr_len) is in bounds.
+static IpAddress read_compact_ip(const std::string& compact_info, size_t offset, size_t addr_len) {
+    const auto* p = reinterpret_cast<const uint8_t*>(compact_info.data()) + offset;
+    return IpAddress::from_bytes(ByteView(p, addr_len)).value_or(IpAddress{});
 }
 
-std::string KrpcProtocol::compact_peer_info(const Peer& peer) {
+std::string KrpcProtocol::compact_peer_info(const Address& peer) {
     std::string result;
     result.reserve(18);
 
@@ -561,8 +512,8 @@ std::string KrpcProtocol::compact_node_info(const KrpcNode& node) {
     return result;
 }
 
-std::vector<Peer> KrpcProtocol::parse_compact_peer_info(const std::string& compact_info) {
-    std::vector<Peer> peers;
+std::vector<Address> KrpcProtocol::parse_compact_peer_info(const std::string& compact_info) {
+    std::vector<Address> peers;
 
     // 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;
@@ -578,13 +529,13 @@ std::vector<Peer> KrpcProtocol::parse_compact_peer_info(const std::string& compa
     }
 
     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);
+        IpAddress ip = read_compact_ip(compact_info, i, addr_len);
 
         uint16_t port = 0;
         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);
+        peers.emplace_back(ip, port);
     }
 
     return peers;
@@ -608,14 +559,14 @@ std::vector<KrpcNode> KrpcProtocol::parse_compact_node_info(const std::string& c
         std::copy_n(compact_info.begin() + i, 20, node_id.begin());
 
         // Extract IP address (4 or 16 bytes)
-        std::string ip_str = read_compact_address(compact_info, i + 20, addr_len);
+        IpAddress ip = read_compact_ip(compact_info, i + 20, addr_len);
 
         // Extract port (2 bytes)
         uint16_t port = 0;
         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);
+        nodes.emplace_back(node_id, ip, port);
     }
 
     return nodes;

package/native-src/src/{krpc.h → librats/dht/krpc.h}

@@ -1,12 +1,12 @@
 #pragma once
 
-#include "bencode.h"
-#include "socket.h"
+#include "librats/bittorrent/bencode.h"
+#include "librats/core/ip_address.h"
+#include "librats/core/socket.h"
 #include <string>
 #include <vector>
 #include <array>
 #include <memory>
-#include <atomic>
 
 namespace librats {
 
@@ -46,12 +46,12 @@ enum class KrpcErrorCode {
  * KRPC Node information
  */
 struct KrpcNode {
-    NodeId id;
-    std::string ip;
-    uint16_t port;
-    
+    NodeId    id;
+    IpAddress ip;
+    uint16_t  port;
+
     KrpcNode() : id(), port(0) {}
-    KrpcNode(const NodeId& node_id, const std::string& ip_addr, uint16_t port_num)
+    KrpcNode(const NodeId& node_id, const IpAddress& ip_addr, uint16_t port_num)
         : id(node_id), ip(ip_addr), port(port_num) {}
 };
 
@@ -78,14 +78,16 @@ struct KrpcMessage {
     // For responses
     NodeId response_id;
     std::vector<KrpcNode> nodes;  // may mix IPv4/IPv6 nodes; encoder splits into nodes/nodes6
-    std::vector<Peer> peers;
+    std::vector<Address> 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;
+    // Kept as a numeric IpAddress (not text): it comes off the wire as raw bytes and is
+    // consumed as raw bytes, so no round-trip through a string is needed.
+    IpAddress external_ip;
+    uint16_t  external_port = 0;
 
     // For errors
     KrpcErrorCode error_code;
@@ -112,7 +114,7 @@ public:
     
     static KrpcMessage create_ping_response(const std::string& transaction_id, const NodeId& response_id);
     static KrpcMessage create_find_node_response(const std::string& transaction_id, const NodeId& response_id, const std::vector<KrpcNode>& nodes);
-    static KrpcMessage create_get_peers_response(const std::string& transaction_id, const NodeId& response_id, const std::vector<Peer>& peers, const std::string& token);
+    static KrpcMessage create_get_peers_response(const std::string& transaction_id, const NodeId& response_id, const std::vector<Address>& peers, const std::string& token);
     static KrpcMessage create_get_peers_response_with_nodes(const std::string& transaction_id, const NodeId& response_id, const std::vector<KrpcNode>& nodes, const std::string& token);
     static KrpcMessage create_announce_peer_response(const std::string& transaction_id, const NodeId& response_id);
     
@@ -123,22 +125,19 @@ public:
      */
     static std::vector<uint8_t> encode_message(const KrpcMessage& message);
     static std::unique_ptr<KrpcMessage> decode_message(const std::vector<uint8_t>& data);
-    
-    /**
-     * Generate transaction ID
-     */
-    static std::string generate_transaction_id();
-    
+
     /**
      * Utility functions
      */
     static std::string node_id_to_string(const NodeId& id);
     static NodeId string_to_node_id(const std::string& str);
+    // The KRPC method name ("ping" / "find_node" / "get_peers" / "announce_peer"); used for logging.
+    static std::string query_type_to_string(KrpcQueryType type);
     // 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_peer_info(const Address& 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<Address> parse_compact_peer_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);
 
@@ -152,9 +151,6 @@ private:
     static std::unique_ptr<KrpcMessage> decode_error(const BencodeValue& data);
     
     static KrpcQueryType string_to_query_type(const std::string& str);
-    static std::string query_type_to_string(KrpcQueryType type);
-    
-    static std::atomic<uint32_t> transaction_counter_;
 };
 
 } // namespace librats 

package/native-src/src/librats/dht/log.h

@@ -0,0 +1,38 @@
+#pragma once
+
+/**
+ * @file log.h
+ * @brief Small logging helpers shared across the DHT modules.
+ *
+ * Formatting sugar on top of util/logger.h — nothing more. The DHT logs under a set of
+ * dot-namespaced tags so each subsystem gets its own stable colour and is easy to grep:
+ *
+ *   "dht"        — client facade + runner lifecycle (start/stop/bootstrap/external-ip)
+ *   "dht.find"   — lookups (find_peers / announce) and their progress
+ *   "dht.route"  — routing table (bucket splits, evictions, table summary)
+ *   "dht.rpc"    — outgoing/incoming queries, timeouts, anti-spoof drops
+ *   "dht.krpc"   — the KRPC wire codec (encode/decode); defined in krpc.cpp
+ *
+ * Endpoints render via Address::to_string(); ids render via short_hex() below.
+ */
+
+#include "librats/dht/id.h"
+#include "librats/util/logger.h"
+
+#include <cstddef>
+#include <string>
+
+namespace librats {
+namespace dht {
+
+// A compact, log-friendly rendering of a 160-bit id: its leading `chars` hex digits
+// (default 8, like a git short hash). The full 40-char id is unreadable in a log line
+// and its leading bytes are more than enough to follow one contact across lines. Reach
+// for to_hex(id) only where the complete id genuinely matters (e.g. our own id at start).
+inline std::string short_hex(const NodeId& id, std::size_t chars = 8) {
+    const std::string full = to_hex(id);
+    return chars >= full.size() ? full : full.substr(0, chars);
+}
+
+} // namespace dht
+} // namespace librats