react-native-nitro-net 0.1.5

package/cpp/NetManager.hpp

@@ -0,0 +1,160 @@
+#pragma once
+
+#include "NetBindings.hpp"
+#include <functional>
+#include <memory>
+#include <shared_mutex>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#define NM_TAG "NetManager"
+
+#ifdef __ANDROID__
+#include <android/log.h>
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, NM_TAG, __VA_ARGS__)
+#define LOGW(...) __android_log_print(ANDROID_LOG_WARN, NM_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, NM_TAG, __VA_ARGS__)
+#else
+#include <cstdio>
+#define LOGI(...)                                                              \
+  printf("[" NM_TAG "] " __VA_ARGS__);                                         \
+  printf("\n")
+#define LOGW(...)                                                              \
+  printf("[" NM_TAG "] WARN: " __VA_ARGS__);                                   \
+  printf("\n")
+#define LOGE(...)                                                              \
+  printf("[" NM_TAG "] ERROR: " __VA_ARGS__);                                  \
+  printf("\n")
+#endif
+
+namespace margelo::nitro::net {
+
+class NetManager {
+public:
+  using EventHandler =
+      std::function<void(int eventType, const uint8_t *data, size_t len)>;
+
+  static NetManager &shared() {
+    static NetManager instance;
+    return instance;
+  }
+
+  NetManager() {
+    LOGI("Initializing NetManager with default config...");
+    initializeRuntime(0); // 0 = use default (CPU core count)
+  }
+
+  /// Initialize with custom worker thread count
+  /// Must be called before any other operations, or the config will be ignored
+  void initWithConfig(uint32_t workerThreads) {
+    if (!_initialized) {
+      LOGI("Initializing NetManager with %u worker threads...", workerThreads);
+      initializeRuntime(workerThreads);
+    } else {
+      LOGW("NetManager already initialized, config ignored. Call "
+           "initWithConfig before any socket/server operations.");
+    }
+  }
+
+private:
+  void initializeRuntime(uint32_t workerThreads) {
+    if (_initialized)
+      return;
+    _initialized = true;
+
+    if (workerThreads > 0) {
+      net_init_with_config(
+          [](uint32_t id, int event_type, const uint8_t *data, size_t len,
+             void *context) {
+            auto mgr = static_cast<NetManager *>(context);
+            mgr->dispatch(id, event_type, data, len);
+          },
+          this, workerThreads);
+    } else {
+      net_init(
+          [](uint32_t id, int event_type, const uint8_t *data, size_t len,
+             void *context) {
+            auto mgr = static_cast<NetManager *>(context);
+            mgr->dispatch(id, event_type, data, len);
+          },
+          this);
+    }
+  }
+
+  bool _initialized = false;
+
+public:
+  void registerHandler(uint32_t id, EventHandler handler) {
+    LOGI("Registering handler for ID %u", id);
+    std::unique_lock lock(_mutex);
+    _handlers[id] = handler;
+  }
+
+  void unregisterHandler(uint32_t id) {
+    LOGI("Unregistering handler for ID %u", id);
+    std::unique_lock lock(_mutex);
+    _handlers.erase(id);
+  }
+
+private:
+  void dispatch(uint32_t id, int eventType, const uint8_t *data, size_t len) {
+    // Log all events for debugging
+    const char *eventName = "UNKNOWN";
+    switch (eventType) {
+    case 1:
+      eventName = "CONNECT";
+      break;
+    case 2:
+      eventName = "DATA";
+      break;
+    case 3:
+      eventName = "ERROR";
+      break;
+    case 4:
+      eventName = "CLOSE";
+      break;
+    case 5:
+      eventName = "DRAIN";
+      break;
+    case 6:
+      eventName = "CONNECTION";
+      break;
+    case 7:
+      eventName = "TIMEOUT";
+      break;
+    case 8:
+      eventName = "LOOKUP";
+      break;
+    case 9:
+      eventName = "DEBUG";
+      break;
+    }
+
+    LOGI("dispatch: id=%u, event=%s(%d), len=%zu", id, eventName, eventType,
+         len);
+
+    // Copy handler outside of lock to avoid deadlock
+    // (handler may call unregisterHandler which needs unique_lock)
+    EventHandler handler;
+    {
+      std::shared_lock lock(_mutex);
+      auto it = _handlers.find(id);
+      if (it != _handlers.end()) {
+        handler = it->second;
+      }
+    }
+
+    // Call handler outside of lock
+    if (handler) {
+      handler(eventType, data, len);
+    } else {
+      LOGW("No handler found for id=%u, event=%s", id, eventName);
+    }
+  }
+
+  std::shared_mutex _mutex;
+  std::unordered_map<uint32_t, EventHandler> _handlers;
+};
+
+} // namespace margelo::nitro::net

