librats 0.9.0 → 0.9.2

package/native-src/src/network_utils.cpp

@@ -16,6 +16,17 @@
     #else
         #include <ifaddrs.h>
     #endif
+
+    // macOS / BSD default-gateway lookup via the PF_ROUTE sysctl routing table.
+    #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || \
+        defined(__OpenBSD__) || defined(__DragonFly__)
+        #define RATS_HAVE_BSD_ROUTES 1
+        #include <sys/types.h>
+        #include <sys/socket.h>
+        #include <sys/sysctl.h>
+        #include <net/route.h>
+        #include <net/if.h>
+    #endif
 #endif
 
 
@@ -25,6 +36,12 @@
 #include <cstring>
 #include <iostream>
 #include <vector>
+#include <algorithm>
+
+#ifndef _WIN32
+    #include <cstdio>
+    #include <cstdlib>
+#endif
 
 // Network utilities module logging macros
 #define LOG_NETUTILS_DEBUG(message) LOG_DEBUG("network_utils", message)
@@ -379,6 +396,41 @@ bool is_hostname(const std::string& str) {
     return true;
 }
 
+bool is_public_ip(const std::string& ip) {
+    if (ip.empty()) return false;
+
+    if (is_valid_ipv6(ip)) {
+        struct in6_addr a;
+        if (inet_pton(AF_INET6, ip.c_str(), &a) != 1) return false;
+        const uint8_t* b = a.s6_addr;
+        bool all_zero = true;
+        for (int i = 0; i < 16; ++i) { if (b[i]) { all_zero = false; break; } }
+        if (all_zero) return false;                              // ::  (unspecified)
+        bool loopback = (b[15] == 1);
+        for (int i = 0; i < 15; ++i) { if (b[i]) { loopback = false; break; } }
+        if (loopback) return false;                              // ::1
+        if ((b[0] & 0xfe) == 0xfc) return false;                 // fc00::/7  unique local
+        if (b[0] == 0xfe && (b[1] & 0xc0) == 0x80) return false; // fe80::/10 link-local
+        if (b[0] == 0xff) return false;                          // ff00::/8  multicast
+        return true;
+    }
+
+    struct in_addr a;
+    if (inet_pton(AF_INET, ip.c_str(), &a) != 1) return false;
+    uint32_t h = ntohl(a.s_addr);
+    uint8_t o1 = static_cast<uint8_t>((h >> 24) & 0xff);
+    uint8_t o2 = static_cast<uint8_t>((h >> 16) & 0xff);
+    if (o1 == 0) return false;                                   // 0.0.0.0/8
+    if (o1 == 127) return false;                                 // loopback
+    if (o1 == 10) return false;                                  // 10.0.0.0/8
+    if (o1 == 172 && o2 >= 16 && o2 <= 31) return false;         // 172.16.0.0/12
+    if (o1 == 192 && o2 == 168) return false;                    // 192.168.0.0/16
+    if (o1 == 169 && o2 == 254) return false;                    // 169.254.0.0/16 link-local
+    if (o1 == 100 && o2 >= 64 && o2 <= 127) return false;        // 100.64.0.0/10 CGNAT
+    if (o1 >= 224) return false;                                 // multicast / reserved
+    return true;
+}
+
 std::vector<std::string> get_local_interface_addresses() {
     LOG_NETUTILS_DEBUG("Getting all local interface addresses (IPv4 and IPv6)");
     
@@ -390,11 +442,140 @@ std::vector<std::string> get_local_interface_addresses() {
     auto ipv6_addresses = get_local_interface_addresses_v6();
     addresses.insert(addresses.end(), ipv6_addresses.begin(), ipv6_addresses.end());
     
-    LOG_NETUTILS_INFO("Found " << addresses.size() << " total local interface addresses (" 
+    LOG_NETUTILS_INFO("Found " << addresses.size() << " total local interface addresses ("
                       << ipv4_addresses.size() << " IPv4, " << ipv6_addresses.size() << " IPv6)");
-    
+
     return addresses;
 }
 
+namespace {
+
+// Append unique, non-empty entries preserving order
+void append_unique(std::vector<std::string>& out, const std::string& value) {
+    if (value.empty()) return;
+    if (std::find(out.begin(), out.end(), value) == out.end()) {
+        out.push_back(value);
+    }
+}
+
+// Best-effort guess: for each local IPv4 assume the gateway is the .1 host of a
+// /24 network. Covers the overwhelming majority of home routers and serves as a
+// fallback when the OS routing table is unavailable.
+void append_gateway_heuristics(std::vector<std::string>& out) {
+    for (const auto& ip : get_local_interface_addresses_v4()) {
+        if (ip.empty() || ip == "127.0.0.1") continue;
+        auto last_dot = ip.find_last_of('.');
+        if (last_dot == std::string::npos) continue;
+        append_unique(out, ip.substr(0, last_dot) + ".1");
+    }
+}
+
+} // anonymous namespace
+
+std::vector<std::string> get_default_gateways() {
+    std::vector<std::string> gateways;
+
+#ifdef _WIN32
+    ULONG out_buf_len = sizeof(IP_ADAPTER_INFO);
+    std::vector<uint8_t> buffer(out_buf_len);
+    DWORD ret = GetAdaptersInfo(reinterpret_cast<PIP_ADAPTER_INFO>(buffer.data()), &out_buf_len);
+    if (ret == ERROR_BUFFER_OVERFLOW) {
+        buffer.resize(out_buf_len);
+        ret = GetAdaptersInfo(reinterpret_cast<PIP_ADAPTER_INFO>(buffer.data()), &out_buf_len);
+    }
+    if (ret == NO_ERROR) {
+        for (PIP_ADAPTER_INFO adapter = reinterpret_cast<PIP_ADAPTER_INFO>(buffer.data());
+             adapter != nullptr; adapter = adapter->Next) {
+            for (const IP_ADDR_STRING* gw = &adapter->GatewayList; gw != nullptr; gw = gw->Next) {
+                std::string gw_ip(gw->IpAddress.String);
+                if (gw_ip != "0.0.0.0") {
+                    append_unique(gateways, gw_ip);
+                }
+            }
+        }
+    } else {
+        LOG_NETUTILS_DEBUG("GetAdaptersInfo failed with error: " << ret);
+    }
+#elif defined(__linux__)
+    // /proc/net/route columns: Iface Destination Gateway Flags ... (hex, little-endian)
+    if (FILE* f = std::fopen("/proc/net/route", "r")) {
+        char line[256];
+        // Skip header line
+        if (std::fgets(line, sizeof(line), f)) {
+            char iface[64];
+            unsigned long dest = 0, gw = 0;
+            while (std::fgets(line, sizeof(line), f)) {
+                if (std::sscanf(line, "%63s %lx %lx", iface, &dest, &gw) == 3) {
+                    if (dest == 0 && gw != 0) {
+                        struct in_addr addr;
+                        addr.s_addr = static_cast<in_addr_t>(gw);
+                        char ip_str[INET_ADDRSTRLEN];
+                        if (inet_ntop(AF_INET, &addr, ip_str, sizeof(ip_str))) {
+                            append_unique(gateways, ip_str);
+                        }
+                    }
+                }
+            }
+        }
+        std::fclose(f);
+    }
+#elif defined(RATS_HAVE_BSD_ROUTES)
+    // Dump the IPv4 routing table and pick the gateway of the default route(s).
+    int mib[6] = { CTL_NET, PF_ROUTE, 0, AF_INET, NET_RT_DUMP, 0 };
+    size_t needed = 0;
+    if (sysctl(mib, 6, nullptr, &needed, nullptr, 0) == 0 && needed > 0) {
+        std::vector<char> buf(needed);
+        if (sysctl(mib, 6, buf.data(), &needed, nullptr, 0) == 0) {
+            // sockaddrs in a routing message are padded to a 4-byte boundary.
+            auto sa_roundup = [](socklen_t len) -> size_t {
+                return len ? (1 + ((static_cast<size_t>(len) - 1) | (sizeof(uint32_t) - 1)))
+                           : sizeof(uint32_t);
+            };
+            char* lim = buf.data() + needed;
+            for (char* next = buf.data(); next + sizeof(struct rt_msghdr) <= lim; ) {
+                auto* rtm = reinterpret_cast<struct rt_msghdr*>(next);
+                if (rtm->rtm_msglen == 0) break;
+                char* msg_end = next + rtm->rtm_msglen;
+                next = msg_end;
+
+                if (!(rtm->rtm_flags & RTF_GATEWAY)) continue;
+                if (!(rtm->rtm_addrs & RTA_DST) || !(rtm->rtm_addrs & RTA_GATEWAY)) continue;
+
+                // Address list follows the header, ordered by the RTA_* bit flags.
+                char* sa_ptr = reinterpret_cast<char*>(rtm + 1);
+                struct sockaddr* dst = nullptr;
+                struct sockaddr* gw = nullptr;
+                for (int bit = 1; bit && sa_ptr < msg_end; bit <<= 1) {
+                    if (!(rtm->rtm_addrs & bit)) continue;
+                    auto* sa = reinterpret_cast<struct sockaddr*>(sa_ptr);
+                    if (bit == RTA_DST) dst = sa;
+                    else if (bit == RTA_GATEWAY) gw = sa;
+                    sa_ptr += sa_roundup(sa->sa_len);
+                }
+
+                if (!dst || !gw) continue;
+                if (dst->sa_family != AF_INET || gw->sa_family != AF_INET) continue;
+                // Default route: destination 0.0.0.0
+                if (reinterpret_cast<struct sockaddr_in*>(dst)->sin_addr.s_addr != 0) continue;
+
+                char ip_str[INET_ADDRSTRLEN];
+                auto* gw4 = reinterpret_cast<struct sockaddr_in*>(gw);
+                if (inet_ntop(AF_INET, &gw4->sin_addr, ip_str, sizeof(ip_str))) {
+                    append_unique(gateways, ip_str);
+                }
+            }
+        }
+    } else {
+        LOG_NETUTILS_DEBUG("PF_ROUTE sysctl for default gateway failed");
+    }
+#endif
+
+    // Always add heuristics as a fallback so callers have something to try
+    append_gateway_heuristics(gateways);
+
+    LOG_NETUTILS_INFO("Detected " << gateways.size() << " default gateway candidate(s)");
+    return gateways;
+}
+
 } // namespace network_utils
 } // namespace librats

