librats 0.7.0 → 0.7.2

package/native-src/src/socket.h

@@ -27,6 +27,15 @@
 
 namespace librats {
 
+/**
+ * Address family for socket creation
+ */
+enum class AddressFamily {
+    IPv4,       // IPv4 only
+    IPv6,       // IPv6 only
+    DualStack   // IPv6 socket with IPv4 support (default)
+};
+
 /**
  * UDP peer information
  */
@@ -69,49 +78,15 @@ void cleanup_socket_library();
 socket_t create_tcp_client(const std::string& host, int port, int timeout_ms = 0);
 
 /**
- * Create a TCP client socket and connect to a server using IPv4 only
- * @param host The hostname or IP address to connect to
- * @param port The port number to connect to
- * @param timeout_ms Connection timeout in milliseconds (0 for blocking)
- * @return Socket handle, or INVALID_SOCKET_VALUE on error
- */
-socket_t create_tcp_client_v4(const std::string& host, int port, int timeout_ms = 0);
-
-/**
- * Create a TCP client socket and connect to a server using IPv6 only
- * @param host The hostname or IPv6 address to connect to
- * @param port The port number to connect to
- * @param timeout_ms Connection timeout in milliseconds (0 for blocking)
- * @return Socket handle, or INVALID_SOCKET_VALUE on error
- */
-socket_t create_tcp_client_v6(const std::string& host, int port, int timeout_ms = 0);
-
-/**
- * Create a TCP server socket and bind to a port using dual stack (IPv6 with IPv4 support)
+ * Create a TCP server socket and bind to a port
  * @param port The port number to bind to
  * @param backlog The maximum number of pending connections
  * @param bind_address The interface IP address to bind to (empty for all interfaces)
+ * @param af Address family (DualStack by default)
  * @return Socket handle, or INVALID_SOCKET_VALUE on error
  */
-socket_t create_tcp_server(int port, int backlog = 5, const std::string& bind_address = "");
-
-/**
- * Create a TCP server socket and bind to a port using IPv4 only
- * @param port The port number to bind to
- * @param backlog The maximum number of pending connections
- * @param bind_address The interface IP address to bind to (empty for all interfaces)
- * @return Socket handle, or INVALID_SOCKET_VALUE on error
- */
-socket_t create_tcp_server_v4(int port, int backlog = 5, const std::string& bind_address = "");
-
-/**
- * Create a TCP server socket and bind to a port using IPv6 only
- * @param port The port number to bind to
- * @param backlog The maximum number of pending connections
- * @param bind_address The interface IP address to bind to (empty for all interfaces)
- * @return Socket handle, or INVALID_SOCKET_VALUE on error
- */
-socket_t create_tcp_server_v6(int port, int backlog = 5, const std::string& bind_address = "");
+socket_t create_tcp_server(int port, int backlog = 5, const std::string& bind_address = "",
+                           AddressFamily af = AddressFamily::DualStack);
 
 /**
  * Accept a client connection on a server socket
@@ -144,29 +119,20 @@ int send_tcp_data(socket_t socket, const std::vector<uint8_t>& data);
 std::vector<uint8_t> receive_tcp_data(socket_t socket, size_t buffer_size = 1024);
 
 /**
- * Send a framed message with length prefix through a TCP socket
+ * Send a length-prefixed framed message through a TCP socket
  * @param socket The socket handle
  * @param message The binary message to send
  * @return Total bytes sent (including length prefix), or -1 on error
  */
-int send_tcp_message_framed(socket_t socket, const std::vector<uint8_t>& message);
-
-/**
- * Receive exact number of bytes from a TCP socket (blocking until complete)
- * @param socket The socket handle
- * @param num_bytes Number of bytes to receive
- * @return Received binary data, empty vector on error or connection close
- */
-std::vector<uint8_t> receive_exact_bytes(socket_t socket, size_t num_bytes);
+int send_tcp_message(socket_t socket, const std::vector<uint8_t>& message);
 
 /**
- * Receive a complete framed message from a TCP socket
+ * Receive a complete length-prefixed framed message from a TCP socket
  * @param socket The socket handle
  * @return Complete binary message, empty vector on error or connection close
  */
-std::vector<uint8_t> receive_tcp_message_framed(socket_t socket);
+std::vector<uint8_t> receive_tcp_message(socket_t socket);
 
-// Convenience functions for string compatibility
 /**
  * Send string data through a TCP socket (converts to binary)
  * @param socket The socket handle
@@ -175,98 +141,45 @@ std::vector<uint8_t> receive_tcp_message_framed(socket_t socket);
  */
 int send_tcp_string(socket_t socket, const std::string& data);
 
-/**
- * Receive data from a TCP socket as string
- * @param socket The socket handle
- * @param buffer_size Maximum number of bytes to receive
- * @return Received data as string, empty string on error
- */
-std::string receive_tcp_string(socket_t socket, size_t buffer_size = 1024);
-
-/**
- * Send a framed string message through a TCP socket
- * @param socket The socket handle
- * @param message The string message to send
- * @return Total bytes sent (including length prefix), or -1 on error
- */
-int send_tcp_string_framed(socket_t socket, const std::string& message);
-
-/**
- * Receive a complete framed string message from a TCP socket
- * @param socket The socket handle
- * @return Complete message as string, empty string on error or connection close
- */
-std::string receive_tcp_string_framed(socket_t socket);
-
 // UDP Socket Functions
 /**
- * Create a UDP socket with dual stack support (IPv6 with IPv4 support)
- * @param port The port to bind to (0 for any available port)
- * @param bind_address The interface IP address to bind to (empty for all interfaces)
- * @return UDP socket handle, or INVALID_SOCKET_VALUE on error
- */
-socket_t create_udp_socket(int port = 0, const std::string& bind_address = "");
-
-/**
- * Create a UDP socket with IPv4 support only
- * @param port The port to bind to (0 for any available port)
- * @param bind_address The interface IP address to bind to (empty for all interfaces)
- * @return UDP socket handle, or INVALID_SOCKET_VALUE on error
- */
-socket_t create_udp_socket_v4(int port = 0, const std::string& bind_address = "");
-
-/**
- * Create a UDP socket with IPv6 support only
+ * Create a UDP socket and bind to a port
  * @param port The port to bind to (0 for any available port)
  * @param bind_address The interface IP address to bind to (empty for all interfaces)
+ * @param af Address family (DualStack by default)
  * @return UDP socket handle, or INVALID_SOCKET_VALUE on error
  */
-socket_t create_udp_socket_v6(int port = 0, const std::string& bind_address = "");
-
-/**
- * Send UDP data to a peer
- * @param socket The UDP socket handle
- * @param data The data to send
- * @param peer The destination peer
- * @return Number of bytes sent, or -1 on error
- */
-int send_udp_data(socket_t socket, const std::vector<uint8_t>& data, const Peer& peer);
+socket_t create_udp_socket(int port = 0, const std::string& bind_address = "",
+                           AddressFamily af = AddressFamily::DualStack);
 
 /**
- * Send UDP data to a hostname and port directly
+ * Send UDP data to a destination host and port
  * @param socket The UDP socket handle
  * @param data The data to send
- * @param hostname The destination hostname or IP address
+ * @param host The destination hostname or IP address
  * @param port The destination port
+ * @param af Address family matching the socket (DualStack by default)
  * @return Number of bytes sent, or -1 on error
  */
-int send_udp_data_to(socket_t socket, const std::vector<uint8_t>& data, const std::string& hostname, int port);
+int send_udp_data(socket_t socket, const std::vector<uint8_t>& data, const std::string& host, int port,
+                  AddressFamily af = AddressFamily::DualStack);
 
 /**
- * Receive UDP data from a peer
+ * Receive UDP data with optional timeout
  * @param socket The UDP socket handle
  * @param buffer_size Maximum number of bytes to receive
  * @param sender_peer Output parameter for the sender's peer info
- * @return Received data, empty vector on error
- */
-std::vector<uint8_t> receive_udp_data(socket_t socket, size_t buffer_size, Peer& sender_peer);
-
-/**
- * Receive UDP data with timeout support
- * @param socket The UDP socket handle
- * @param buffer_size Maximum number of bytes to receive
- * @param timeout_ms Timeout in milliseconds (0 for non-blocking, -1 for blocking)
- * @param sender_ip Optional output parameter for sender IP address
- * @param sender_port Optional output parameter for sender port
+ * @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
  */
-std::vector<uint8_t> receive_udp_data_with_timeout(socket_t socket, size_t buffer_size, int timeout_ms, 
-                                                   std::string* sender_ip = nullptr, int* sender_port = nullptr);
+std::vector<uint8_t> receive_udp_data(socket_t socket, size_t buffer_size, Peer& sender_peer,
+                                      int timeout_ms = -1);
 
 // Common Socket Functions
 /**
  * Close a socket
  * @param socket The socket handle to close
+ * @param force If true, send RST instead of FIN (avoids TIME_WAIT)
  */
 void close_socket(socket_t socket, bool force = false);
 
@@ -291,13 +204,6 @@ bool set_socket_nonblocking(socket_t socket);
  */
 bool set_socket_blocking(socket_t socket);
 
-/**
- * Check if a socket is a TCP socket
- * @param socket The socket handle to check
- * @return true if TCP socket, false otherwise
- */
-bool is_tcp_socket(socket_t socket);
-
 /**
  * Connect to a socket address with timeout
  * @param socket The socket handle (should be non-blocking)
@@ -309,10 +215,10 @@ bool is_tcp_socket(socket_t socket);
 bool connect_with_timeout(socket_t socket, struct sockaddr* addr, socklen_t addr_len, int timeout_ms);
 
 /**
- * Get the ephemeral port that a socket is bound to
- * @param socket The socket handle to get the ephemeral port for
- * @return The ephemeral port, or 0 if the socket is not bound to an ephemeral port
+ * Get the port that a socket is bound to
+ * @param socket The socket handle
+ * @return The bound port, or 0 on error
  */
-int get_ephemeral_port(socket_t socket);
+int get_bound_port(socket_t socket);
 
-} // namespace librats 
+} // namespace librats

