librats 0.7.2 → 0.9.0

package/native-src/src/librats_c.cpp

@@ -679,42 +679,36 @@ char* rats_send_directory(rats_client_t handle, const char* peer_id, const char*
     rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
     
     std::string remote_name = remote_directory_name ? std::string(remote_directory_name) : std::string("");
-    std::string transfer_id = wrap->client->send_directory(std::string(peer_id), std::string(directory_path), remote_name, recursive != 0);
-    
+    (void)recursive; // directory transfers are always recursive
+    std::string transfer_id = wrap->client->send_directory(std::string(peer_id), std::string(directory_path), remote_name);
+
     return transfer_id.empty() ? nullptr : rats_strdup_owned(transfer_id);
 }
 
+// Pull-style requests are not supported in this version; transfers are push-only.
 char* rats_request_file(rats_client_t handle, const char* peer_id, const char* remote_file_path, const char* local_path) {
-    if (!handle || !peer_id || !remote_file_path || !local_path) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    std::string transfer_id = wrap->client->request_file(std::string(peer_id), std::string(remote_file_path), std::string(local_path));
-    
-    return transfer_id.empty() ? nullptr : rats_strdup_owned(transfer_id);
+    (void)handle; (void)peer_id; (void)remote_file_path; (void)local_path;
+    return nullptr;
 }
 
 char* rats_request_directory(rats_client_t handle, const char* peer_id, const char* remote_directory_path, const char* local_directory_path, int recursive) {
-    if (!handle || !peer_id || !remote_directory_path || !local_directory_path) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    std::string transfer_id = wrap->client->request_directory(std::string(peer_id), std::string(remote_directory_path), std::string(local_directory_path), recursive != 0);
-    
-    return transfer_id.empty() ? nullptr : rats_strdup_owned(transfer_id);
+    (void)handle; (void)peer_id; (void)remote_directory_path; (void)local_directory_path; (void)recursive;
+    return nullptr;
 }
 
 rats_error_t rats_accept_directory_transfer(rats_client_t handle, const char* transfer_id, const char* local_path) {
     if (!handle || !transfer_id || !local_path) return RATS_ERROR_INVALID_PARAMETER;
     rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    return wrap->client->accept_directory_transfer(std::string(transfer_id), std::string(local_path)) ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
+
+    return wrap->client->accept_file_transfer(std::string(transfer_id), std::string(local_path)) ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
 }
 
 rats_error_t rats_reject_directory_transfer(rats_client_t handle, const char* transfer_id, const char* reason) {
     if (!handle || !transfer_id) return RATS_ERROR_INVALID_PARAMETER;
     rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
+
     std::string reject_reason = reason ? std::string(reason) : std::string("");
-    return wrap->client->reject_directory_transfer(std::string(transfer_id), reject_reason) ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
+    return wrap->client->reject_file_transfer(std::string(transfer_id), reject_reason) ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
 }
 
 rats_error_t rats_pause_file_transfer(rats_client_t handle, const char* transfer_id) {
@@ -768,44 +762,33 @@ void rats_set_file_request_callback(rats_client_t handle, rats_file_request_cb c
     wrap->file_request_ud = user_data;
     
     if (cb) {
-        wrap->client->on_file_request([wrap](const std::string& peer_id, const std::string& file_path, const std::string& transfer_id) {
+        // Fires for every incoming offer (file or directory). The C app should
+        // then call rats_accept_file_transfer()/rats_reject_file_transfer().
+        wrap->client->on_file_transfer_request([wrap](const IncomingTransferOffer& offer) {
             if (wrap->file_request_cb) {
-                wrap->file_request_cb(wrap->file_request_ud, peer_id.c_str(), transfer_id.c_str(), file_path.c_str(), "");
+                wrap->file_request_cb(wrap->file_request_ud, offer.peer_id.c_str(),
+                                      offer.transfer_id.c_str(), "", offer.name.c_str());
             }
-            return true; // Accept the file request
         });
     }
 }
 
+// Directory offers arrive through the unified file-request callback above;
+// this setter is kept for ABI compatibility and simply records the callback.
 void rats_set_directory_request_callback(rats_client_t handle, rats_directory_request_cb cb, void* user_data) {
     if (!handle) return;
     rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
     wrap->directory_request_cb = cb;
     wrap->directory_request_ud = user_data;
-    
-    if (cb) {
-        wrap->client->on_directory_request([wrap](const std::string& peer_id, const std::string& directory_path, bool recursive, const std::string& transfer_id) {
-            if (wrap->directory_request_cb) {
-                wrap->directory_request_cb(wrap->directory_request_ud, peer_id.c_str(), transfer_id.c_str(), directory_path.c_str(), "");
-            }
-            return true; // Accept the directory request
-        });
-    }
 }
 
+// Directory progress arrives through the unified file-progress callback above;
+// this setter is kept for ABI compatibility and simply records the callback.
 void rats_set_directory_progress_callback(rats_client_t handle, rats_directory_progress_cb cb, void* user_data) {
     if (!handle) return;
     rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
     wrap->directory_progress_cb = cb;
     wrap->directory_progress_ud = user_data;
-    
-    if (cb) {
-        wrap->client->on_directory_transfer_progress([wrap](const std::string& transfer_id, const std::string& current_file, uint64_t files_completed, uint64_t total_files, uint64_t bytes_completed, uint64_t total_bytes) {
-            if (wrap->directory_progress_cb) {
-                wrap->directory_progress_cb(wrap->directory_progress_ud, transfer_id.c_str(), static_cast<int>(files_completed), static_cast<int>(total_files), current_file.c_str());
-            }
-        });
-    }
 }
 
 // Peer information
@@ -847,7 +830,7 @@ char* rats_get_peer_info_json(rats_client_t handle, const char* peer_id) {
     if (!handle || !peer_id) return nullptr;
     rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
     
-    const RatsPeer* peer = wrap->client->get_peer_by_id(std::string(peer_id));
+    auto peer = wrap->client->get_peer_by_id(std::string(peer_id));
     if (!peer) return nullptr;
     
     // Create JSON representation of peer info

package/native-src/src/librats_discovery.cpp

@@ -0,0 +1,377 @@
+#include "librats.h"
+#include "librats_log_macros.h"
+#include "sha1.h"
+
+namespace librats {
+
+// =========================================================================
+// Peer Discovery Methods
+// =========================================================================
+
+bool RatsClient::start_dht_discovery(int dht_port) {
+    if (dht_client_ && dht_client_->is_running()) {
+        LOG_CLIENT_WARN("DHT discovery is already running");
+        return true;
+    }
+
+    LOG_CLIENT_INFO("Starting DHT discovery on port " << dht_port <<
+                   (bind_address_.empty() ? "" : " bound to " + bind_address_));
+
+    auto bootstrap_nodes = DhtClient::get_default_bootstrap_nodes();
+
+    // IPv4 DHT (also shared with the BitTorrent subsystem) - required.
+    dht_client_ = std::make_unique<DhtClient>(dht_port, bind_address_, data_directory_, AddressFamily::IPv4);
+    if (!dht_client_->start()) {
+        LOG_CLIENT_ERROR("Failed to start IPv4 DHT client");
+        dht_client_.reset();
+        return false;
+    }
+    if (!dht_client_->bootstrap(bootstrap_nodes)) {
+        LOG_CLIENT_WARN("Failed to bootstrap IPv4 DHT");
+    }
+
+    // IPv6 DHT - best effort. Shares the same port via a V6ONLY socket. If the host has
+    // no usable IPv6 stack, socket creation fails and we simply run IPv4-only.
+    dht_client_v6_ = std::make_unique<DhtClient>(dht_port, bind_address_, data_directory_, AddressFamily::IPv6);
+    if (dht_client_v6_->start()) {
+        if (!dht_client_v6_->bootstrap(bootstrap_nodes)) {
+            LOG_CLIENT_WARN("Failed to bootstrap IPv6 DHT");
+        }
+        LOG_CLIENT_INFO("IPv6 DHT client started");
+    } else {
+        LOG_CLIENT_INFO("IPv6 DHT unavailable on this host, running IPv4-only");
+        dht_client_v6_.reset();
+    }
+
+    // Start automatic peer discovery (this thread also performs the best-effort STUN probe
+    // that derives our BEP 42 node ID — see automatic_discovery_loop).
+    start_automatic_peer_discovery();
+
+    LOG_CLIENT_INFO("DHT discovery started successfully");
+    return true;
+}
+
+void RatsClient::stop_dht_discovery() {
+    if (!dht_client_ && !dht_client_v6_) {
+        return;
+    }
+
+    LOG_CLIENT_INFO("Stopping DHT discovery");
+
+    // Stop automatic peer discovery
+    stop_automatic_peer_discovery();
+
+    if (dht_client_) {
+        dht_client_->stop();
+        dht_client_.reset();
+    }
+    if (dht_client_v6_) {
+        dht_client_v6_->stop();
+        dht_client_v6_.reset();
+    }
+    LOG_CLIENT_INFO("DHT discovery stopped");
+}
+
+bool RatsClient::find_peers_by_hash(const std::string& content_hash, std::function<void(const std::vector<std::string>&)> callback) {
+    if (!is_dht_running()) {
+        LOG_CLIENT_ERROR("DHT client not running");
+        return false;
+    }
+
+    if (content_hash.length() != CONTENT_HASH_HEX_LENGTH) {
+        LOG_CLIENT_ERROR("Invalid content hash length: " << content_hash.length() << " (expected " << CONTENT_HASH_HEX_LENGTH << ")");
+        return false;
+    }
+
+    LOG_CLIENT_INFO("Finding peers for content hash: " << content_hash);
+
+    InfoHash info_hash = hex_to_node_id(content_hash);
+
+    // Shared wrapper: discovered peers (IPv4 or IPv6) are delivered through the same callback.
+    PeerDiscoveryCallback peer_callback = [callback](const std::vector<Peer>& peers, const InfoHash&) {
+        std::vector<std::string> peer_addresses;
+        peer_addresses.reserve(peers.size());
+        for (const auto& peer : peers) {
+            peer_addresses.emplace_back(peer.ip + ":" + std::to_string(peer.port));
+        }
+        if (callback) {
+            callback(peer_addresses);
+        }
+    };
+
+    // Fan out to both Kademlia networks; succeed if at least one accepts the search.
+    bool started = false;
+    if (dht_client_ && dht_client_->is_running()) {
+        started |= dht_client_->find_peers(info_hash, peer_callback);
+    }
+    if (dht_client_v6_ && dht_client_v6_->is_running()) {
+        started |= dht_client_v6_->find_peers(info_hash, peer_callback);
+    }
+    return started;
+}
+
+bool RatsClient::announce_for_hash(const std::string& content_hash, uint16_t port,
+                                   std::function<void(const std::vector<std::string>&)> callback) {
+    if (!is_dht_running()) {
+        LOG_CLIENT_ERROR("DHT client not running");
+        return false;
+    }
+
+    if (content_hash.length() != CONTENT_HASH_HEX_LENGTH) {
+        LOG_CLIENT_ERROR("Invalid content hash length: " << content_hash.length() << " (expected " << CONTENT_HASH_HEX_LENGTH << ")");
+        return false;
+    }
+
+    if (port == 0) {
+        port = listen_port_;
+    }
+
+    LOG_CLIENT_INFO("Announcing for content hash: " << content_hash << " on port " << port
+                   << (callback ? " with peer callback" : ""));
+
+    InfoHash info_hash = hex_to_node_id(content_hash);
+
+    // Create wrapper callback that converts Peer to string addresses (if callback provided)
+    PeerDiscoveryCallback peer_callback = nullptr;
+    if (callback) {
+        peer_callback = [callback](const std::vector<Peer>& peers, const InfoHash& hash) {
+            std::vector<std::string> peer_addresses;
+            peer_addresses.reserve(peers.size());
+            for (const auto& peer : peers) {
+                peer_addresses.push_back(peer.ip + ":" + std::to_string(peer.port));
+            }
+            callback(peer_addresses);
+        };
+    }
+
+    // Announce on both Kademlia networks so IPv4 and IPv6 peers can both find us.
+    bool started = false;
+    if (dht_client_ && dht_client_->is_running()) {
+        started |= dht_client_->announce_peer(info_hash, port, peer_callback);
+    }
+    if (dht_client_v6_ && dht_client_v6_->is_running()) {
+        started |= dht_client_v6_->announce_peer(info_hash, port, peer_callback);
+    }
+    return started;
+}
+
+bool RatsClient::is_dht_running() const {
+    return (dht_client_ && dht_client_->is_running()) ||
+           (dht_client_v6_ && dht_client_v6_->is_running());
+}
+
+size_t RatsClient::get_dht_routing_table_size() const {
+    size_t total = 0;
+    if (dht_client_) {
+        total += dht_client_->get_routing_table_size();
+    }
+    if (dht_client_v6_) {
+        total += dht_client_v6_->get_routing_table_size();
+    }
+    return total;
+}
+
+void RatsClient::handle_dht_peer_discovery(const std::vector<Peer>& peers, const InfoHash& info_hash) {
+    LOG_CLIENT_INFO("DHT discovered " << peers.size() << " peers for info hash: " << node_id_to_hex(info_hash));
+    
+    // Auto-connect to discovered peers
+    for (const auto& peer : peers) {
+        if (!can_connect_to_peer(peer.ip, peer.port)) {
+            continue;
+        }
+        
+        LOG_CLIENT_DEBUG("Attempting to connect to discovered peer: " << peer.ip << ":" << peer.port);
+        
+        // Try to connect to the peer (non-blocking, managed thread for graceful shutdown)
+        add_managed_thread(std::thread([this, peer]() {
+            if (connect_to_peer(peer.ip, peer.port)) {
+                LOG_CLIENT_INFO("Successfully connected to DHT discovered peer: " << peer.ip << ":" << peer.port);
+            } else {
+                LOG_CLIENT_DEBUG("Failed to connect to DHT discovered peer: " << peer.ip << ":" << peer.port);
+            }
+        }), "dht-connect-" + peer.ip);
+    }
+}
+
+void RatsClient::start_automatic_peer_discovery() {
+    if (auto_discovery_running_.load()) {
+        LOG_CLIENT_WARN("Automatic peer discovery is already running");
+        return;
+    }
+    
+    LOG_CLIENT_INFO("Starting automatic rats peer discovery");
+    auto_discovery_running_.store(true);
+    auto_discovery_thread_ = std::thread(&RatsClient::automatic_discovery_loop, this);
+}
+
+void RatsClient::stop_automatic_peer_discovery() {
+    if (!auto_discovery_running_.load()) {
+        return;
+    }
+    
+    LOG_CLIENT_INFO("Stopping automatic peer discovery");
+    auto_discovery_running_.store(false);
+    
+    if (auto_discovery_thread_.joinable()) {
+        auto_discovery_thread_.join();
+    }
+    
+    LOG_CLIENT_INFO("Automatic peer discovery stopped");
+}
+
+bool RatsClient::is_automatic_discovery_running() const {
+    return auto_discovery_running_.load();
+}
+
+std::chrono::seconds RatsClient::calculate_discovery_interval() const {
+    int peer_count = get_peer_count();
+    
+    // No peers - aggressive discovery
+    if (peer_count == 0) {
+        return std::chrono::seconds(15);
+    }
+    
+    // Calculate fill ratio
+    float fill_ratio = static_cast<float>(peer_count) / static_cast<float>(max_peers_);
+    
+    // Graduated intervals based on fill ratio
+    if (fill_ratio < 0.25f) {
+        // Less than 25% full - still fairly aggressive
+        return std::chrono::seconds(60);       // 1 minute
+    } else if (fill_ratio < 0.50f) {
+        // 25-50% full - moderate
+        return std::chrono::seconds(180);      // 3 minutes
+    } else if (fill_ratio < 0.75f) {
+        // 50-75% full - relaxed
+        return std::chrono::seconds(600);      // 10 minutes
+    } else {
+        // 75-100% full - very relaxed (mostly just re-announcing)
+        return std::chrono::seconds(1800);     // 30 minutes
+    }
+}
+
+void RatsClient::automatic_discovery_loop() {
+    LOG_CLIENT_INFO("Automatic peer discovery loop started");
+    
+    // Initial delay to let DHT bootstrap
+    {
+        std::unique_lock<std::mutex> lock(shutdown_mutex_);
+        if (shutdown_cv_.wait_for(lock, std::chrono::seconds(INITIAL_DISCOVERY_DELAY_SECONDS), [this] { return !auto_discovery_running_.load() || !running_.load(); })) {
+            LOG_CLIENT_INFO("Automatic peer discovery loop stopped during initial delay");
+            return;
+        }
+    }
+
+    // Best-effort: discover our public IP via STUN and derive a BEP 42 node ID from it before
+    // we announce, so we announce under the correct ID. This runs on the discovery thread (not
+    // a standalone one) on purpose: stop_dht_discovery() joins this thread via
+    // stop_automatic_peer_discovery() BEFORE resetting the DHT clients, so set_external_ip()
+    // can never touch a destroyed DhtClient. It complements the in-DHT "ip"-field voting, which
+    // keeps the node ID correct if the address changes or STUN is unavailable.
+    if (auto_discovery_running_.load() && running_.load()) {
+        auto mapped = discover_public_address("stun.l.google.com", 19302, 4000);
+        if (mapped) {
+            // set_external_ip validates the address family, so feeding both instances is safe:
+            // only the matching-family DHT adopts it. (A default IPv4 STUN server yields an IPv4
+            // address; the IPv6 node ID is learned organically from IPv6 DHT responses.)
+            if (dht_client_) {
+                dht_client_->set_external_ip(mapped->address);
+            }
+            if (dht_client_v6_) {
+                dht_client_v6_->set_external_ip(mapped->address);
+            }
+        }
+    }
+
+    // Announce immediately - this also discovers peers during traversal
+    announce_rats_peer();
+
+    auto last_announce = std::chrono::steady_clock::now();
+    
+    while (auto_discovery_running_.load()) {
+        auto now = std::chrono::steady_clock::now();
+        
+        // Announce combines both announcing our presence and discovering peers
+        // Interval scales based on peer count: aggressive when empty, relaxed when nearly full
+        auto interval = calculate_discovery_interval();
+        
+        if (now - last_announce >= interval) {
+            LOG_CLIENT_DEBUG("Discovery interval: " << interval.count() << "s (peers: " 
+                            << get_peer_count() << "/" << max_peers_ << ")");
+            announce_rats_peer();
+            last_announce = now;
+        }
+        
+        // Use conditional variable for responsive shutdown
+        {
+            std::unique_lock<std::mutex> lock(shutdown_mutex_);
+            if (shutdown_cv_.wait_for(lock, std::chrono::milliseconds(500), [this] { return !auto_discovery_running_.load() || !running_.load(); })) {
+                break;
+            }
+        }
+    }
+    
+    LOG_CLIENT_INFO("Automatic peer discovery loop stopped");
+}
+
+void RatsClient::announce_rats_peer() {
+    if (!dht_client_ || !dht_client_->is_running()) {
+        LOG_CLIENT_WARN("DHT client not running, cannot announce peer");
+        return;
+    }
+    
+    std::string discovery_hash = get_discovery_hash();
+    LOG_CLIENT_INFO("Announcing peer for discovery hash: " << discovery_hash << " on port " << listen_port_);
+    
+    InfoHash info_hash = hex_to_node_id(discovery_hash);
+
+    // Skip only if every running DHT network already has this announce in flight.
+    // (announce_peer() also dedups internally, so this is just to avoid redundant work.)
+    bool v4_busy = !dht_client_ || !dht_client_->is_running() || dht_client_->is_announce_active(info_hash);
+    bool v6_busy = !dht_client_v6_ || !dht_client_v6_->is_running() || dht_client_v6_->is_announce_active(info_hash);
+    if (v4_busy && v6_busy) {
+        LOG_CLIENT_WARN("Announce already in progress for info hash: " << node_id_to_hex(info_hash));
+        return;
+    }
+    
+    // Use announce with callback - combines announce and find_peers in one traversal
+    // Peers discovered during traversal will be returned through the callback
+    if (announce_for_hash(discovery_hash, listen_port_, [this, info_hash](const std::vector<std::string>& peer_addresses) {
+        LOG_CLIENT_INFO("Announce discovered " << peer_addresses.size() << " peers during traversal");
+        
+        // Convert peer addresses to Peer objects for handle_dht_peer_discovery()
+        std::vector<Peer> peers;
+        peers.reserve(peer_addresses.size());
+        for (const auto& peer_address : peer_addresses) {
+            std::string ip;
+            int port;
+            if (parse_address_string(peer_address, ip, port)) {
+                peers.push_back(Peer(ip, port));
+            }
+        }
+        
+        // Auto-connect to discovered peers
+        if (!peers.empty()) {
+            handle_dht_peer_discovery(peers, info_hash);
+        }
+    })) {
+        LOG_CLIENT_DEBUG("Successfully started announce with peer discovery for discovery hash");
+    } else {
+        LOG_CLIENT_WARN("Failed to announce peer for discovery");
+    }
+}
+
+std::string RatsClient::get_discovery_hash() const {
+    std::lock_guard<std::mutex> lock(protocol_config_mutex_);
+    // Generate discovery hash based on current protocol configuration
+    std::string discovery_string = custom_protocol_name_ + "_peer_discovery_v" + custom_protocol_version_;
+    return SHA1::hash(discovery_string);
+}
+
+std::string RatsClient::get_rats_peer_discovery_hash() {
+    // Well-known hash for rats peer discovery
+    // Compute SHA1 hash of "rats_peer_discovery_v1.0"
+    return SHA1::hash("rats_peer_discovery_v1.0");
+}
+
+}