package/native-src/src/network_utils.h

@@ -41,11 +41,38 @@ bool is_valid_ipv6(const std::string& ip_str);
  */
 bool is_hostname(const std::string& str);
 
+/**
+ * Check whether an IP address is publicly routable (not a private/reserved range).
+ *
+ * Returns false for RFC1918 (10/8, 172.16/12, 192.168/16), CGNAT (100.64/10),
+ * loopback, link-local (169.254/16, fe80::/10), unspecified, multicast/reserved,
+ * and IPv6 unique-local (fc00::/7). A non-IP / unparseable string yields false.
+ *
+ * Used both by the DHT (BEP 42 external-IP voting) and by automatic port
+ * forwarding to detect a double-NAT gateway whose reported "external" IP is itself
+ * private and therefore not a usable public endpoint.
+ */
+bool is_public_ip(const std::string& ip);
+
 /**
  * Get all local network interface addresses (IPv4 and IPv6)
  * @return Vector of local IP addresses from all network interfaces
  */
 std::vector<std::string> get_local_interface_addresses();
 
+/**
+ * Get the default IPv4 gateway address(es) of the host.
+ *
+ * Used for NAT port forwarding (NAT-PMP talks to the gateway directly, and UPnP
+ * can use it to restrict discovery to the local router). The OS routing table is
+ * consulted where available (Windows iphlpapi, Linux /proc/net/route). When the
+ * platform routing table cannot be read, a best-effort heuristic derived from the
+ * local IPv4 addresses (network .1) is appended so callers still have a candidate
+ * to try.
+ *
+ * @return Vector of gateway IPv4 addresses, most specific first. May be empty.
+ */
+std::vector<std::string> get_default_gateways();
+
 } // namespace network_utils
 } // namespace librats

