librats 0.8.0 → 0.9.0

package/native-src/src/librats_file_transfer.cpp

@@ -3,9 +3,9 @@
 
 namespace librats {
 
-//=============================================================================
-// File Transfer API Implementation
-//=============================================================================
+// =============================================================================
+// File transfer API - thin forwarding layer over FileTransferManager
+// =============================================================================
 
 FileTransferManager& RatsClient::get_file_transfer_manager() {
     if (!file_transfer_manager_) {
@@ -18,24 +18,22 @@ bool RatsClient::is_file_transfer_available() const {
     return file_transfer_manager_ != nullptr;
 }
 
-std::string RatsClient::send_file(const std::string& peer_id, const std::string& file_path, 
-                                 const std::string& remote_filename) {
+std::string RatsClient::send_file(const std::string& peer_id, const std::string& file_path,
+                                  const std::string& remote_filename) {
     if (!is_file_transfer_available()) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return "";
     }
-    
     return file_transfer_manager_->send_file(peer_id, file_path, remote_filename);
 }
 
 std::string RatsClient::send_directory(const std::string& peer_id, const std::string& directory_path,
-                                      const std::string& remote_directory_name, bool recursive) {
+                                       const std::string& remote_name) {
     if (!is_file_transfer_available()) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return "";
     }
-    
-    return file_transfer_manager_->send_directory(peer_id, directory_path, remote_directory_name, recursive);
+    return file_transfer_manager_->send_directory(peer_id, directory_path, remote_name);
 }
 
 bool RatsClient::accept_file_transfer(const std::string& transfer_id, const std::string& local_path) {
@@ -43,8 +41,7 @@ bool RatsClient::accept_file_transfer(const std::string& transfer_id, const std:
         LOG_CLIENT_ERROR("File transfer manager not available");
         return false;
     }
-    
-    return file_transfer_manager_->accept_file_transfer(transfer_id, local_path);
+    return file_transfer_manager_->accept(transfer_id, local_path);
 }
 
 bool RatsClient::reject_file_transfer(const std::string& transfer_id, const std::string& reason) {
@@ -52,26 +49,7 @@ bool RatsClient::reject_file_transfer(const std::string& transfer_id, const std:
         LOG_CLIENT_ERROR("File transfer manager not available");
         return false;
     }
-    
-    return file_transfer_manager_->reject_file_transfer(transfer_id, reason);
-}
-
-bool RatsClient::accept_directory_transfer(const std::string& transfer_id, const std::string& local_path) {
-    if (!is_file_transfer_available()) {
-        LOG_CLIENT_ERROR("File transfer manager not available");
-        return false;
-    }
-    
-    return file_transfer_manager_->accept_directory_transfer(transfer_id, local_path);
-}
-
-bool RatsClient::reject_directory_transfer(const std::string& transfer_id, const std::string& reason) {
-    if (!is_file_transfer_available()) {
-        LOG_CLIENT_ERROR("File transfer manager not available");
-        return false;
-    }
-    
-    return file_transfer_manager_->reject_directory_transfer(transfer_id, reason);
+    return file_transfer_manager_->reject(transfer_id, reason);
 }
 
 bool RatsClient::pause_file_transfer(const std::string& transfer_id) {
@@ -79,8 +57,7 @@ bool RatsClient::pause_file_transfer(const std::string& transfer_id) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return false;
     }
-    
-    return file_transfer_manager_->pause_transfer(transfer_id);
+    return file_transfer_manager_->pause(transfer_id);
 }
 
 bool RatsClient::resume_file_transfer(const std::string& transfer_id) {
@@ -88,8 +65,7 @@ bool RatsClient::resume_file_transfer(const std::string& transfer_id) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return false;
     }
-    
-    return file_transfer_manager_->resume_transfer(transfer_id);
+    return file_transfer_manager_->resume(transfer_id);
 }
 
 bool RatsClient::cancel_file_transfer(const std::string& transfer_id) {
@@ -97,25 +73,24 @@ bool RatsClient::cancel_file_transfer(const std::string& transfer_id) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return false;
     }
