librats 0.7.1 → 0.8.0

package/native-src/src/bt_network.h

@@ -5,12 +5,14 @@
  * @brief Async network layer for BitTorrent peer connections
  * 
  * Provides efficient multiplexed I/O for managing multiple peer connections
- * with non-blocking sockets. Buffers are owned by BtPeerConnection (single
- * source of truth) - this class only handles socket I/O.
+ * using platform-optimal I/O polling (epoll/kqueue/WSAPoll).
+ * Buffers are owned by BtPeerConnection (single source of truth) -
+ * this class only handles socket I/O.
  */
 
 #include "bt_types.h"
 #include "bt_peer_connection.h"
+#include "io_poller.h"
 #include "socket.h"
 
 #include <vector>
@@ -37,7 +39,7 @@ struct BtNetworkConfig {
     size_t max_connections;         ///< Maximum total connections
     bool enable_incoming;           ///< Accept incoming connections
     int connect_timeout_ms;         ///< Timeout for outgoing connections (ms)
-    int select_timeout_ms;          ///< Timeout for select() call (ms)
+    int poll_timeout_ms;            ///< Timeout for I/O poll (ms)
     size_t send_buffer_high_water;  ///< High water mark for send buffer
     PeerID peer_id;                 ///< Our peer ID (for incoming connections)
     
@@ -46,7 +48,7 @@ struct BtNetworkConfig {
         , max_connections(200)
         , enable_incoming(true)
         , connect_timeout_ms(30000)
-        , select_timeout_ms(15)
+        , poll_timeout_ms(15)
         , send_buffer_high_water(1024 * 1024)  // 1MB
         , peer_id{} {}
 };
@@ -150,10 +152,16 @@ struct DisconnectedEvent {
 /**
  * @brief Manages all BitTorrent peer connections
  * 
- * Provides async I/O via select() multiplexing:
+ * Provides async I/O via platform-optimal multiplexing:
+ * - Linux:   epoll   (O(1) per event)
+ * - macOS:   kqueue  (O(1) per event)
+ * - Windows: WSAPoll (no FD_SETSIZE limit)
+ * 
+ * Features:
  * - Listens for incoming connections
  * - Manages outgoing connection queue
  * - Handles non-blocking reads/writes
+ * - TCP_NODELAY for low-latency messaging
  * - Invokes callbacks for events
  * 
  * Thread-safety: The manager runs its own I/O thread.
@@ -328,6 +336,9 @@ private:
     /// Main I/O loop (runs in separate thread)
     void io_loop();
     
+    /// Synchronize poller state with current connections (under mutex)
+    void sync_poller();
+    
     /// Process the queue of pending connections
     void process_pending_connects();
     
@@ -360,6 +371,9 @@ private:
     /// Handle info_hash discovered from incoming connection handshake
     void on_incoming_info_hash(BtPeerConnection* conn, const BtInfoHash& info_hash);
     
+    /// Set TCP_NODELAY on a socket (disable Nagle's algorithm)
+    static bool set_tcp_nodelay(socket_t sock);
+    
     //=========================================================================
     // Data Members
     //=========================================================================
@@ -373,6 +387,12 @@ private:
     
     mutable std::mutex mutex_;
     
+    /// Platform-optimal I/O poller (epoll/kqueue/WSAPoll)
+    std::unique_ptr<IOPoller> poller_;
+    
+    /// Tracks current poller event mask per socket (to avoid redundant modify calls)
+    std::unordered_map<socket_t, uint32_t> poller_state_;
+    
     /// Active connections by socket
     std::unordered_map<socket_t, SocketContext> connections_;
     

package/native-src/src/bt_peer_connection.cpp

@@ -358,6 +358,9 @@ void BtPeerConnection::process_handshake() {
     
     handshake_received_ = true;
     
+    // Identify client from peer_id
+    peer_client_name_ = identify_client(peer_id_);
+    
     // Format peer_id for logging (first 8 chars, printable only)
     std::string peer_id_str;
     for (size_t i = 0; i < 8 && i < peer_id_.size(); ++i) {
@@ -366,6 +369,7 @@ void BtPeerConnection::process_handshake() {
     }
     
     LOG_INFO("BtPeerConn", "Handshake received from " + ip_ + ", peer_id=" + peer_id_str + 
+             ", client=" + peer_client_name_ +
              ", ext_protocol=" + (hs->extensions.extension_protocol ? "yes" : "no") +
              ", fast=" + (hs->extensions.fast ? "yes" : "no"));
     
@@ -604,6 +608,13 @@ void BtPeerConnection::parse_extension_handshake(const std::vector<uint8_t>& pay
                       std::to_string(peer_ut_metadata_id_));
         }
     }
+    
+    // Extract client version string from 'v' field
+    auto v_it = dict.find("v");
+    if (v_it != dict.end() && v_it->second.is_string()) {
+        peer_client_name_ = v_it->second.as_string();
+        LOG_INFO("BtPeerConn", "Peer " + ip_ + " client: " + peer_client_name_);
+    }
 }
 
 void BtPeerConnection::queue_send(const std::vector<uint8_t>& data) {

package/native-src/src/bt_peer_connection.h

@@ -355,6 +355,11 @@ public:
      */
     uint8_t peer_ut_metadata_id() const { return peer_ut_metadata_id_; }
     
+    /**
+     * @brief Get peer's client name (from extension handshake "v" field, or identified from peer_id)
+     */
+    const std::string& peer_client_name() const { return peer_client_name_; }
+    
     //=========================================================================
     // Sending Messages
     //=========================================================================
@@ -549,6 +554,7 @@ private:
     bool extension_handshake_received_;
     size_t peer_metadata_size_;
     uint8_t peer_ut_metadata_id_;
+    std::string peer_client_name_;  ///< Client name (from "v" field or peer_id identification)
     
     // Protocol state
     bool am_choking_;

package/native-src/src/bt_torrent.cpp

@@ -135,7 +135,7 @@ Torrent::Torrent(const BtInfoHash& info_hash,
     , have_pieces_(0) {
     
     LOG_INFO("Torrent", "Creating torrent '" + name + "' from magnet link (no metadata yet), info_hash=" + 
-             info_hash_to_hex(info_hash).substr(0, 16) + "...");
+             info_hash_to_hex(info_hash));
     
     // No picker until we have metadata
     
@@ -233,6 +233,7 @@ void Torrent::stop() {
     // Clear metadata exchange state
     metadata_buffer_.clear();
     metadata_pieces_received_.clear();
+    metadata_pieces_requested_.clear();
     peer_metadata_size_.clear();
     peer_ut_metadata_id_.clear();
     
@@ -725,6 +726,7 @@ void Torrent::tick() {
             // Clear metadata state
             metadata_buffer_.clear();
             metadata_pieces_received_.clear();
+            metadata_pieces_requested_.clear();
             peer_metadata_size_.clear();
             peer_ut_metadata_id_.clear();
             
@@ -778,8 +780,9 @@ void Torrent::tick() {
 //=============================================================================
 
 void Torrent::on_peer_connected(BtPeerConnection* peer) {
-    LOG_DEBUG("Torrent", "Peer " + peer->ip() + " connected, has_metadata=" + 
-              (has_metadata_unlocked() ? "true" : "false"));
+    LOG_DEBUG("Torrent", "Peer " + peer->ip() + " connected" +
+              (peer->peer_client_name().empty() ? "" : " [" + peer->peer_client_name() + "]") +
+              ", has_metadata=" + (has_metadata_unlocked() ? "true" : "false"));
     
     // Send extension handshake if peer supports it
     if (peer->peer_extensions().extension_protocol) {
@@ -1506,11 +1509,15 @@ void Torrent::request_metadata(BtPeerConnection* peer) {
     if (metadata_buffer_.empty()) {
         metadata_buffer_.resize(metadata_size);
         metadata_pieces_received_.resize(num_pieces, false);
+        metadata_pieces_requested_.resize(num_pieces, false);
     }
+
+    // Request pieces we don't have yet (pipeline up to 4 requests)
+    int requests_sent = 0;
+    const int max_pending_requests = 4;
     
-    // Request pieces we don't have yet
     for (uint32_t piece = 0; piece < num_pieces; ++piece) {
-        if (!metadata_pieces_received_[piece]) {
+        if (!metadata_pieces_received_[piece] && !metadata_pieces_requested_[piece]) {
             // Create request message
             BencodeValue req = BencodeValue::create_dict();
             req["msg_type"] = BencodeValue(static_cast<int64_t>(0));  // Request
@@ -1518,10 +1525,11 @@ void Torrent::request_metadata(BtPeerConnection* peer) {
             
             auto req_payload = req.encode();
             peer->send_extended(peer_ut_id, req_payload);
+            metadata_pieces_requested_[piece] = true;
             
             LOG_DEBUG("Torrent", "Requesting metadata piece " + std::to_string(piece) + 
                       " from " + peer->ip());
-            break;  // Request one piece at a time for now
+            if (++requests_sent >= max_pending_requests) break;
         }
     }
 }
@@ -1580,6 +1588,7 @@ void Torrent::on_metadata_message(BtPeerConnection* peer,
             
             if (piece < metadata_pieces_received_.size()) {
                 metadata_pieces_received_[piece] = true;
+                metadata_pieces_requested_[piece] = false;
             }
             
             LOG_DEBUG("Torrent", "Received metadata piece " + std::to_string(piece) + 
@@ -1647,6 +1656,7 @@ void Torrent::on_metadata_complete() {
         // Clear metadata tracking data
         metadata_buffer_.clear();
         metadata_pieces_received_.clear();
+        metadata_pieces_requested_.clear();
         peer_metadata_size_.clear();
         peer_ut_metadata_id_.clear();
         
@@ -1672,6 +1682,7 @@ void Torrent::on_metadata_complete() {
         // Could retry from other peers
         metadata_buffer_.clear();
         metadata_pieces_received_.clear();
+        metadata_pieces_requested_.clear();
     }
 }
 

package/native-src/src/bt_torrent.h

@@ -631,6 +631,7 @@ private:
     // Metadata exchange (for magnet links)
     std::vector<uint8_t> metadata_buffer_;
     std::vector<bool> metadata_pieces_received_;
+    std::vector<bool> metadata_pieces_requested_;
     std::unordered_map<BtPeerConnection*, size_t> peer_metadata_size_;
     std::unordered_map<BtPeerConnection*, uint8_t> peer_ut_metadata_id_;
     std::chrono::steady_clock::time_point metadata_download_started_;

package/native-src/src/bt_types.h

@@ -10,6 +10,8 @@
 
 #include <array>
 #include <cstdint>
+#include <cstring>
+#include <cstdio>
 #include <string>
 #include <random>
 #include <chrono>
@@ -270,39 +272,304 @@ inline bool is_zero_hash(const BtInfoHash& hash) {
 }
 
 //=============================================================================
-// Client ID Parsing
+// Client ID Parsing (BEP 20)
 //=============================================================================
 
+namespace detail {
+
+/**
+ * @brief Decode a version digit from peer ID (supports 0-9 and A-Z)
+ */
+inline int decode_version_digit(uint8_t c) {
+    if (c >= '0' && c <= '9') return c - '0';
+    if (c >= 'A' && c <= 'Z') return c - 'A' + 10;
+    if (c >= 'a' && c <= 'z') return c - 'a' + 10;
+    return 0;
+}
+
 /**
- * @brief Extract client name from peer ID (BEP 20)
+ * @brief Azureus-style client name lookup table
+ * Based on BEP 20 and libtorrent's identify_client implementation
+ */
+inline const char* lookup_az_client(const char* code) {
+    // Sorted alphabetically by 2-char code for binary search potential
+    // Using linear search for simplicity - table is small enough
+    struct Entry { const char* code; const char* name; };
+    static const Entry entries[] = {
+        {"7T", "aTorrent"},
+        {"AB", "AnyEvent BitTorrent"},
+        {"AG", "Ares"},
+        {"AR", "Arctic Torrent"},
+        {"AT", "Artemis"},
+        {"AV", "Avicora"},
+        {"AX", "BitPump"},
+        {"AZ", "Azureus"},
+        {"A~", "Ares"},
+        {"BB", "BitBuddy"},
+        {"BC", "BitComet"},
+        {"BE", "baretorrent"},
+        {"BF", "Bitflu"},
+        {"BG", "BTG"},
+        {"BI", "BiglyBT"},
+        {"BL", "BitBlinder"},
+        {"BP", "BitTorrent Pro"},
+        {"BR", "BitRocket"},
+        {"BS", "BTSlave"},
+        {"BT", "BitTorrent"},
+        {"BU", "BigUp"},
+        {"BW", "BitWombat"},
+        {"BX", "BittorrentX"},
+        {"CD", "Enhanced CTorrent"},
+        {"CT", "CTorrent"},
+        {"DE", "Deluge"},
+        {"DP", "Propagate Data Client"},
+        {"EB", "EBit"},
+        {"ES", "electric sheep"},
+        {"FC", "FileCroc"},
+        {"FT", "FoxTorrent"},
+        {"FW", "FrostWire"},
+        {"FX", "Freebox BitTorrent"},
+        {"GS", "GSTorrent"},
+        {"HK", "Hekate"},
+        {"HL", "Halite"},
+        {"HN", "Hydranode"},
+        {"IL", "iLivid"},
+        {"KC", "Koinonein"},
+        {"KG", "KGet"},
+        {"KT", "KTorrent"},
+        {"LC", "LeechCraft"},
+        {"LH", "LH-ABC"},
+        {"LK", "Linkage"},
+        {"LP", "lphant"},
+        {"LR", "librats"},
+        {"LT", "libtorrent"},
+        {"LW", "Limewire"},
+        {"ML", "MLDonkey"},
+        {"MO", "Mono Torrent"},
+        {"MP", "MooPolice"},
+        {"MR", "Miro"},
+        {"MT", "Moonlight Torrent"},
+        {"NX", "Net Transport"},
+        {"OS", "OneSwarm"},
+        {"OT", "OmegaTorrent"},
+        {"PD", "Pando"},
+        {"QD", "QQDownload"},
+        {"QT", "Qt 4"},
+        {"RT", "Retriever"},
+        {"RZ", "RezTorrent"},
+        {"SB", "Swiftbit"},
+        {"SD", "Xunlei"},
+        {"SK", "spark"},
+        {"SN", "ShareNet"},
+        {"SS", "SwarmScope"},
+        {"ST", "SymTorrent"},
+        {"SZ", "Shareaza"},
+        {"S~", "Shareaza (beta)"},
+        {"TB", "Torch"},
+        {"TL", "Tribler"},
+        {"TN", "Torrent.NET"},
+        {"TR", "Transmission"},
+        {"TS", "TorrentStorm"},
+        {"TT", "TuoTu"},
+        {"UL", "uLeecher"},
+        {"UM", "uTorrent Mac"},
+        {"UT", "uTorrent"},
+        {"VG", "Vagaa"},
+        {"WT", "BitLet"},
+        {"WY", "FireTorrent"},
+        {"XF", "Xfplay"},
+        {"XL", "Xunlei"},
+        {"XS", "XSwifter"},
+        {"XT", "XanTorrent"},
+        {"XX", "Xtorrent"},
+        {"ZO", "Zona"},
+        {"ZT", "ZipTorrent"},
+        {"lt", "rTorrent"},
+        {"pX", "pHoeniX"},
+        {"qB", "qBittorrent"},
+        {"st", "SharkTorrent"},
+    };
+
+    for (const auto& e : entries) {
+        if (e.code[0] == code[0] && e.code[1] == code[1]) {
+            return e.name;
+        }
+    }
+    return nullptr;
+}
+
+/**
+ * @brief Generic (non-standard) client name lookup
+ */
+inline const char* lookup_generic_client(const uint8_t* id) {
+    struct Entry { int offset; const char* pattern; const char* name; };
+    static const Entry entries[] = {
+        {0, "Deadman Walking-", "Deadman"},
+        {5, "Azureus", "Azureus 2.0.3.2"},
+        {0, "DansClient", "XanTorrent"},
+        {4, "btfans", "SimpleBT"},
+        {0, "PRC.P---", "Bittorrent Plus! II"},
+        {0, "P87.P---", "Bittorrent Plus!"},
+        {0, "S587Plus", "Bittorrent Plus!"},
+        {0, "martini", "Martini Man"},
+        {0, "Plus---", "Bittorrent Plus"},
+        {0, "turbobt", "TurboBT"},
+        {0, "a00---0", "Swarmy"},
+        {0, "a02---0", "Swarmy"},
+        {0, "T00---0", "Teeweety"},
+        {0, "BTDWV-", "Deadman Walking"},
+        {2, "BS", "BitSpirit"},
+        {0, "-SP", "BitSpirit 3.6"},
+        {0, "Pando-", "Pando"},
+        {0, "LIME", "LimeWire"},
+        {0, "btuga", "BTugaXP"},
+        {0, "oernu", "BTugaXP"},
+        {0, "Mbrst", "Burst!"},
+        {0, "PEERAPP", "PeerApp"},
+        {0, "Plus", "Plus!"},
+        {0, "-Qt-", "Qt"},
+        {0, "exbc", "BitComet"},
+        {0, "DNA", "BitTorrent DNA"},
+        {0, "-G3", "G3 Torrent"},
+        {0, "-FG", "FlashGet"},
+        {0, "-ML", "MLdonkey"},
+        {0, "-MG", "Media Get"},
+        {0, "XBT", "XBT"},
+        {0, "OP", "Opera"},
+        {2, "RS", "Rufus"},
+        {0, "AZ2500BT", "BitTyrant"},
+        {0, "btpd/", "BitTorrent Protocol Daemon"},
+        {0, "TIX", "Tixati"},
+        {0, "QVOD", "Qvod"},
+    };
+
+    for (const auto& e : entries) {
+        const char* p = e.pattern;
+        const char* s = reinterpret_cast<const char*>(id) + e.offset;
+        size_t len = std::strlen(p);
+        if (e.offset + len <= BT_PEER_ID_SIZE && std::memcmp(s, p, len) == 0) {
+            return e.name;
+        }
+    }
+    return nullptr;
+}
+
+} // namespace detail
+
+/**
+ * @brief Identify BitTorrent client from peer ID (BEP 20)
  * 
- * Attempts to identify the client from the peer ID prefix
+ * Supports three encoding styles:
+ * - Azureus-style: -XX1234-xxxxxxxxxxxx
+ * - Shadow-style: Xyyy--xxxxxxxxxxxxxx
+ * - Mainline-style: M1-2-3--xxxxxxxxxxxx
+ * Also recognizes many non-standard encodings.
  * 
- * @param id Peer ID to parse
- * @return Client name or "Unknown"
+ * @param id 20-byte peer ID
+ * @return Human-readable client name with version, or "Unknown [...]"
  */
 inline std::string identify_client(const PeerID& id) {
+    // Check if all zeros
+    bool all_zero = true;
+    for (uint8_t b : id) { if (b != 0) { all_zero = false; break; } }
+    if (all_zero) return "Unknown";
+    
+    // Check non-standard encodings first
+    const char* generic = detail::lookup_generic_client(id.data());
+    if (generic) return generic;
+    
+    // Check Bits on Wheels special case
+    if (id[0] == '-' && id[1] == 'B' && id[2] == 'O' && id[3] == 'W' && id[7] == '-') {
+        return "Bits on Wheels " + std::string(reinterpret_cast<const char*>(id.data()) + 4, 3);
+    }
+    
     // Azureus-style: -XX1234-
-    if (id[0] == '-' && id[7] == '-') {
-        char client[3] = {static_cast<char>(id[1]), static_cast<char>(id[2]), '\0'};
-        std::string client_code(client);
+    if (id[0] == '-' && id[7] == '-' && 
+        (id[1] >= 'A' || id[1] >= 'a') &&
+        id[3] >= '0' && id[4] >= '0' && id[5] >= '0' && id[6] >= '0') {
+        
+        char code[3] = {static_cast<char>(id[1]), static_cast<char>(id[2]), '\0'};
+        
+        int v1 = detail::decode_version_digit(id[3]);
+        int v2 = detail::decode_version_digit(id[4]);
+        int v3 = detail::decode_version_digit(id[5]);
+        int v4 = detail::decode_version_digit(id[6]);
+        
+        const char* name = detail::lookup_az_client(code);
+        std::string client_name = name ? name : std::string("Unknown (") + code + ")";
         
-        if (client_code == "LR") return "librats";
-        if (client_code == "LT") return "libtorrent";
-        if (client_code == "qB") return "qBittorrent";
-        if (client_code == "DE") return "Deluge";
-        if (client_code == "TR") return "Transmission";
-        if (client_code == "UT") return "uTorrent";
-        if (client_code == "AZ") return "Azureus/Vuze";
-        if (client_code == "BT") return "BitTorrent";
+        std::string version = std::to_string(v1) + "." + std::to_string(v2) + "." + std::to_string(v3);
+        if (v4 != 0) {
+            version += "." + std::to_string(v4);
+        }
+        
+        return client_name + " " + version;
+    }
+    
+    // Shadow-style: first char is client, next 3 are version
+    if ((id[0] >= 'A' && id[0] <= 'Z') || (id[0] >= 'a' && id[0] <= 'z')) {
+        // Check for shadow format: X + 3 version bytes + "--"
+        if (id[4] == '-' && id[5] == '-') {
+            if (id[1] >= '0' && id[2] >= '0' && id[3] >= '0') {
+                char c = static_cast<char>(id[0]);
+                const char* name = nullptr;
+                switch (c) {
+                    case 'A': name = "ABC"; break;
+                    case 'M': name = "Mainline"; break;
+                    case 'O': name = "Osprey Permaseed"; break;
+                    case 'Q': name = "BTQueue"; break;
+                    case 'R': name = "Tribler"; break;
+                    case 'S': name = "Shadow"; break;
+                    case 'T': name = "BitTornado"; break;
+                    case 'U': name = "UPnP"; break;
+                    default: break;
+                }
+                if (name) {
+                    int v1 = detail::decode_version_digit(id[1]);
+                    int v2 = detail::decode_version_digit(id[2]);
+                    int v3 = detail::decode_version_digit(id[3]);
+                    return std::string(name) + " " + std::to_string(v1) + "." + 
+                           std::to_string(v2) + "." + std::to_string(v3);
+                }
+            }
+        }
         
-        return std::string("Unknown (") + client_code + ")";
+        // Mainline-style: M1-2-3--
+        char ids[21];
+        std::memcpy(ids, id.data(), 20);
+        ids[20] = '\0';
+        char name_ch = '\0';
+        int v1 = 0, v2 = 0, v3 = 0;
+        if (std::sscanf(ids, "%c%3d-%3d-%3d--", &name_ch, &v1, &v2, &v3) == 4 &&
+            name_ch >= 32 && name_ch < 127) {
+            const char* name = nullptr;
+            switch (name_ch) {
+                case 'M': name = "Mainline"; break;
+                default: break;
+            }
+            if (name) {
+                return std::string(name) + " " + std::to_string(v1) + "." + 
+                       std::to_string(v2) + "." + std::to_string(v3);
+            }
+        }
     }
     
-    // Shadow-style: first byte is client ID
-    // Not as common, but still used
+    // All zeros in first 12 bytes - special cases
+    bool first_12_zero = true;
+    for (int i = 0; i < 12; ++i) { if (id[i] != 0) { first_12_zero = false; break; } }
+    if (first_12_zero) {
+        if (id[12] == 0x97) return "Experimental 3.2.1b2";
+        if (id[12] == 0x00) return "Experimental 3.1";
+        return "Generic";
+    }
     
-    return "Unknown";
+    // Unknown - show printable representation
+    std::string unknown("Unknown [");
+    for (uint8_t c : id) {
+        unknown += (c >= 32 && c < 127) ? static_cast<char>(c) : '.';
+    }
+    unknown += "]";
+    return unknown;
 }
 
 //=============================================================================

package/native-src/src/dht.cpp

@@ -62,8 +62,19 @@ bool DhtClient::start() {
     }
     
     socket_ = create_udp_socket(port_, bind_address_);
+	// Fallback to free port
+    if (!is_valid_socket(socket_) && port_ > 0) {
+        // Requested port is not available, try ephemeral port as fallback
+        int original_port = port_;
+        LOG_DHT_WARN("UDP port " << original_port << " is not available, falling back to ephemeral port");
+        socket_ = create_udp_socket(0, bind_address_);
+        if (is_valid_socket(socket_)) {
+            port_ = get_bound_port(socket_);
+            LOG_DHT_INFO("Fell back from port " << original_port << " to ephemeral port " << port_);
+        }
+    }
     if (!is_valid_socket(socket_)) {
-        LOG_DHT_ERROR("Failed to create dual-stack UDP socket");
+        LOG_DHT_ERROR("Failed to create dual-stack UDP socket on port " << port_);
         return false;
     }
     
@@ -380,7 +391,7 @@ void DhtClient::network_loop() {
     
     while (running_) {
         Peer sender;
-        auto data = receive_udp_data(socket_, 1500, sender);  // MTU size
+        auto data = receive_udp_data(socket_, 1500, sender, -1);  // MTU size, blocking
         
         if (!data.empty()) {
             LOG_DHT_DEBUG("Received " << data.size() << " bytes from " << sender.ip << ":" << sender.port);
@@ -937,7 +948,8 @@ void DhtClient::handle_krpc_announce_peer(const KrpcMessage& message, const Peer
     }
     
     // Determine the actual port (BEP 5: implied_port support)
-    uint16_t peer_port = message.port;
+    // If implied_port is set, use the UDP source port instead of the explicit port field
+    uint16_t peer_port = message.implied_port ? sender.port : message.port;
     
     // Store the peer announcement
     Peer announcing_peer(sender.ip, peer_port);
@@ -1072,7 +1084,7 @@ bool DhtClient::send_krpc_message(const KrpcMessage& message, const Peer& peer)
     }
     
     LOG_DHT_DEBUG("Sending KRPC message (" << data.size() << " bytes) to " << peer.ip << ":" << peer.port);
-    int result = send_udp_data(socket_, data, peer);
+    int result = send_udp_data(socket_, data, peer.ip, peer.port);
     
     if (result > 0) {
         LOG_DHT_DEBUG("Successfully sent KRPC message to " << peer.ip << ":" << peer.port);
@@ -1101,9 +1113,9 @@ void DhtClient::send_krpc_get_peers(const Peer& peer, const InfoHash& info_hash)
     send_krpc_message(message, peer);
 }
 
-void DhtClient::send_krpc_announce_peer(const Peer& peer, const InfoHash& info_hash, uint16_t port, const std::string& token) {
+void DhtClient::send_krpc_announce_peer(const Peer& peer, const InfoHash& info_hash, uint16_t port, const std::string& token, bool implied_port) {
     std::string transaction_id = KrpcProtocol::generate_transaction_id();
-    auto message = KrpcProtocol::create_announce_peer_query(transaction_id, node_id_, info_hash, port, token);
+    auto message = KrpcProtocol::create_announce_peer_query(transaction_id, node_id_, info_hash, port, token, implied_port);
     send_krpc_message(message, peer);
 }
 
@@ -2138,13 +2150,19 @@ void DhtClient::send_announce_to_closest_nodes(PendingSearch& search) {
     
     LOG_DHT_INFO("Announcing to " << announce_targets.size() << " closest nodes with tokens");
     
+    // BEP 5: Use implied_port when the announce port is the same as the DHT port.
+    // This tells the receiving node to use the UDP source port from the packet,
+    // which is more accurate when behind NAT.
+    bool use_implied_port = (search.announce_port == port_);
+    
     // Send announce_peer to each target
     for (const auto& [node, token] : announce_targets) {
         LOG_DHT_DEBUG("Sending announce_peer to node " << node_id_to_hex(node.id) 
                       << " at " << node.peer.ip << ":" << node.peer.port
-                      << " with token (distance: " << get_bucket_index(node.id) << ")");
+                      << " with token (distance: " << get_bucket_index(node.id) << ")"
+                      << (use_implied_port ? " [implied_port]" : ""));
         
-        send_krpc_announce_peer(node.peer, search.info_hash, search.announce_port, token);
+        send_krpc_announce_peer(node.peer, search.info_hash, search.announce_port, token, use_implied_port);
     }
     
     LOG_DHT_INFO("Announce completed: sent announce_peer to " << announce_targets.size() 

package/native-src/src/dht.h

@@ -541,7 +541,7 @@ private:
     void send_krpc_ping(const Peer& peer);
     void send_krpc_find_node(const Peer& peer, const NodeId& target);
     void send_krpc_get_peers(const Peer& peer, const InfoHash& info_hash);
-    void send_krpc_announce_peer(const Peer& peer, const InfoHash& info_hash, uint16_t port, const std::string& token);
+    void send_krpc_announce_peer(const Peer& peer, const InfoHash& info_hash, uint16_t port, const std::string& token, bool implied_port = false);
     
     void add_node(const DhtNode& node, bool confirmed = true, bool no_verify = false);
     std::vector<DhtNode> find_closest_nodes(const NodeId& target, size_t count = K_BUCKET_SIZE);

package/native-src/src/ice.cpp

@@ -281,7 +281,7 @@ bool IceManager::ensure_socket() {
         return false;
     }
     
-    local_port_ = static_cast<uint16_t>(get_ephemeral_port(socket_));
+    local_port_ = static_cast<uint16_t>(get_bound_port(socket_));
     LOG_ICE_DEBUG("Created ICE socket on port " << local_port_);
     return true;
 }