librats 1.0.2 → 2.2.0

package/native-src/src/librats_portmap.cpp

@@ -1,419 +0,0 @@
-/**
- * @file librats_portmap.cpp
- * @brief Automatic port forwarding (UPnP IGD + NAT-PMP) integration for RatsClient
- *
- * Wires the standalone @ref UpnpClient and @ref NatPmpClient backends into the
- * RatsClient lifecycle. Both run in parallel; whichever the router supports maps
- * the TCP listen port so peers behind NAT can accept inbound connections. The
- * backends are started from RatsClient::start() and torn down in stop().
- */
-
-#include "librats.h"
-#include "librats_log_macros.h"
-#include "network_utils.h"
-#include "network_monitor.h"
-#include "logger.h"
-
-namespace librats {
-
-// ============================================================================
-// Configuration
-// ============================================================================
-
-void RatsClient::set_port_mapping_enabled(bool enabled) {
-    bool was_enabled;
-    {
-        std::lock_guard<std::mutex> lock(port_mapping_mutex_);
-        was_enabled = port_mapping_config_.enabled;
-        port_mapping_config_.enabled = enabled;
-    }
-
-    if (was_enabled != enabled) {
-        LOG_INFO("portmap", "Automatic port forwarding " << (enabled ? "enabled" : "disabled"));
-        if (running_.load()) {
-            if (enabled) {
-                start_port_mapping();
-            } else {
-                stop_port_mapping();
-            }
-        }
-        // Persist the new preference
-        save_configuration();
-    }
-}
-
-bool RatsClient::is_port_mapping_enabled() const {
-    std::lock_guard<std::mutex> lock(port_mapping_mutex_);
-    return port_mapping_config_.enabled;
-}
-
-void RatsClient::set_port_mapping_config(const PortMappingConfig& config) {
-    {
-        std::lock_guard<std::mutex> lock(port_mapping_mutex_);
-        port_mapping_config_ = config;
-    }
-    LOG_DEBUG("portmap", "Port mapping config updated (upnp=" << config.enable_upnp
-              << " natpmp=" << config.enable_natpmp << " lease=" << config.lease_duration_seconds << ")");
-}
-
-PortMappingConfig RatsClient::get_port_mapping_config() const {
-    std::lock_guard<std::mutex> lock(port_mapping_mutex_);
-    return port_mapping_config_;
-}
-
-void RatsClient::on_port_mapping(PortMapCallback callback) {
-    std::lock_guard<std::mutex> lock(port_mapping_mutex_);
-    port_mapping_callback_ = std::move(callback);
-}
-
-std::optional<std::pair<std::string, uint16_t>> RatsClient::get_mapped_public_address() const {
-    std::lock_guard<std::mutex> lock(port_mapping_mutex_);
-    // The "public address" peers should reach us on is the TCP peer-listen mapping.
-    if (mapped_external_tcp_port_ == 0 || mapped_external_ip_.empty()) {
-        return std::nullopt;
-    }
-    return std::make_pair(mapped_external_ip_, mapped_external_tcp_port_);
-}
-
-uint16_t RatsClient::get_advertised_port() const {
-    std::lock_guard<std::mutex> lock(port_mapping_mutex_);
-    return mapped_external_tcp_port_ != 0
-         ? mapped_external_tcp_port_
-         : static_cast<uint16_t>(listen_port_);
-}
-
-void RatsClient::add_port_mapping(PortMapProtocol protocol, uint16_t port) {
-    std::lock_guard<std::mutex> lock(port_mapping_mutex_);
-    if (upnp_client_)   upnp_client_->add_mapping(protocol, port);
-    if (natpmp_client_) natpmp_client_->add_mapping(protocol, port);
-}
-
-// ============================================================================
-// Result handling
-// ============================================================================
-
-void RatsClient::handle_port_mapping_result(const PortMapResult& result) {
-    // A gateway whose reported "external" IP is itself private means we're behind a
-    // second NAT (double-NAT): the mapping forwards a port on the inner router, but
-    // that doesn't make us reachable from the internet, and the inner port won't
-    // match whatever the outer NAT assigns. So such a mapping must NOT be treated as
-    // a public endpoint — we leave mapped_external_* untouched and let the advertised
-    // address fall back to listen_port_ / the STUN-discovered reflexive address.
-    // An empty external IP (gateway didn't report one) is "unknown", not private, so
-    // we keep the previous best-effort behavior for it.
-    const bool ip_is_private = !result.external_ip.empty() && !network_utils::is_public_ip(result.external_ip);
-
-    PortMapCallback user_cb;
-    bool tcp_port_changed = false;
-    bool warn_double_nat = false;
-    {
-        std::lock_guard<std::mutex> lock(port_mapping_mutex_);
-        if (result.success && !ip_is_private) {
-            if (!result.external_ip.empty()) {
-                mapped_external_ip_ = result.external_ip;
-            }
-            // Track the external port per protocol so the TCP (peer) and UDP (DHT)
-            // mappings don't overwrite each other.
-            if (result.protocol == PortMapProtocol::TCP) {
-                tcp_port_changed = (mapped_external_tcp_port_ != result.external_port);
-                mapped_external_tcp_port_ = result.external_port;
-            } else {
-                mapped_external_udp_port_ = result.external_port;
-            }
-        } else if (result.success && ip_is_private && !double_nat_warning_logged_) {
-            double_nat_warning_logged_ = true;
-            warn_double_nat = true;
-        }
-        user_cb = port_mapping_callback_;
-    }
-
-    if (result.success && ip_is_private) {
-        LOG_INFO("portmap", to_string(result.transport) << " mapped " << to_string(result.protocol)
-                 << " port " << result.internal_port << " -> external " << result.external_ip << ":"
-                 << result.external_port << " (gateway external IP is private — not a usable public address)");
-        if (warn_double_nat) {
-            LOG_WARN("portmap", "Gateway reports a private external IP (" << result.external_ip
-                     << ") — likely double-NAT. Port forwarding alone won't make this host publicly "
-                        "reachable; relying on STUN for the public address.");
-        }
-    } else if (result.success) {
-        LOG_INFO("portmap", to_string(result.transport) << " mapped " << to_string(result.protocol)
-                 << " port " << result.internal_port << " -> external "
-                 << (result.external_ip.empty() ? "?" : result.external_ip) << ":" << result.external_port);
-        // Avoid trying to connect to ourselves through the public address. Only a
-        // genuinely public IP belongs on the ignore list — a private one could be a
-        // real LAN peer we still want to reach.
-        if (!result.external_ip.empty()) {
-            add_ignored_address(result.external_ip);
-        }
-        // A new/changed public TCP port means the address peers should reach us on
-        // changed: re-announce to the DHT so it advertises the mapped port instead
-        // of the (NATed) local listen port. Done outside the lock below.
-    } else {
-        LOG_DEBUG("portmap", to_string(result.transport) << " mapping failed: " << result.error);
-    }
-
-    // Invoke the user callback outside the lock to avoid re-entrancy deadlocks.
-    if (user_cb) {
-        user_cb(result);
-    }
-
-    // Re-announce with the freshly mapped public port (outside any lock).
-    if (tcp_port_changed && is_dht_running()) {
-        announce_rats_peer();
-    }
-}
-
-// ============================================================================
-// Lifecycle
-// ============================================================================
-
-void RatsClient::start_port_mapping() {
-    PortMappingConfig config;
-    int port;
-    {
-        std::lock_guard<std::mutex> lock(port_mapping_mutex_);
-        config = port_mapping_config_;
-        // Already started?
-        if (upnp_client_ || natpmp_client_) {
-            return;
-        }
-        port = listen_port_;
-    }
-
-    if (!config.enabled) {
-        return;
-    }
-    if (port <= 0) {
-        LOG_WARN("portmap", "Skipping port mapping: invalid listen port");
-        return;
-    }
-
-    LOG_INFO("portmap", "Starting automatic port forwarding for TCP port " << port
-             << " (upnp=" << config.enable_upnp << " natpmp=" << config.enable_natpmp << ")");
-
-    auto callback = [this](const PortMapResult& r) { handle_port_mapping_result(r); };
-
-    std::unique_ptr<UpnpClient> upnp;
-    std::unique_ptr<NatPmpClient> natpmp;
-
-    if (config.enable_upnp) {
-        upnp = std::make_unique<UpnpClient>();
-        upnp->set_lease_duration(config.lease_duration_seconds);
-        upnp->set_callback(callback);
-        upnp->add_mapping(PortMapProtocol::TCP, static_cast<uint16_t>(port), 0, "rats");
-    }
-    if (config.enable_natpmp) {
-        natpmp = std::make_unique<NatPmpClient>();
-        natpmp->set_lease_duration(config.lease_duration_seconds);
-        natpmp->set_callback(callback);
-        natpmp->add_mapping(PortMapProtocol::TCP, static_cast<uint16_t>(port));
-    }
-
-    // Publish the clients before starting their workers so add_port_mapping() can
-    // reach them, then kick off discovery.
-    {
-        std::lock_guard<std::mutex> lock(port_mapping_mutex_);
-        upnp_client_ = std::move(upnp);
-        natpmp_client_ = std::move(natpmp);
-    }
-    {
-        std::lock_guard<std::mutex> lock(port_mapping_mutex_);
-        if (upnp_client_)   upnp_client_->start();
-        if (natpmp_client_) natpmp_client_->start();
-    }
-}
-
-void RatsClient::stop_port_mapping() {
-    // Move the clients out under the lock, then stop() them outside it: stop()
-    // joins worker threads which may call handle_port_mapping_result() (and thus
-    // re-acquire port_mapping_mutex_), so holding it here would deadlock.
-    std::unique_ptr<UpnpClient> upnp;
-    std::unique_ptr<NatPmpClient> natpmp;
-    {
-        std::lock_guard<std::mutex> lock(port_mapping_mutex_);
-        upnp = std::move(upnp_client_);
-        natpmp = std::move(natpmp_client_);
-    }
-
-    if (upnp || natpmp) {
-        LOG_INFO("portmap", "Removing port mappings and stopping backends");
-    }
-    if (upnp)   upnp->stop();
-    if (natpmp) natpmp->stop();
-}
-
-// ============================================================================
-// Network change detection
-// ============================================================================
-
-void RatsClient::set_network_change_detection_enabled(bool enabled) {
-    bool was_enabled;
-    {
-        std::lock_guard<std::mutex> lock(network_monitor_mutex_);
-        was_enabled = network_change_detection_enabled_;
-        network_change_detection_enabled_ = enabled;
-    }
-    if (was_enabled == enabled) {
-        return;
-    }
-    LOG_INFO("netmon", "Network change detection " << (enabled ? "enabled" : "disabled"));
-    if (running_.load()) {
-        if (enabled) {
-            start_network_monitor();
-        } else {
-            stop_network_monitor();
-        }
-    }
-}
-
-bool RatsClient::is_network_change_detection_enabled() const {
-    std::lock_guard<std::mutex> lock(network_monitor_mutex_);
-    return network_change_detection_enabled_;
-}
-
-void RatsClient::on_network_changed(NetworkChangeCallback callback) {
-    std::lock_guard<std::mutex> lock(network_monitor_mutex_);
-    network_change_callback_ = std::move(callback);
-}
-
-void RatsClient::start_network_monitor() {
-    {
-        std::lock_guard<std::mutex> lock(network_monitor_mutex_);
-        if (!network_change_detection_enabled_ || network_monitor_) {
-            return;  // disabled or already running
-        }
-    }
-
-    // Spin up the recovery worker before the monitor so it can never miss the
-    // first wake-up.
-    {
-        std::lock_guard<std::mutex> lock(network_recovery_mutex_);
-        network_recovery_stop_ = false;
-        network_recovery_pending_ = false;
-    }
-    network_recovery_thread_ = std::thread([this]() { network_recovery_loop(); });
-
-    auto monitor = std::make_unique<NetworkMonitor>();
-    monitor->start([this](const std::vector<std::string>& addrs) {
-        handle_network_change(addrs);
-    });
-    {
-        std::lock_guard<std::mutex> lock(network_monitor_mutex_);
-        network_monitor_ = std::move(monitor);
-    }
-    LOG_INFO("netmon", "Network change detection active");
-}
-
-void RatsClient::stop_network_monitor() {
-    // Stop the OS watcher first so no further change events are queued.
-    std::unique_ptr<NetworkMonitor> monitor;
-    {
-        std::lock_guard<std::mutex> lock(network_monitor_mutex_);
-        monitor = std::move(network_monitor_);
-    }
-    if (monitor) {
-        monitor->stop();   // joins the monitor's worker thread
-    }
-
-    // Then wake and join the recovery worker. Done after the monitor is down so
-    // no new recovery can be scheduled while we shut it down.
-    {
-        std::lock_guard<std::mutex> lock(network_recovery_mutex_);
-        network_recovery_stop_ = true;
-    }
-    network_recovery_cv_.notify_all();
-    if (network_recovery_thread_.joinable()) {
-        network_recovery_thread_.join();
-    }
-}
-
-void RatsClient::network_recovery_loop() {
-    while (true) {
-        {
-            std::unique_lock<std::mutex> lock(network_recovery_mutex_);
-            network_recovery_cv_.wait(lock, [this]() {
-                return network_recovery_pending_ || network_recovery_stop_;
-            });
-            if (network_recovery_stop_) {
-                break;
-            }
-            network_recovery_pending_ = false;
-        }
-        recover_after_network_change();
-    }
-}
-
-void RatsClient::handle_network_change(const std::vector<std::string>& current_addresses) {
-    if (!running_.load()) {
-        return;
-    }
-    LOG_CLIENT_INFO("Network change detected (" << current_addresses.size()
-                    << " local address(es)); refreshing network state");
-
-    // Cheap and synchronous: refresh the self-address set so a freshly added
-    // local address isn't misjudged as a remote peer, and a removed one stops
-    // being blocked. (Diff-based; preserves STUN/mapped/ignored entries.)
-    initialize_local_addresses();
-
-    // Notify the application.
-    NetworkChangeCallback cb;
-    {
-        std::lock_guard<std::mutex> lock(network_monitor_mutex_);
-        cb = network_change_callback_;
-    }
-    if (cb) {
-        cb(current_addresses);
-    }
-
-    // Hand the slow recovery (port re-mapping + STUN + re-announce) to the
-    // dedicated worker so we don't block the monitor thread. Coalesced: if a
-    // recovery is already running, this just marks another pass is needed.
-    {
-        std::lock_guard<std::mutex> lock(network_recovery_mutex_);
-        network_recovery_pending_ = true;
-    }
-    network_recovery_cv_.notify_all();
-}
-
-void RatsClient::recover_after_network_change() {
-    if (!running_.load()) {
-        return;
-    }
-    LOG_CLIENT_INFO("Recovering after network change: renewing port mappings and re-announcing");
-
-    // 1. Renew router port mappings. Our LAN IP and/or the gateway likely
-    //    changed, so existing UPnP/NAT-PMP leases are stale or aimed at the wrong
-    //    internal address. Tear down and re-run discovery from scratch.
-    if (is_port_mapping_enabled()) {
-        stop_port_mapping();
-        if (running_.load()) {
-            start_port_mapping();
-        }
-    }
-
-    if (!running_.load()) {
-        return;
-    }
-
-    // 2. Re-discover our public address via STUN, update the BEP 42 node IDs and
-    //    re-announce so the DHT advertises our current reachable endpoint rather
-    //    than the one from the previous network. This runs on the recovery
-    //    thread, which stop() joins before the DHT clients are destroyed, so the
-    //    set_external_ip()/announce calls can never touch a freed DhtClient.
-    if (is_dht_running()) {
-        auto mapped = discover_public_address("stun.l.google.com", 19302, 4000);
-        if (mapped) {
-            if (dht_client_)    dht_client_->set_external_ip(mapped->address);
-            if (dht_client_v6_) dht_client_v6_->set_external_ip(mapped->address);
-            LOG_CLIENT_INFO("Public address after network change: " << mapped->address);
-        } else {
-            LOG_CLIENT_DEBUG("STUN public address discovery failed after network change");
-        }
-        if (running_.load()) {
-            announce_rats_peer();
-        }
-    }
-}
-
-} // namespace librats