-    
-    return file_transfer_manager_->cancel_transfer(transfer_id);
+    return file_transfer_manager_->cancel(transfer_id);
 }
 
-std::shared_ptr<FileTransferProgress> RatsClient::get_file_transfer_progress(const std::string& transfer_id) const {
+std::shared_ptr<FileTransferProgress>
+RatsClient::get_file_transfer_progress(const std::string& transfer_id) const {
     if (!is_file_transfer_available()) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return nullptr;
     }
-    
-    return file_transfer_manager_->get_transfer_progress(transfer_id);
+    return file_transfer_manager_->get_progress(transfer_id);
 }
 
-std::vector<std::shared_ptr<FileTransferProgress>> RatsClient::get_active_file_transfers() const {
+std::vector<std::shared_ptr<FileTransferProgress>>
+RatsClient::get_active_file_transfers() const {
     if (!is_file_transfer_available()) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return {};
     }
-    
     return file_transfer_manager_->get_active_transfers();
 }
 
@@ -124,8 +99,7 @@ nlohmann::json RatsClient::get_file_transfer_statistics() const {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return nlohmann::json::object();
     }
-    
-    return file_transfer_manager_->get_transfer_statistics();
+    return file_transfer_manager_->get_statistics();
 }
 
 void RatsClient::set_file_transfer_config(const FileTransferConfig& config) {
@@ -133,7 +107,6 @@ void RatsClient::set_file_transfer_config(const FileTransferConfig& config) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return;
     }
-    
     file_transfer_manager_->set_config(config);
 }
 
@@ -141,82 +114,31 @@ FileTransferConfig RatsClient::get_file_transfer_config() const {
     if (!is_file_transfer_available()) {
         throw std::runtime_error("File transfer manager not available");
     }
-    
     return file_transfer_manager_->get_config();
 }
 
-void RatsClient::on_file_transfer_progress(FileTransferProgressCallback callback) {
-    if (!is_file_transfer_available()) {
-        LOG_CLIENT_ERROR("File transfer manager not available");
-        return;
-    }
-    
-    file_transfer_manager_->set_progress_callback(callback);
-}
-
-void RatsClient::on_file_transfer_completed(FileTransferCompletedCallback callback) {
-    if (!is_file_transfer_available()) {
-        LOG_CLIENT_ERROR("File transfer manager not available");
-        return;
-    }
-    
-    file_transfer_manager_->set_completion_callback(callback);
-}
-
-void RatsClient::on_file_transfer_request(FileTransferRequestCallback callback) {
+void RatsClient::on_file_transfer_progress(TransferProgressCallback callback) {
     if (!is_file_transfer_available()) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return;
     }
-    
-    file_transfer_manager_->set_request_callback(callback);
-}
-
-void RatsClient::on_directory_transfer_progress(DirectoryTransferProgressCallback callback) {
-    if (!is_file_transfer_available()) {
-        LOG_CLIENT_ERROR("File transfer manager not available");
-        return;
-    }
-    
-    file_transfer_manager_->set_directory_progress_callback(callback);
-}
-
-std::string RatsClient::request_file(const std::string& peer_id, const std::string& remote_file_path,
-                                    const std::string& local_path) {
-    if (!is_file_transfer_available()) {
-        LOG_CLIENT_ERROR("File transfer manager not available");
-        return "";
-    }
-    
-    return file_transfer_manager_->request_file(peer_id, remote_file_path, local_path);
-}
-
-std::string RatsClient::request_directory(const std::string& peer_id, const std::string& remote_directory_path,
-                                         const std::string& local_directory_path, bool recursive) {
-    if (!is_file_transfer_available()) {
-        LOG_CLIENT_ERROR("File transfer manager not available");
-        return "";
-    }
-    
-    return file_transfer_manager_->request_directory(peer_id, remote_directory_path, local_directory_path, recursive);
+    file_transfer_manager_->set_progress_callback(std::move(callback));
 }
 
