react-native-nitro-net 0.1.5

package/README.md

@@ -0,0 +1,133 @@
+# react-native-nitro-net
+
+Node.js `net` API implementation for React Native using [Nitro Modules](https://github.com/mrousavy/nitro) and Rust.
+
+## Features
+
+*   🚀 **High Performance**: Built on top of Rust's `tokio` asynchronous runtime.
+*   🤝 **Node.js Compatible**: Implements the standard `net` API including `Socket` (Duplex stream) and `Server`.
+*   ⚡ **Nitro Modules**: Uses JSI for zero-overhead communication between JavaScript and Native code.
+*   🛡️ **Robust & Stable**: Advanced fixes for common networking issues like port reuse, deadlocks, and DNS reliability.
+*   📱 **Cross-Platform**: Supports both iOS and Android.
+
+## Installation
+
+```bash
+npm install react-native-nitro-net
+# or
+yarn add react-native-nitro-net
+```
+
+### iOS
+
+Requires `pod install` to link the native libraries.
+
+```bash
+cd ios && pod install
+```
+
+## Architecture
+
+This library uses a high-performance three-layer architecture:
+
+1.  **JavaScript Layer**: Provides the high-level Node.js compatible `net.Socket` (Duplex) and `net.Server` APIs using `readable-stream` and `EventEmitter`.
+2.  **C++ Bridge (Nitro)**: Handles the zero-copy orchestration between JS and Rust using Nitro Hybrid Objects and JSI.
+3.  **Rust Core**: Implements the actual networking logic using the **Tokio** asynchronous runtime, providing memory safety and high concurrency.
+
+## Usage
+
+### Client (Socket)
+
+```typescript
+import net from 'react-native-nitro-net';
+
+const client = net.createConnection({ port: 8080, host: '1.1.1.1' }, () => {
+  console.log('Connected!');
+  client.write('Hello Server!');
+});
+
+client.on('data', (data) => {
+  console.log('Received:', data.toString());
+});
+
+client.on('error', (err) => {
+  console.error('Error:', err.message);
+});
+```
+
+### Server (Dynamic Port Support)
+
+The server supports binding to a dynamic port by using `0`.
+
+```typescript
+import net from 'react-native-nitro-net';
+
+const server = net.createServer((socket) => {
+  socket.write('Echo: ' + socket.read());
+});
+
+// Use 0 for dynamic port allocation
+server.listen(0, '127.0.0.1', () => {
+  const address = server.address();
+  console.log(`Server listening on dynamic port: ${address?.port}`);
+});
+```
+
+## Stability Improvements
+
+We have implemented several critical fixes to ensure production-grade stability:
+
+*   **Port Reuse (`SO_REUSEPORT`)**: Automatically enabled on Unix/iOS to allow immediate server restarts without the "Address already in use" error.
+*   **Anti-Deadlock Logic**: C++ layer uses lock-free callback dispatching to prevent UI freezes during high-frequency events.
+*   **DNS Reliability**: Automatically retries all resolved IP addresses if the first one fails to connect.
+*   **Resource Management**: Strict protective shutdown logic in Rust to prevent socket and Unix domain socket file leaks.
+
+## API Reference
+
+### `net.Socket`
+
+| Property / Method | Description |
+| --- | --- |
+| `connect(options)` | Connect to a remote host/port or Unix path. |
+| `write(data)` | Send data asynchronously. Supports backpressure. |
+| `destroy()` | Immediate closing of the socket and resource cleanup. |
+| `setNoDelay(bool)` | Control Nagle's algorithm. |
+| `setKeepAlive(bool)`| Enable/disable keep-alive. |
+| `address()` | Returns `{ port, family, address }` for the local side. |
+
+**Events**: `connect`, `ready`, `data`, `error`, `close`, `timeout`, `lookup`.
+
+### Global APIs
+
+| Method | Description |
+| --- | --- |
+| `initWithConfig(options)` | Optional. Initializes the Rust runtime with custom settings (e.g., `workerThreads`). Must be called before any other operation. |
+| `setVerbose(bool)` | Toggle detailed logging for JS, C++, and Rust. |
+| `isIP(string)` | Returns `0`, `4`, or `6`. |
+
+### `net.Server`
+
+| Method | Description |
+| --- | --- |
+| `listen(options)` | Start listening. Supports `port: 0` for dynamic allocation. |
+| `close()` | Stops the server from accepting new connections. |
+| `address()` | Returns the bound address (crucial for dynamic ports). |
+| `getConnections(cb)`| Get count of active connections. |
+
+**Events**: `listening`, `connection`, `error`, `close`.
+
+## Debugging
+
+Enable verbose logging to see the internal data flow across JS, C++, and Rust:
+
+```typescript
+import { setVerbose } from 'react-native-nitro-net';
+
+setVerbose(true);
+```
+
+Logs will be visible in your native debugger (Xcode/logcat) and JS console, prefixed with `[NET DEBUG]` or `[NET NATIVE]`.
+
+## License
+
+ISC

package/android/CMakeLists.txt

@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 3.9.0)
+project(RustCNet)
+
+set(PACKAGE_NAME RustCNet)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+# Add our custom implementation and JNI adapter
+add_library(${PACKAGE_NAME} SHARED
+        ../cpp/HybridNetDriver.cpp
+        ../cpp/HybridNetServerDriver.cpp
+        ../cpp/HybridNetSocketDriver.cpp
+        OnLoad.cpp
+)
+
+# Include paths for our headers
+include_directories(
+    ${CMAKE_CURRENT_SOURCE_DIR}/../cpp
+)
+
+# Include the Nitrogen-generated CMake file
+include(${CMAKE_CURRENT_SOURCE_DIR}/../nitrogen/generated/android/RustCNet+autolinking.cmake)
+
+# Link the Rust Net library
+target_link_directories(${PACKAGE_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/libs/${ANDROID_ABI})
+target_link_libraries(${PACKAGE_NAME} 
+    rust_c_net
+    log # For android logging
+)

package/android/OnLoad.cpp

@@ -0,0 +1,6 @@
+#include "RustCNetOnLoad.hpp"
+#include <jni.h>
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
+  return margelo::nitro::net::initialize(vm);
+}