package/native-src/src/port_mapping.h

@@ -0,0 +1,78 @@
+#pragma once
+
+/**
+ * @file port_mapping.h
+ * @brief Shared types for automatic NAT port forwarding (UPnP IGD + NAT-PMP)
+ *
+ * Both the UPnP (@ref UpnpClient) and NAT-PMP (@ref NatPmpClient) backends ask a
+ * home router to forward an external (WAN) port to a local (LAN) port so that
+ * inbound peer connections can reach a host behind NAT. They share the small set
+ * of vocabulary types defined here: the transport protocol of the mapping, which
+ * backend produced a result, and the result/callback shape RatsClient consumes.
+ */
+
+#include <cstdint>
+#include <string>
+#include <functional>
+
+namespace librats {
+
+/// Transport protocol of a port mapping.
+enum class PortMapProtocol : uint8_t {
+    TCP,
+    UDP
+};
+
+/// Which NAT traversal backend produced a result.
+enum class PortMapTransport : uint8_t {
+    UPnP,
+    NatPMP
+};
+
+/// Human readable protocol name ("TCP"/"UDP").
+inline const char* to_string(PortMapProtocol p) {
+    return p == PortMapProtocol::TCP ? "TCP" : "UDP";
+}
+
+/// Human readable transport name ("UPnP"/"NAT-PMP").
+inline const char* to_string(PortMapTransport t) {
+    return t == PortMapTransport::UPnP ? "UPnP" : "NAT-PMP";
+}
+
+/**
+ * Result of a port mapping attempt.
+ *
+ * On success @ref external_port holds the public port the router assigned (which
+ * may differ from the requested one) and, when the backend can report it,
+ * @ref external_ip holds the discovered public IP address.
+ */
+struct PortMapResult {
+    PortMapTransport transport;          ///< Backend that produced this result
+    PortMapProtocol  protocol;           ///< Protocol of the mapping
+    bool             success = false;    ///< Whether the mapping is currently active
+    uint16_t         internal_port = 0;  ///< Local (LAN) port that was mapped
+    uint16_t         external_port = 0;  ///< Public (WAN) port assigned by the router
+    std::string      external_ip;        ///< Discovered public IP (may be empty)
+    std::string      error;              ///< Human readable error when !success
+};
+
+/**
+ * Callback invoked whenever a mapping is established, refreshed, removed or fails.
+ * Always called from the backend's own worker thread.
+ */
+using PortMapCallback = std::function<void(const PortMapResult&)>;
+
+/**
+ * Configuration for RatsClient's automatic port forwarding.
+ *
+ * Both backends run in parallel by default; whichever the router supports
+ * succeeds. Disabling one (or all) of them is a matter of flipping a flag.
+ */
+struct PortMappingConfig {
+    bool enabled = true;                  ///< Master switch for automatic port forwarding
+    bool enable_upnp = true;              ///< Use the UPnP IGD backend
+    bool enable_natpmp = true;            ///< Use the NAT-PMP backend
+    uint32_t lease_duration_seconds = 3600; ///< Requested lease duration
+};
+
+} // namespace librats