-void RatsClient::on_file_request(FileRequestCallback callback) {
+void RatsClient::on_file_transfer_completed(TransferCompletedCallback callback) {
     if (!is_file_transfer_available()) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return;
     }
-    
-    file_transfer_manager_->set_file_request_callback(callback);
+    file_transfer_manager_->set_completed_callback(std::move(callback));
 }
 
-void RatsClient::on_directory_request(DirectoryRequestCallback callback) {
+void RatsClient::on_file_transfer_request(TransferOfferCallback callback) {
     if (!is_file_transfer_available()) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return;
     }
-    
-    file_transfer_manager_->set_directory_request_callback(callback);
+    file_transfer_manager_->set_offer_callback(std::move(callback));
 }
 
-}
+} // namespace librats

package/native-src/src/librats_ice.cpp

@@ -91,6 +91,10 @@ std::optional<StunMappedAddress> RatsClient::discover_public_address(
     
     if (result.success && result.mapped_address) {
         LOG_INFO("ice", "Discovered public address: " << result.mapped_address->to_string());
+        
+        // Add public IP to our own addresses list to prevent self-connections
+        add_ignored_address(result.mapped_address->address);
+        
         return result.mapped_address;
     }
     

package/native-src/src/librats_statistic.cpp

@@ -24,10 +24,18 @@ nlohmann::json RatsClient::get_connection_statistics() const {
     stats["our_peer_id"] = get_our_peer_id();
     stats["encryption_enabled"] = is_encryption_enabled();
     
-    // DHT statistics
-    if (dht_client_ && dht_client_->is_running()) {
+    // DHT statistics (IPv4 + IPv6 combined)
+    if (is_dht_running()) {
         stats["dht_running"] = true;
         stats["dht_routing_table_size"] = get_dht_routing_table_size();
+        stats["dht_ipv4_running"] = (dht_client_ && dht_client_->is_running());
+        stats["dht_ipv6_running"] = (dht_client_v6_ && dht_client_v6_->is_running());
+        if (dht_client_ && dht_client_->is_running()) {
+            stats["dht_ipv4_routing_table_size"] = dht_client_->get_routing_table_size();
+        }
+        if (dht_client_v6_ && dht_client_v6_->is_running()) {
+            stats["dht_ipv6_routing_table_size"] = dht_client_v6_->get_routing_table_size();
+        }
     } else {
         stats["dht_running"] = false;
     }

package/native-src/src/socket.cpp

@@ -760,13 +760,25 @@ static bool build_udp_dest_addr(const std::string& host, int port, AddressFamily
                                 sockaddr_storage& addr, socklen_t& addr_len) {
     memset(&addr, 0, sizeof(addr));
 
-    // Native IPv6 address
+    // Native IPv6 address, or hostname that must resolve to IPv6 (pure IPv6 socket).
+    // A pure IPv6 socket (V6ONLY) cannot send to IPv4-mapped addresses, so hostnames
+    // are resolved via AAAA records here.
+    std::string ipv6_host;
     if (network_utils::is_valid_ipv6(host)) {
+        ipv6_host = host;
+    } else if (af == AddressFamily::IPv6) {
+        ipv6_host = network_utils::resolve_hostname_v6(host);
+        if (ipv6_host.empty()) {
+            LOG_SOCKET_DEBUG("Failed to resolve hostname to IPv6: " << host);
+            return false;
+        }
+    }
+    if (!ipv6_host.empty()) {
         auto* a6 = reinterpret_cast<sockaddr_in6*>(&addr);
         a6->sin6_family = AF_INET6;
         a6->sin6_port = htons(port);
-        if (inet_pton(AF_INET6, host.c_str(), &a6->sin6_addr) <= 0) {
-            LOG_SOCKET_ERROR("Invalid IPv6 address: " << host);
+        if (inet_pton(AF_INET6, ipv6_host.c_str(), &a6->sin6_addr) <= 0) {
+            LOG_SOCKET_ERROR("Invalid IPv6 address: " << ipv6_host);
             return false;
         }
         addr_len = sizeof(sockaddr_in6);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "librats",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Node.js bindings for librats - A high-performance peer-to-peer networking library",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/scripts/build-librats.js

@@ -136,6 +136,9 @@ try {
         '-DRATS_BUILD_EXAMPLES=OFF',
         '-DRATS_STATIC_LIBRARY=ON',
         '-DRATS_BINDINGS=ON',
+        // The bindings only need the static archive; install/package-config rules
+        // (find_package support) are unnecessary here and pull in cmake/ratsConfig.cmake.in.
+        '-DRATS_INSTALL=OFF',
         '-DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreadedDLL'
     ];
 

package/scripts/prepare-package.js

@@ -108,6 +108,16 @@ copyDir(
     srcFilter
 );
 
+// Copy cmake/ directory (package-config templates referenced by CMakeLists.txt
+// when RATS_INSTALL is enabled, e.g. cmake/ratsConfig.cmake.in)
+if (fs.existsSync(path.join(projectRoot, 'cmake'))) {
+    console.log('  Copying cmake/ directory...');
+    copyDir(
+        path.join(projectRoot, 'cmake'),
+        path.join(nativeSrcDir, 'cmake')
+    );
+}
+
 // Copy 3rdparty/ directory
 if (fs.existsSync(path.join(projectRoot, '3rdparty'))) {
     console.log('  Copying 3rdparty/ directory...');

package/src/librats_node.cpp

@@ -24,6 +24,7 @@ std::unordered_map<rats_client_t, std::shared_ptr<CallbackData>> binary_callback
 std::unordered_map<rats_client_t, std::shared_ptr<CallbackData>> json_callbacks;
 std::unordered_map<rats_client_t, std::shared_ptr<CallbackData>> disconnect_callbacks;
 std::unordered_map<rats_client_t, std::shared_ptr<CallbackData>> file_progress_callbacks;
+std::unordered_map<rats_client_t, std::shared_ptr<CallbackData>> file_request_callbacks;
 
 // C callback wrappers
 void connection_callback_wrapper(void* user_data, const char* peer_id) {
@@ -95,6 +96,23 @@ void file_progress_callback_wrapper(void* user_data, const char* transfer_id, in
     }
 }
 
+// Fires for every incoming transfer offer (file or directory). The app should
+// respond by calling acceptFileTransfer()/rejectFileTransfer(). remote_path is
+// always empty in the push-only model, so only filename is forwarded.
+void file_request_callback_wrapper(void* user_data, const char* peer_id, const char* transfer_id, const char* remote_path, const char* filename) {
+    (void)remote_path;
+    rats_client_t client = static_cast<rats_client_t>(user_data);
+    auto it = file_request_callbacks.find(client);
+    if (it != file_request_callbacks.end() && it->second) {
+        auto callback_data = it->second;
+        callback_data->callback.Call({
+            Napi::String::New(callback_data->env, peer_id),
+            Napi::String::New(callback_data->env, transfer_id),
+            Napi::String::New(callback_data->env, filename)
+        });
+    }
+}
+
 class RatsClient : public Napi::ObjectWrap<RatsClient> {
 public:
     static Napi::Object Init(Napi::Env env, Napi::Object exports) {
@@ -178,8 +196,6 @@ public:
             // File Transfer methods
             InstanceMethod("sendFile", &RatsClient::SendFile),
             InstanceMethod("sendDirectory", &RatsClient::SendDirectory),
-            InstanceMethod("requestFile", &RatsClient::RequestFile),
-            InstanceMethod("requestDirectory", &RatsClient::RequestDirectory),
             InstanceMethod("acceptFileTransfer", &RatsClient::AcceptFileTransfer),
             InstanceMethod("rejectFileTransfer", &RatsClient::RejectFileTransfer),
             InstanceMethod("cancelFileTransfer", &RatsClient::CancelFileTransfer),
@@ -198,6 +214,7 @@ public:
             InstanceMethod("onJson", &RatsClient::OnJson),
             InstanceMethod("onDisconnect", &RatsClient::OnDisconnect),
             InstanceMethod("onFileProgress", &RatsClient::OnFileProgress),
+            InstanceMethod("onFileRequest", &RatsClient::OnFileRequest),
             
             // Configuration persistence
             InstanceMethod("loadConfiguration", &RatsClient::LoadConfiguration),
@@ -240,7 +257,8 @@ public:
             json_callbacks.erase(client_);
             disconnect_callbacks.erase(client_);
             file_progress_callbacks.erase(client_);
-            
+            file_request_callbacks.erase(client_);
+
             rats_destroy(client_);
         }
     }
@@ -542,9 +560,10 @@ private:
     Napi::Value StartMdnsDiscovery(const Napi::CallbackInfo& info) {
         Napi::Env env = info.Env();
         
+        std::string service;
         const char* service_name = nullptr;
         if (info.Length() > 0 && info[0].IsString()) {
-            std::string service = info[0].As<Napi::String>().Utf8Value();
+            service = info[0].As<Napi::String>().Utf8Value();
             service_name = service.c_str();
         }
         
@@ -750,12 +769,13 @@ private:
     Napi::Value DiscoverPublicAddress(const Napi::CallbackInfo& info) {
         Napi::Env env = info.Env();
         
+        std::string server_str;
         const char* server = nullptr;
         uint16_t port = 0;
         int timeout_ms = 5000;
-        
+
         if (info.Length() > 0 && info[0].IsString()) {
-            std::string server_str = info[0].As<Napi::String>().Utf8Value();
+            server_str = info[0].As<Napi::String>().Utf8Value();
             server = server_str.c_str();
         }
         if (info.Length() > 1 && info[1].IsNumber()) {
@@ -976,12 +996,13 @@ private:
         std::string peer_id = info[0].As<Napi::String>().Utf8Value();
         std::string file_path = info[1].As<Napi::String>().Utf8Value();
         
+        std::string remote_name;
         const char* remote_filename = nullptr;
         if (info.Length() > 2 && info[2].IsString()) {
-            std::string remote_name = info[2].As<Napi::String>().Utf8Value();
+            remote_name = info[2].As<Napi::String>().Utf8Value();
             remote_filename = remote_name.c_str();
         }
-        
+
         char* transfer_id = rats_send_file(client_, peer_id.c_str(), file_path.c_str(), remote_filename);
         if (!transfer_id) return env.Null();
         
@@ -1001,63 +1022,15 @@ private:
         std::string peer_id = info[0].As<Napi::String>().Utf8Value();
         std::string directory_path = info[1].As<Napi::String>().Utf8Value();
         
+        std::string remote_name;
         const char* remote_directory_name = nullptr;
         if (info.Length() > 2 && info[2].IsString()) {
-            std::string remote_name = info[2].As<Napi::String>().Utf8Value();
+            remote_name = info[2].As<Napi::String>().Utf8Value();
             remote_directory_name = remote_name.c_str();
         }
-        
-        int recursive = 1;
-        if (info.Length() > 3 && info[3].IsBoolean()) {
-            recursive = info[3].As<Napi::Boolean>().Value() ? 1 : 0;
-        }
-        
-        char* transfer_id = rats_send_directory(client_, peer_id.c_str(), directory_path.c_str(), remote_directory_name, recursive);
-        if (!transfer_id) return env.Null();
-        
-        Napi::String result = Napi::String::New(env, transfer_id);
-        rats_string_free(transfer_id);
-        return result;
-    }
-    
-    Napi::Value RequestFile(const Napi::CallbackInfo& info) {
-        Napi::Env env = info.Env();
-        
-        if (info.Length() < 3 || !info[0].IsString() || !info[1].IsString() || !info[2].IsString()) {
-            Napi::TypeError::New(env, "Expected peer_id (string), remote_file_path (string), and local_path (string)").ThrowAsJavaScriptException();
-            return env.Null();
-        }
-        
-        std::string peer_id = info[0].As<Napi::String>().Utf8Value();
-        std::string remote_file_path = info[1].As<Napi::String>().Utf8Value();
-        std::string local_path = info[2].As<Napi::String>().Utf8Value();
-        
-        char* transfer_id = rats_request_file(client_, peer_id.c_str(), remote_file_path.c_str(), local_path.c_str());
-        if (!transfer_id) return env.Null();
-        
-        Napi::String result = Napi::String::New(env, transfer_id);
-        rats_string_free(transfer_id);
-        return result;
-    }
-    
-    Napi::Value RequestDirectory(const Napi::CallbackInfo& info) {
-        Napi::Env env = info.Env();
-        
-        if (info.Length() < 3 || !info[0].IsString() || !info[1].IsString() || !info[2].IsString()) {
-            Napi::TypeError::New(env, "Expected peer_id (string), remote_directory_path (string), and local_directory_path (string)").ThrowAsJavaScriptException();
-            return env.Null();
-        }
-        
-        std::string peer_id = info[0].As<Napi::String>().Utf8Value();
-        std::string remote_directory_path = info[1].As<Napi::String>().Utf8Value();
-        std::string local_directory_path = info[2].As<Napi::String>().Utf8Value();
-        
-        int recursive = 1;
-        if (info.Length() > 3 && info[3].IsBoolean()) {
-            recursive = info[3].As<Napi::Boolean>().Value() ? 1 : 0;
-        }
-        
-        char* transfer_id = rats_request_directory(client_, peer_id.c_str(), remote_directory_path.c_str(), local_directory_path.c_str(), recursive);
+
+        // Directory transfers are always recursive; the trailing flag is ignored.
+        char* transfer_id = rats_send_directory(client_, peer_id.c_str(), directory_path.c_str(), remote_directory_name, 1);
         if (!transfer_id) return env.Null();
         
         Napi::String result = Napi::String::New(env, transfer_id);
@@ -1090,12 +1063,13 @@ private:
         
         std::string transfer_id = info[0].As<Napi::String>().Utf8Value();
         
+        std::string reason_str;
         const char* reason = nullptr;
         if (info.Length() > 1 && info[1].IsString()) {
-            std::string reason_str = info[1].As<Napi::String>().Utf8Value();
+            reason_str = info[1].As<Napi::String>().Utf8Value();
             reason = reason_str.c_str();
         }
-        
+
         rats_error_t result = rats_reject_file_transfer(client_, transfer_id.c_str(), reason);
         return Napi::Boolean::New(env, result == RATS_SUCCESS);
     }
@@ -1271,7 +1245,22 @@ private:
         file_progress_callbacks[client_] = callback_data;
         rats_set_file_progress_callback(client_, file_progress_callback_wrapper, client_);
     }
-    
+
+    void OnFileRequest(const Napi::CallbackInfo& info) {
+        Napi::Env env = info.Env();
+
+        if (info.Length() < 1 || !info[0].IsFunction()) {
+            Napi::TypeError::New(env, "Expected callback function").ThrowAsJavaScriptException();
+            return;
+        }
+
+        auto callback_data = std::make_shared<CallbackData>(env);
+        callback_data->callback = Napi::Persistent(info[0].As<Napi::Function>());
+
+        file_request_callbacks[client_] = callback_data;
+        rats_set_file_request_callback(client_, file_request_callback_wrapper, client_);
+    }
+
     // Configuration persistence
     Napi::Value LoadConfiguration(const Napi::CallbackInfo& info) {
         Napi::Env env = info.Env();