package/native-src/src/stun.cpp

@@ -1047,7 +1047,7 @@ std::optional<StunMessage> StunClient::send_request(socket_t socket,
         }
         
         // Send request
-        int sent = send_udp_data_to(socket, data, server, port);
+        int sent = send_udp_data(socket, data, server, port);
         if (sent <= 0) {
             LOG_STUN_ERROR("Failed to send STUN request");
             return std::nullopt;
@@ -1057,11 +1057,9 @@ std::optional<StunMessage> StunClient::send_request(socket_t socket,
         
         // Wait for response with current RTO
         int wait_time = (std::min)(rto, timeout_ms - total_time);
-        std::string sender_ip;
-        int sender_port;
+        Peer sender;
         
-        auto response_data = receive_udp_data_with_timeout(socket, STUN_MAX_MESSAGE_SIZE, 
-                                                           wait_time, &sender_ip, &sender_port);
+        auto response_data = receive_udp_data(socket, STUN_MAX_MESSAGE_SIZE, sender, wait_time);
         
         total_time += wait_time;
         

package/native-src/src/tracker.cpp

@@ -673,12 +673,13 @@ std::vector<uint8_t> UdpTrackerClient::send_request(const std::vector<uint8_t>&
     }
     
     // Send request
-    if (send_udp_data_to(socket_, request, hostname_, port_) <= 0) {
+    if (send_udp_data(socket_, request, hostname_, port_) <= 0) {
         return std::vector<uint8_t>();
     }
     
     // Receive response with timeout
-    std::vector<uint8_t> response = receive_udp_data_with_timeout(socket_, 2048, timeout_ms);
+    Peer sender;
+    std::vector<uint8_t> response = receive_udp_data(socket_, 2048, sender, timeout_ms);
     
     return response;
 }

package/native-src/src/turn.cpp

@@ -600,7 +600,7 @@ bool TurnClient::send_indication(const StunMappedAddress& peer, const std::vecto
     indication.add_data(data);
     
     auto msg_data = indication.serialize();
-    int sent = send_udp_data_to(socket_, msg_data, config_.server, config_.port);
+    int sent = send_udp_data(socket_, msg_data, config_.server, config_.port);
     
     return sent > 0;
 }
@@ -625,7 +625,7 @@ bool TurnClient::send_channel_data(uint16_t channel, const std::vector<uint8_t>&
         msg.push_back(0);
     }
     
-    int sent = send_udp_data_to(socket_, msg, config_.server, config_.port);
+    int sent = send_udp_data(socket_, msg, config_.server, config_.port);
     return sent > 0;
 }
 
@@ -634,10 +634,8 @@ std::optional<std::pair<StunMappedAddress, std::vector<uint8_t>>> TurnClient::re
         return std::nullopt;
     }
     
