librats 0.9.1 → 1.0.0

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