package/native-src/src/librats_reconnection.cpp

@@ -1,218 +0,0 @@
-#include "librats.h"
-#include "librats_log_macros.h"
-
-namespace librats {
-
-    
-// =========================================================================
-// Automatic Reconnection System
-// =========================================================================
-
-void RatsClient::set_reconnect_enabled(bool enabled) {
-    std::lock_guard<std::mutex> lock(reconnect_mutex_);
-    reconnect_config_.enabled = enabled;
-    LOG_CLIENT_INFO("Automatic reconnection " << (enabled ? "enabled" : "disabled"));
-}
-
-bool RatsClient::is_reconnect_enabled() const {
-    std::lock_guard<std::mutex> lock(reconnect_mutex_);
-    return reconnect_config_.enabled;
-}
-
-void RatsClient::set_reconnect_config(const ReconnectConfig& config) {
-    std::lock_guard<std::mutex> lock(reconnect_mutex_);
-    reconnect_config_ = config;
-    LOG_CLIENT_INFO("Reconnection config updated: max_attempts=" << config.max_attempts 
-                    << ", stable_threshold=" << config.stable_connection_threshold_seconds << "s");
-}
-
-ReconnectConfig RatsClient::get_reconnect_config() const {
-    std::lock_guard<std::mutex> lock(reconnect_mutex_);
-    return reconnect_config_;
-}
-
-size_t RatsClient::get_reconnect_queue_size() const {
-    std::lock_guard<std::mutex> lock(reconnect_mutex_);
-    return reconnect_queue_.size();
-}
-
-void RatsClient::clear_reconnect_queue() {
-    std::lock_guard<std::mutex> lock(reconnect_mutex_);
-    size_t cleared = reconnect_queue_.size();
-    reconnect_queue_.clear();
-    manual_disconnect_peers_.clear();
-    LOG_CLIENT_INFO("Cleared " << cleared << " peers from reconnection queue");
-}
-
-std::vector<ReconnectInfo> RatsClient::get_reconnect_queue() const {
-    std::lock_guard<std::mutex> lock(reconnect_mutex_);
-    std::vector<ReconnectInfo> result;
-    result.reserve(reconnect_queue_.size());
-    for (const auto& pair : reconnect_queue_) {
-        result.push_back(pair.second);
-    }
-    return result;
-}
-
-int RatsClient::get_retry_interval_seconds(int attempt, bool is_stable) const {
-    // For stable peers, use faster first retry
-    if (attempt == 0 && is_stable) {
-        return reconnect_config_.stable_first_retry_seconds;
-    }
-    
-    // Use configured intervals, defaulting to last interval if attempt exceeds array size
-    const auto& intervals = reconnect_config_.retry_intervals_seconds;
-    if (intervals.empty()) {
-        return 30; // Default fallback
-    }
-    
-    size_t index = static_cast<size_t>(attempt);
-    if (index >= intervals.size()) {
-        return intervals.back();
-    }
-    return intervals[index];
-}
-
-void RatsClient::schedule_reconnect(const RatsPeer& peer) {
-    if (!running_.load()) {
-        return;
-    }
-    
-    // Check if reconnection is enabled
-    {
-        std::lock_guard<std::mutex> lock(reconnect_mutex_);
-        if (!reconnect_config_.enabled) {
-            LOG_CLIENT_DEBUG("Reconnection disabled, not scheduling reconnect for " << peer.peer_id);
-            return;
-        }
-        
-        // Check if this peer was manually disconnected
-        if (manual_disconnect_peers_.find(peer.peer_id) != manual_disconnect_peers_.end()) {
-            LOG_CLIENT_DEBUG("Peer " << peer.peer_id << " was manually disconnected, not scheduling reconnect");
-            manual_disconnect_peers_.erase(peer.peer_id);
-            return;
-        }
-        
-        // Check if already in queue
-        if (reconnect_queue_.find(peer.peer_id) != reconnect_queue_.end()) {
-            LOG_CLIENT_DEBUG("Peer " << peer.peer_id << " already in reconnection queue");
-            return;
-        }
-    }
-    
-    // Calculate connection duration
-    auto now = std::chrono::steady_clock::now();
-    auto connection_duration = std::chrono::duration_cast<std::chrono::milliseconds>(now - peer.connected_at);
-    
-    // Determine if this was a stable connection
-    bool is_stable = connection_duration.count() >= 
-        (reconnect_config_.stable_connection_threshold_seconds * 1000);
-    
-    // Create reconnect info
-    ReconnectInfo info(peer.peer_id, peer.ip, peer.port, connection_duration, is_stable);
-    
-    // Calculate first retry interval
-    int first_retry_seconds = get_retry_interval_seconds(0, is_stable);
-    info.next_attempt_time = now + std::chrono::seconds(first_retry_seconds);
-    
-    // Add to queue
-    {
-        std::lock_guard<std::mutex> lock(reconnect_mutex_);
-        reconnect_queue_[peer.peer_id] = info;
-    }
-    
-    LOG_CLIENT_INFO("Scheduled reconnection for peer " << peer.peer_id 
-                    << " (" << peer.ip << ":" << peer.port << ")"
-                    << " - stable=" << is_stable 
-                    << ", connection_duration=" << connection_duration.count() << "ms"
-                    << ", first_retry_in=" << first_retry_seconds << "s");
-}
-
-void RatsClient::remove_from_reconnect_queue(const std::string& peer_id) {
-    std::lock_guard<std::mutex> lock(reconnect_mutex_);
-    auto it = reconnect_queue_.find(peer_id);
-    if (it != reconnect_queue_.end()) {
-        LOG_CLIENT_DEBUG("Removed peer " << peer_id << " from reconnection queue");
-        reconnect_queue_.erase(it);
-    }
-}
-
-void RatsClient::process_reconnect_queue() {
-    if (!running_.load()) {
-        return;
-    }
-    
-    // Get list of peers to attempt reconnection (copy to avoid holding lock during connect)
-    std::vector<ReconnectInfo> peers_to_reconnect;
-    
-    {
-        std::lock_guard<std::mutex> lock(reconnect_mutex_);
-        
-        if (!reconnect_config_.enabled || reconnect_queue_.empty()) {
-            return;
-        }
-        
-        auto now = std::chrono::steady_clock::now();
-        
-        for (auto& pair : reconnect_queue_) {
-            ReconnectInfo& info = pair.second;
-            
-            // Check if it's time for next attempt
-            if (now >= info.next_attempt_time) {
-                peers_to_reconnect.push_back(info);
-            }
-        }
-    }
-    
-    // Process reconnection attempts outside of lock
-    for (const auto& info : peers_to_reconnect) {
-        // Check if we're already connected to this peer
-        std::string normalized_address = normalize_peer_address(info.ip, static_cast<int>(info.port));
-        if (is_already_connected_to_address(normalized_address)) {
-            LOG_CLIENT_INFO("Already reconnected to peer " << info.peer_id << ", removing from queue");
-            remove_from_reconnect_queue(info.peer_id);
-            continue;
-        }
-        
-        // Check if peer limit is reached
-        if (is_peer_limit_reached()) {
-            LOG_CLIENT_DEBUG("Peer limit reached, skipping reconnection attempt for " << info.peer_id);
-            continue;
-        }
-        
-        LOG_CLIENT_INFO("Attempting reconnection to peer " << info.peer_id 
-                        << " (" << info.ip << ":" << info.port << ")"
-                        << " - attempt " << (info.attempt_count + 1) << "/" << reconnect_config_.max_attempts);
-        
-        // Attempt to connect
-        bool connected = connect_to_peer(info.ip, static_cast<int>(info.port));
-        
-        if (connected) {
-            LOG_CLIENT_INFO("Successfully reconnected to peer " << info.peer_id);
-            remove_from_reconnect_queue(info.peer_id);
-        } else {
-            // Update attempt count and schedule next attempt
-            std::lock_guard<std::mutex> lock(reconnect_mutex_);
-            auto it = reconnect_queue_.find(info.peer_id);
-            if (it != reconnect_queue_.end()) {
-                it->second.attempt_count++;
-                
-                // Check if we've exceeded max attempts
-                if (it->second.attempt_count >= reconnect_config_.max_attempts) {
-                    LOG_CLIENT_INFO("Max reconnection attempts reached for peer " << info.peer_id 
-                                    << ", removing from queue");
-                    reconnect_queue_.erase(it);
-                } else {
-                    // Schedule next attempt
-                    int next_interval = get_retry_interval_seconds(it->second.attempt_count, it->second.is_stable);
-                    it->second.next_attempt_time = std::chrono::steady_clock::now() + 
-                        std::chrono::seconds(next_interval);
-                    LOG_CLIENT_DEBUG("Scheduled next reconnection attempt for " << info.peer_id 
-                                     << " in " << next_interval << " seconds");
-                }
-            }
-        }
-    }
-}
-
-}