package/native-src/src/socket.cpp

@@ -844,18 +844,29 @@ int send_udp_data(socket_t socket, const std::vector<uint8_t>& data,
 }
 
 std::vector<uint8_t> receive_udp_data(socket_t socket, size_t buffer_size, Peer& sender_peer,
-                                      int timeout_ms) {
-    // Handle timeout using select
-    if (timeout_ms >= 0) {
+                                      int timeout_ms, socket_t interrupt_fd) {
+    // Handle timeout (and optional interrupt socket) using select. When no interrupt
+    // fd is supplied this path is identical to the plain timeout behavior.
+    const bool have_interrupt = is_valid_socket(interrupt_fd);
+    if (timeout_ms >= 0 || have_interrupt) {
         fd_set read_fds;
         FD_ZERO(&read_fds);
         FD_SET(socket, &read_fds);
+        socket_t maxfd = socket;
+        if (have_interrupt) {
+            FD_SET(interrupt_fd, &read_fds);
+            if (interrupt_fd > maxfd) maxfd = interrupt_fd;
+        }
 
         struct timeval timeout;
-        timeout.tv_sec = timeout_ms / 1000;
-        timeout.tv_usec = (timeout_ms % 1000) * 1000;
+        struct timeval* ptimeout = nullptr; // timeout_ms < 0 => block until readable
+        if (timeout_ms >= 0) {
+            timeout.tv_sec = timeout_ms / 1000;
+            timeout.tv_usec = (timeout_ms % 1000) * 1000;
+            ptimeout = &timeout;
+        }
 
-        int result = select(socket + 1, &read_fds, nullptr, nullptr, &timeout);
+        int result = select(static_cast<int>(maxfd) + 1, &read_fds, nullptr, nullptr, ptimeout);
         if (result == 0) {
             LOG_SOCKET_DEBUG("UDP receive timeout (" << timeout_ms << "ms)");
             return {};
@@ -863,6 +874,15 @@ std::vector<uint8_t> receive_udp_data(socket_t socket, size_t buffer_size, Peer&
             LOG_SOCKET_ERROR("Select error while waiting for UDP data");
             return {};
         }
+        // Woken by the interrupt socket (e.g. stop requested): leave the data socket
+        // untouched and report no data so the caller can re-check its stop flag.
+        if (have_interrupt && FD_ISSET(interrupt_fd, &read_fds)) {
+            return {};
+        }
+        // Guard against calling recvfrom on a data socket that isn't actually ready.
+        if (!FD_ISSET(socket, &read_fds)) {
+            return {};
+        }
     }
 
     std::vector<uint8_t> buffer(buffer_size);

package/native-src/src/socket.h

@@ -170,10 +170,14 @@ int send_udp_data(socket_t socket, const std::vector<uint8_t>& data, const std::
  * @param buffer_size Maximum number of bytes to receive
  * @param sender_peer Output parameter for the sender's peer info
  * @param timeout_ms Timeout in milliseconds (-1 for blocking, 0 for non-blocking, >0 for timeout)
- * @return Received data, empty vector on timeout or error
+ * @param interrupt_fd Optional second socket to watch; when it becomes readable the
+ *                     call returns immediately with an empty vector (used to wake a
+ *                     blocking receive on shutdown). INVALID_SOCKET_VALUE disables it.
+ * @return Received data, empty vector on timeout, error or interrupt
  */
 std::vector<uint8_t> receive_udp_data(socket_t socket, size_t buffer_size, Peer& sender_peer,
-                                      int timeout_ms = -1);
+                                      int timeout_ms = -1,
+                                      socket_t interrupt_fd = INVALID_SOCKET_VALUE);
 
 // Common Socket Functions
 /**