package/ios/Frameworks/RustCNet.xcframework/Info.plist

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>AvailableLibraries</key>
+	<array>
+		<dict>
+			<key>BinaryPath</key>
+			<string>RustCNet.framework/RustCNet</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64_x86_64-simulator</string>
+			<key>LibraryPath</key>
+			<string>RustCNet.framework</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+				<string>x86_64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
+		</dict>
+		<dict>
+			<key>BinaryPath</key>
+			<string>RustCNet.framework/RustCNet</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64</string>
+			<key>LibraryPath</key>
+			<string>RustCNet.framework</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+		</dict>
+	</array>
+	<key>CFBundlePackageType</key>
+	<string>XFWK</string>
+	<key>XCFrameworkFormatVersion</key>
+	<string>1.0</string>
+</dict>
+</plist>

package/ios/Frameworks/RustCNet.xcframework/ios-arm64/RustCNet.framework/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleExecutable</key>
+    <string>RustCNet</string>
+    <key>CFBundleIdentifier</key>
+    <string>com.iwater.RustCNet</string>
+    <key>CFBundleName</key>
+    <string>RustCNet</string>
+    <key>CFBundlePackageType</key>
+    <string>FMWK</string>
+    <key>CFBundleVersion</key>
+    <string>1.0</string>
+    <key>CFBundleShortVersionString</key>
+    <string>1.0</string>
+    <key>MinimumOSVersion</key>
+    <string>13.0</string>
+</dict>
+</plist>

package/ios/Frameworks/RustCNet.xcframework/ios-arm64_x86_64-simulator/RustCNet.framework/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleExecutable</key>
+    <string>RustCNet</string>
+    <key>CFBundleIdentifier</key>
+    <string>com.iwater.RustCNet</string>
+    <key>CFBundleName</key>
+    <string>RustCNet</string>
+    <key>CFBundlePackageType</key>
+    <string>FMWK</string>
+    <key>CFBundleVersion</key>
+    <string>1.0</string>
+    <key>CFBundleShortVersionString</key>
+    <string>1.0</string>
+    <key>MinimumOSVersion</key>
+    <string>13.0</string>
+</dict>
+</plist>

package/lib/Driver.d.ts

@@ -0,0 +1,2 @@
+import type { NetDriver } from './Net.nitro';
+export declare const Driver: NetDriver;

package/lib/Driver.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Driver = void 0;
+const react_native_nitro_modules_1 = require("react-native-nitro-modules");
+exports.Driver = react_native_nitro_modules_1.NitroModules.createHybridObject('NetDriver');

package/lib/Net.nitro.d.ts

@@ -0,0 +1,85 @@
+import { type HybridObject } from 'react-native-nitro-modules';
+export type NetEventType = 'connect' | 'data' | 'error' | 'close' | 'connection';
+export interface NetEvent {
+    type: NetEventType;
+    data?: ArrayBuffer;
+    error?: string;
+    id?: string;
+}
+export type NetEventHandler = (event: NetEvent) => void;
+export declare enum NetSocketEvent {
+    CONNECT = 1,
+    DATA = 2,
+    ERROR = 3,
+    CLOSE = 4,
+    DRAIN = 5,
+    TIMEOUT = 7,
+    LOOKUP = 8,
+    DEBUG = 9
+}
+export interface NetSocketDriver extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    readonly id: number;
+    connect(host: string, port: number): void;
+    connectUnix(path: string): void;
+    write(data: ArrayBuffer): void;
+    pause(): void;
+    resume(): void;
+    shutdown(): void;
+    setTimeout(timeout: number): void;
+    destroy(): void;
+    resetAndDestroy(): void;
+    setNoDelay(enable: boolean): void;
+    setKeepAlive(enable: boolean, delay: number): void;
+    getLocalAddress(): string;
+    getRemoteAddress(): string;
+    onEvent: (event: number, data: ArrayBuffer) => void;
+}
+export declare enum NetServerEvent {
+    CONNECTION = 6,
+    ERROR = 3,
+    CLOSE = 4,
+    DEBUG = 9
+}
+export interface NetServerDriver extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    onEvent: (event: number, data: ArrayBuffer) => void;
+    listen(port: number, backlog?: number, ipv6Only?: boolean, reusePort?: boolean): void;
+    listenUnix(path: string, backlog?: number): void;
+    /**
+     * Listen on an existing file descriptor (handle)
+     * @param fd File descriptor of an already-bound TCP listener
+     * @param backlog Listen backlog (optional, defaults to 128)
+     */
+    listenHandle(fd: number, backlog?: number): void;
+    getLocalAddress(): string;
+    maxConnections: number;
+    close(): void;
+}
+/**
+ * Runtime configuration for the network module
+ */
+export interface NetConfig {
+    /**
+     * Number of worker threads for the async runtime
+     * 0 = use CPU core count (default)
+     */
+    workerThreads?: number;
+}
+export interface NetDriver extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    createSocket(id?: string): NetSocketDriver;
+    createServer(): NetServerDriver;
+    /**
+     * Initialize the network module with custom configuration
+     * Must be called before any other network operations
+     * @param config Configuration options
+     */
+    initWithConfig(config: NetConfig): void;
+}