-    std::string sender_ip;
-    int sender_port;
-    auto data = receive_udp_data_with_timeout(socket_, STUN_MAX_MESSAGE_SIZE, timeout_ms,
-                                               &sender_ip, &sender_port);
+    Peer sender;
+    auto data = receive_udp_data(socket_, STUN_MAX_MESSAGE_SIZE, sender, timeout_ms);
     
     if (data.empty()) {
         return std::nullopt;

package/package.json

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

package/src/librats_node.cpp

@@ -1330,6 +1330,25 @@ Napi::Value GetVersion(const Napi::CallbackInfo& info) {
     return version;
 }
 
+// Console logging control functions
+Napi::Value SetConsoleLoggingEnabled(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    if (info.Length() < 1 || !info[0].IsBoolean()) {
+        Napi::TypeError::New(env, "Boolean expected").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+    
+    bool enabled = info[0].As<Napi::Boolean>().Value();
+    rats_set_console_logging_enabled(enabled ? 1 : 0);
+    return env.Undefined();
+}
+
+Napi::Value IsConsoleLoggingEnabled(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    return Napi::Boolean::New(env, rats_is_console_logging_enabled() != 0);
+}
+
 Napi::Value GetGitDescribe(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     const char* git_describe = rats_get_git_describe();
@@ -1399,6 +1418,10 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
     exports.Set("getGitDescribe", Napi::Function::New(env, GetGitDescribe));
     exports.Set("getAbi", Napi::Function::New(env, GetAbi));
     
+    // Export logging control functions
+    exports.Set("setConsoleLoggingEnabled", Napi::Function::New(env, SetConsoleLoggingEnabled));
+    exports.Set("isConsoleLoggingEnabled", Napi::Function::New(env, IsConsoleLoggingEnabled));
+    
     // Export constants
     exports.Set("constants", InitConstants(env));