package/android/build.gradle

@@ -0,0 +1,72 @@
+apply plugin: 'com.android.library'
+apply plugin: 'org.jetbrains.kotlin.android'
+
+def reactNativeArchitectures() {
+    def value = rootProject.getProperties().get("reactNativeArchitectures")
+    return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def getExtOrDefault(name, defaultValue) {
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : defaultValue
+}
+
+android {
+    namespace "com.margelo.nitro.net"
+    ndkVersion getExtOrDefault("ndkVersion", "27.1.12297006")
+    compileSdkVersion getExtOrDefault('compileSdkVersion', 35)
+
+    defaultConfig {
+        minSdkVersion getExtOrDefault('minSdkVersion', 21)
+        targetSdkVersion getExtOrDefault('targetSdkVersion', 35)
+        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", "false" // Default to false, app will override if needed
+
+        externalNativeBuild {
+            cmake {
+                cppFlags "-fexceptions", "-frtti", "-std=c++20"
+                arguments "-DANDROID_STL=c++_shared"
+                abiFilters (*reactNativeArchitectures())
+            }
+        }
+    }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  sourceSets {
+    main {
+      jniLibs.srcDirs += ['libs']
+    }
+  }
+
+    externalNativeBuild {
+        cmake {
+            path "CMakeLists.txt"
+        }
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+        }
+    }
+
+    packagingOptions {
+        excludes += [
+            "**/libc++_shared.so",
+            "**/libjsi.so",
+            "**/libreactnativejni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libturbomodulejsijni.so"
+        ]
+    }
+}
+
+dependencies {
+    implementation "com.facebook.react:react-native:+"
+    implementation project(':react-native-nitro-modules')
+}
+
+// Apply the Nitrogen-generated Gradle file
+apply from: "../nitrogen/generated/android/RustCNet+autolinking.gradle"

package/android/gradle.properties

@@ -0,0 +1,6 @@
+reactNativeArchitectures=arm64-v8a,armeabi-v7a,x86,x86_64
+ndkVersion=27.1.12297006
+compileSdkVersion=35
+targetSdkVersion=35
+minSdkVersion=24
+kotlinVersion=1.9.24

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.margelo.nitro.net">
+</manifest>

package/android/src/main/java/com/margelo/nitro/net/NitroNetPackage.java