package/lib/Net.nitro.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetServerEvent = exports.NetSocketEvent = void 0;
+var NetSocketEvent;
+(function (NetSocketEvent) {
+    NetSocketEvent[NetSocketEvent["CONNECT"] = 1] = "CONNECT";
+    NetSocketEvent[NetSocketEvent["DATA"] = 2] = "DATA";
+    NetSocketEvent[NetSocketEvent["ERROR"] = 3] = "ERROR";
+    NetSocketEvent[NetSocketEvent["CLOSE"] = 4] = "CLOSE";
+    NetSocketEvent[NetSocketEvent["DRAIN"] = 5] = "DRAIN";
+    NetSocketEvent[NetSocketEvent["TIMEOUT"] = 7] = "TIMEOUT";
+    NetSocketEvent[NetSocketEvent["LOOKUP"] = 8] = "LOOKUP";
+    NetSocketEvent[NetSocketEvent["DEBUG"] = 9] = "DEBUG";
+})(NetSocketEvent || (exports.NetSocketEvent = NetSocketEvent = {}));
+var NetServerEvent;
+(function (NetServerEvent) {
+    NetServerEvent[NetServerEvent["CONNECTION"] = 6] = "CONNECTION";
+    NetServerEvent[NetServerEvent["ERROR"] = 3] = "ERROR";
+    NetServerEvent[NetServerEvent["CLOSE"] = 4] = "CLOSE";
+    NetServerEvent[NetServerEvent["DEBUG"] = 9] = "DEBUG";
+})(NetServerEvent || (exports.NetServerEvent = NetServerEvent = {}));

package/lib/index.d.ts

@@ -0,0 +1,162 @@
+import { Duplex, DuplexOptions } from 'readable-stream';
+import { EventEmitter } from 'eventemitter3';
+import type { NetSocketDriver, NetConfig } from './Net.nitro';
+declare function isIP(input: string): number;
+declare function isIPv4(input: string): boolean;
+declare function isIPv6(input: string): boolean;
+declare function setVerbose(enabled: boolean): void;
+declare function getDefaultAutoSelectFamily(): number;
+declare function setDefaultAutoSelectFamily(family: number): void;
+/**
+ * Initialize the network module with custom configuration.
+ * Must be called before any socket/server operations, or the config will be ignored.
+ *
+ * @param config Configuration options
+ * @param config.workerThreads Number of worker threads (0 = use CPU core count)
+ *
+ * @example
+ * ```ts
+ * import { initWithConfig } from 'react-native-nitro-net';
+ *
+ * // Initialize with 4 worker threads
+ * initWithConfig({ workerThreads: 4 });
+ * ```
+ */
+declare function initWithConfig(config: NetConfig): void;
+export declare class SocketAddress {
+    readonly address: string;
+    readonly family: 'ipv4' | 'ipv6';
+    readonly port: number;
+    readonly flowlabel: number;
+    constructor(options: {
+        address: string;
+        family?: 'ipv4' | 'ipv6';
+        port: number;
+        flowlabel?: number;
+    });
+}
+export declare class BlockList {
+    private _rules;
+    addAddress(address: string, family?: 'ipv4' | 'ipv6'): void;
+    addRange(start: string, end: string, family?: 'ipv4' | 'ipv6'): void;
+    addSubnet(net: string, prefix: number, family?: 'ipv4' | 'ipv6'): void;
+    check(address: string, family?: 'ipv4' | 'ipv6'): boolean;
+}
+export interface SocketOptions extends DuplexOptions {
+    fd?: any;
+    allowHalfOpen?: boolean;
+    readable?: boolean;
+    writable?: boolean;
+    path?: string;
+    socketDriver?: NetSocketDriver;
+    remoteFamily?: string;
+}
+export declare class Socket extends Duplex {
+    private _driver;
+    connecting: boolean;
+    private _connected;
+    private _hadError;
+    remoteAddress?: string;
+    remotePort?: number;
+    remoteFamily?: string;
+    localAddress?: string;
+    localPort?: number;
+    bytesRead: number;
+    bytesWritten: number;
+    autoSelectFamilyAttemptedAddresses: string[];
+    private _autoSelectFamily;
+    get localFamily(): string;
+    get readyState(): string;
+    get pending(): boolean;
+    constructor(options?: SocketOptions);
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
+    private _setupEvents;
+    private _updateAddresses;
+    address(): {
+        port: number;
+        family: string;
+        address: string;
+    } | null;
+    connect(options: any, connectionListener?: () => void): this;
+    private _connect;
+    private _connectUnix;
+    end(cb?: () => void): this;
+    end(chunk: any, cb?: () => void): this;
+    end(chunk: any, encoding: string, cb?: () => void): this;
+    _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
+    _read(size: number): void;
+    _final(callback: (error?: Error | null) => void): void;
+    destroy(reason?: Error): this;
+    _destroy(err: Error | null, callback: (error: Error | null) => void): void;
+    setTimeout(msecs: number, callback?: () => void): this;
+    /**
+     * Pause the reading of data. That is, 'data' events will not be emitted.
+     * Useful to throttle back an upload.
+     */
+    pause(): this;
+    /**
+     * Resume reading after a call to pause().
+     */
+    resume(): this;
+    /**
+     * Enable/disable the use of Nagle's algorithm.
+     */
+    setNoDelay(noDelay?: boolean): this;
+    setKeepAlive(enable?: boolean, initialDelay?: number): this;
+    ref(): this;
+    unref(): this;
+    /**
+     * Set the encoding for the socket as a Readable Stream.
+     * Use 'utf8', 'hex', etc.
+     */
+    setEncoding(encoding: BufferEncoding): this;
+    get timeout(): number | undefined;
+    get bufferSize(): number;
+    resetAndDestroy(): this;
+}
+export declare class Server extends EventEmitter {
+    private _driver;
+    private _sockets;
+    private _connections;
+    private _maxConnections;
+    private _dropMaxConnection;
+    get maxConnections(): number;
+    set maxConnections(value: number);
+    get dropMaxConnection(): boolean;
+    set dropMaxConnection(value: boolean);
+    get listening(): boolean;
+    constructor(options?: any, connectionListener?: (socket: Socket) => void);
+    ref(): this;
+    unref(): this;
+    [Symbol.asyncDispose](): Promise<void>;
+    listen(port?: any, host?: any, backlog?: any, callback?: any): this;
+    close(callback?: (err?: Error) => void): this;
+    address(): {
+        port: number;
+        family: string;
+        address: string;
+    } | null;
+    getConnections(cb: (err: Error | null, count: number) => void): void;
+}
+export declare function createConnection(options: any, connectionListener?: () => void): Socket;
+export declare const connect: typeof createConnection;
+export declare function createServer(options?: any, connectionListener?: (socket: Socket) => void): Server;
+export { isIP, isIPv4, isIPv6, getDefaultAutoSelectFamily, setDefaultAutoSelectFamily, setVerbose, initWithConfig, };
+export type { NetConfig };
+declare const _default: {
+    Socket: typeof Socket;
+    Server: typeof Server;
+    SocketAddress: typeof SocketAddress;
+    BlockList: typeof BlockList;
+    createConnection: typeof createConnection;
+    createServer: typeof createServer;
+    connect: typeof createConnection;
+    isIP: typeof isIP;
+    isIPv4: typeof isIPv4;
+    isIPv6: typeof isIPv6;
+    getDefaultAutoSelectFamily: typeof getDefaultAutoSelectFamily;
+    setDefaultAutoSelectFamily: typeof setDefaultAutoSelectFamily;
+    setVerbose: typeof setVerbose;
+    initWithConfig: typeof initWithConfig;
+};
+export default _default;