@@ -0,0 +1,32 @@
+package com.margelo.nitro.net;
+
+import androidx.annotation.NonNull;
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import java.util.Collections;
+import java.util.List;
+import android.util.Log;
+
+public class NitroNetPackage implements ReactPackage {
+    static {
+        try {
+            System.loadLibrary("RustCNet");
+        } catch (Throwable e) {
+            Log.e("NitroNetPackage", "Failed to load RustCNet library", e);
+        }
+    }
+
+    @NonNull
+    @Override
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+
+    @NonNull
+    @Override
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

package/cpp/HybridNetDriver.cpp

@@ -0,0 +1,5 @@
+#include "HybridNetDriver.hpp"
+
+namespace margelo::nitro::net {
+// Inline
+}

package/cpp/HybridNetDriver.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "../nitrogen/generated/shared/c++/HybridNetDriverSpec.hpp"
+#include "HybridNetServerDriver.hpp"
+#include "HybridNetSocketDriver.hpp"
+#include "NetManager.hpp"
+
+namespace margelo {
+namespace nitro {
+namespace net {
+
+class HybridNetDriver : public HybridNetDriverSpec {
+public:
+  HybridNetDriver() : HybridObject(TAG) {}
+
+  std::shared_ptr<HybridNetSocketDriverSpec>
+  createSocket(const std::optional<std::string> &id) override {
+    if (id.has_value()) {
+      // Existing socket from server accept
+      try {
+        uint32_t socketId = static_cast<uint32_t>(std::stoul(id.value()));
+        return std::make_shared<HybridNetSocketDriver>(socketId);
+      } catch (...) {
+        return std::make_shared<HybridNetSocketDriver>();
+      }
+    }
+    return std::make_shared<HybridNetSocketDriver>();
+  }
+
+  std::shared_ptr<HybridNetServerDriverSpec> createServer() override {
+    return std::make_shared<HybridNetServerDriver>();
+  }
+
+  void initWithConfig(const NetConfig &config) override {
+    uint32_t workerThreads = config.workerThreads.value_or(0);
+    NetManager::shared().initWithConfig(workerThreads);
+  }
+};
+
+} // namespace net
+} // namespace nitro
+} // namespace margelo

package/cpp/HybridNetServerDriver.cpp

@@ -0,0 +1,5 @@
+#include "HybridNetServerDriver.hpp"
+
+namespace margelo::nitro::net {
+// Inline implementation
+}

package/cpp/HybridNetServerDriver.hpp

@@ -0,0 +1,114 @@
+#pragma once
+
+#include "../nitrogen/generated/shared/c++/HybridNetServerDriverSpec.hpp"
+#include "NetBindings.hpp"
+#include "NetManager.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <optional>
+#include <string>
+
+namespace margelo {
+namespace nitro {
+namespace net {
+
+class HybridNetServerDriver : public HybridNetServerDriverSpec {
+public:
+  HybridNetServerDriver() : HybridObject(TAG) {
+    _id = net_create_server();
+    NetManager::shared().registerHandler(
+        _id, [this](int type, const uint8_t *data, size_t len) {
+          this->onNativeEvent(type, data, len);
+        });
+  }
+
+  ~HybridNetServerDriver() override { destroy(); }
+
+  // Properties
+  std::function<void(double, const std::shared_ptr<ArrayBuffer> &)>
+  getOnEvent() override {
+    return _onEvent;
+  }
+  void setOnEvent(
+      const std::function<void(double, const std::shared_ptr<ArrayBuffer> &)>
+          &onEvent) override {
+    _onEvent = onEvent;
+  }
+
+  double getMaxConnections() override { return _maxConnections; }
+  void setMaxConnections(double maxConnections) override {
+    _maxConnections = maxConnections;
+    net_server_set_max_connections(_id, static_cast<int>(maxConnections));
+  }
+
+  // Methods
+  void listen(double port, std::optional<double> backlog,
+              std::optional<bool> ipv6Only,
+              std::optional<bool> reusePort) override {
+    net_listen(_id, static_cast<int>(port),
+               static_cast<int>(backlog.value_or(128)),
+               ipv6Only.value_or(false), reusePort.value_or(false));
+  }
+
+  void listenUnix(const std::string &path,
+                  std::optional<double> backlog) override {
+    net_listen_unix(_id, path.c_str(), static_cast<int>(backlog.value_or(128)));
+  }
+
+  void listenHandle(double fd, std::optional<double> backlog) override {
+    net_listen_handle(_id, static_cast<int>(fd),
+                      static_cast<int>(backlog.value_or(128)));
+  }
+
+  std::string getLocalAddress() override {
+    char buf[256];
+    size_t len = net_get_server_local_address(_id, buf, sizeof(buf));
+    if (len > 0 && len < sizeof(buf)) {
+      buf[len] = '\0';
+      return std::string(buf);
+    }
+    return "";
+  }
+
+  void close() override {
+    if (_id != 0) {
+      net_server_close(_id);
+    }
+  }
+
+private:
+  void destroy() {
+    if (_id != 0) {
+      NetManager::shared().unregisterHandler(_id);
+      net_destroy_server(_id);
+      _id = 0;
+    }
+  }
+
+  void onNativeEvent(int type, const uint8_t *data, size_t len) {
+    if (!_onEvent)
+      return;
+
+    std::shared_ptr<ArrayBuffer> ab;
+    if (data && len > 0) {
+      ab = ArrayBuffer::copy(data, len);
+    } else {
+      static uint8_t empty = 0;
+      ab = ArrayBuffer::copy(&empty, 0);
+    }
+
+    _onEvent(static_cast<double>(type), ab);
+
+    if (type == 4) { // CLOSE
+      LOGI("Server %u received CLOSE event, destroying...", _id);
+      destroy();
+    }
+  }
+
+  uint32_t _id;
+  double _maxConnections = 0;
+  std::function<void(double, const std::shared_ptr<ArrayBuffer> &)> _onEvent;
+};
+
+} // namespace net
+} // namespace nitro
+} // namespace margelo

package/cpp/HybridNetSocketDriver.cpp

@@ -0,0 +1,6 @@
+#include "HybridNetSocketDriver.hpp"
+
+namespace margelo::nitro::net {
+// Implementation is inline in header for simplicity, but if needed we can move
+// it here.
+}

package/cpp/HybridNetSocketDriver.hpp

@@ -0,0 +1,132 @@
+#pragma once
+
+#include "../nitrogen/generated/shared/c++/HybridNetSocketDriverSpec.hpp"
+#include "NetBindings.hpp"
+#include "NetManager.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <string>
+
+namespace margelo {
+namespace nitro {
+namespace net {
+
+class HybridNetSocketDriver : public HybridNetSocketDriverSpec {
+public:
+  HybridNetSocketDriver() : HybridObject(TAG) {
+    _id = net_create_socket();
+    NetManager::shared().registerHandler(
+        _id, [this](int type, const uint8_t *data, size_t len) {
+          this->onNativeEvent(type, data, len);
+        });
+  }
+
+  // For server connections (created with existing ID)
+  explicit HybridNetSocketDriver(uint32_t id) : HybridObject(TAG), _id(id) {
+    NetManager::shared().registerHandler(
+        _id, [this](int type, const uint8_t *data, size_t len) {
+          this->onNativeEvent(type, data, len);
+        });
+  }
+
+  ~HybridNetSocketDriver() override { destroy(); }
+
+  // Properties
+  double getId() override { return static_cast<double>(_id); }
+
+  std::function<void(double, const std::shared_ptr<ArrayBuffer> &)>
+  getOnEvent() override {
+    return _onEvent;
+  }
+  void setOnEvent(
+      const std::function<void(double, const std::shared_ptr<ArrayBuffer> &)>
+          &onEvent) override {
+    _onEvent = onEvent;
+  }
+
+  // Methods
+  void connect(const std::string &host, double port) override {
+    net_connect(_id, host.c_str(), static_cast<int>(port));
+  }
+
+  void write(const std::shared_ptr<ArrayBuffer> &data) override {
+    if (!data)
+      return;
+    net_write(_id, data->data(), data->size());
+  }
+
+  void destroy() override {
+    if (_id != 0) {
+      NetManager::shared().unregisterHandler(_id);
+      net_destroy_socket(_id);
+      _id = 0;
+    }
+  }
+
+  void resetAndDestroy() override {
+    if (_id != 0) {
+      net_socket_reset_and_destroy(_id);
+      NetManager::shared().unregisterHandler(_id);
+      _id = 0;
+    }
+  }
+
+  void setNoDelay(bool enable) override { net_set_nodelay(_id, enable); }
+
+  void setKeepAlive(bool enable, double delay) override {
+    net_set_keepalive(_id, enable, static_cast<uint64_t>(delay));
+  }
+
+  void setTimeout(double timeout) override {
+    net_set_timeout(_id, static_cast<uint64_t>(timeout));
+  }
+
+  std::string getLocalAddress() override {
+    char buf[256];
+    size_t len = net_get_local_address(_id, buf, sizeof(buf));
+    if (len > 0 && len < sizeof(buf)) {
+      return std::string(buf);
+    }
+    return "";
+  }
+
+  std::string getRemoteAddress() override {
+    char buf[256];
+    size_t len = net_get_remote_address(_id, buf, sizeof(buf));
+    if (len == 0)
+      return "";
+    return std::string(buf);
+  }
+
+  void pause() override { net_pause(_id); }
+
+  void resume() override { net_resume(_id); }
+
+  void shutdown() override { net_shutdown(_id); }
+
+  void connectUnix(const std::string &path) override {
+    net_connect_unix(_id, path.c_str());
+  }
+
+private:
+  void onNativeEvent(int type, const uint8_t *data, size_t len) {
+    if (!_onEvent)
+      return;
+
+    std::shared_ptr<ArrayBuffer> ab;
+    if (data && len > 0) {
+      ab = ArrayBuffer::copy(data, len);
+    } else {
+      static uint8_t empty = 0;
+      ab = ArrayBuffer::copy(&empty, 0);
+    }
+
+    _onEvent(static_cast<double>(type), ab);
+  }
+
+  uint32_t _id;
+  std::function<void(double, const std::shared_ptr<ArrayBuffer> &)> _onEvent;
+};
+
+} // namespace net
+} // namespace nitro
+} // namespace margelo

package/cpp/NetBindings.hpp

@@ -0,0 +1,68 @@
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>
+
+extern "C" {
+
+// Callback function type
+typedef void (*NetCallback)(uint32_t id, int event_type, const uint8_t *data,
+                            size_t len, void *context);
+
+// Init
+void net_init(NetCallback callback, void *context);
+/// Initialize with configuration
+/// @param callback Event callback function
+/// @param context User context passed to callback
+/// @param worker_threads Number of worker threads, 0 = use CPU core count
+void net_init_with_config(NetCallback callback, void *context,
+                          uint32_t worker_threads);
+
+// Socket
+uint32_t net_create_socket();
+void net_connect(uint32_t id, const char *host, int port);
+void net_write(uint32_t id, const uint8_t *data, size_t len);
+void net_close(uint32_t id);
+void net_destroy_socket(uint32_t id);
+void net_socket_reset_and_destroy(uint32_t id);
+
+// New Options
+void net_set_nodelay(uint32_t id, bool enable);
+void net_set_keepalive(uint32_t id, bool enable, uint64_t delay_ms);
+void net_set_timeout(uint32_t id, uint64_t timeout_ms);
+
+// New Address Info
+// Returns length of address string. buf can be null to query length.
+size_t net_get_local_address(uint32_t id, char *buf, size_t len);
+size_t net_get_remote_address(uint32_t id, char *buf, size_t len);
+
+// Flow Control
+void net_pause(uint32_t id);
+void net_resume(uint32_t id);
+void net_shutdown(uint32_t id);
+
+// IPC
+void net_connect_unix(uint32_t id, const char *path);
+void net_listen_unix(uint32_t id, const char *path, int backlog);
+
+// Server
+uint32_t net_create_server();
+void net_listen(uint32_t id, int port, int backlog, bool ipv6_only,
+                bool reuse_port);
+void net_server_close(uint32_t id);
+void net_destroy_server(uint32_t id);
+void net_server_set_max_connections(uint32_t id, int max_connections);
+size_t net_get_server_local_address(uint32_t id, char *buf, size_t len);
+/// Listen on an existing file descriptor (handle)
+/// @param id Server ID
+/// @param fd File descriptor of an already-bound TCP listener
+/// @param backlog Listen backlog
+void net_listen_handle(uint32_t id, int fd, int backlog);
+
+// Event Types
+#define NET_EVENT_CONNECT 1
+#define NET_EVENT_DATA 2
+#define NET_EVENT_ERROR 3
+#define NET_EVENT_CLOSE 4
+#define NET_EVENT_CONNECTION 6
+}