react-native-nitro-net 0.1.5 → 0.2.0

package/nitrogen/generated/shared/c++/HybridNetServerDriverSpec.cpp

@@ -19,6 +19,7 @@ namespace margelo::nitro::net {
       prototype.registerHybridGetter("maxConnections", &HybridNetServerDriverSpec::getMaxConnections);
       prototype.registerHybridSetter("maxConnections", &HybridNetServerDriverSpec::setMaxConnections);
       prototype.registerHybridMethod("listen", &HybridNetServerDriverSpec::listen);
+      prototype.registerHybridMethod("listenTLS", &HybridNetServerDriverSpec::listenTLS);
       prototype.registerHybridMethod("listenUnix", &HybridNetServerDriverSpec::listenUnix);
       prototype.registerHybridMethod("listenHandle", &HybridNetServerDriverSpec::listenHandle);
       prototype.registerHybridMethod("getLocalAddress", &HybridNetServerDriverSpec::getLocalAddress);

package/nitrogen/generated/shared/c++/HybridNetServerDriverSpec.hpp

@@ -55,6 +55,7 @@ namespace margelo::nitro::net {
     public:
       // Methods
       virtual void listen(double port, std::optional<double> backlog, std::optional<bool> ipv6Only, std::optional<bool> reusePort) = 0;
+      virtual void listenTLS(double port, double secureContextId, std::optional<double> backlog, std::optional<bool> ipv6Only, std::optional<bool> reusePort) = 0;
       virtual void listenUnix(const std::string& path, std::optional<double> backlog) = 0;
       virtual void listenHandle(double fd, std::optional<double> backlog) = 0;
       virtual std::string getLocalAddress() = 0;

package/nitrogen/generated/shared/c++/HybridNetSocketDriverSpec.cpp

@@ -18,7 +18,21 @@ namespace margelo::nitro::net {
       prototype.registerHybridGetter("onEvent", &HybridNetSocketDriverSpec::getOnEvent);
       prototype.registerHybridSetter("onEvent", &HybridNetSocketDriverSpec::setOnEvent);
       prototype.registerHybridMethod("connect", &HybridNetSocketDriverSpec::connect);
+      prototype.registerHybridMethod("connectTLS", &HybridNetSocketDriverSpec::connectTLS);
+      prototype.registerHybridMethod("connectTLSWithContext", &HybridNetSocketDriverSpec::connectTLSWithContext);
+      prototype.registerHybridMethod("getAuthorizationError", &HybridNetSocketDriverSpec::getAuthorizationError);
+      prototype.registerHybridMethod("getProtocol", &HybridNetSocketDriverSpec::getProtocol);
+      prototype.registerHybridMethod("getCipher", &HybridNetSocketDriverSpec::getCipher);
+      prototype.registerHybridMethod("getALPN", &HybridNetSocketDriverSpec::getALPN);
+      prototype.registerHybridMethod("getPeerCertificateJSON", &HybridNetSocketDriverSpec::getPeerCertificateJSON);
+      prototype.registerHybridMethod("getEphemeralKeyInfo", &HybridNetSocketDriverSpec::getEphemeralKeyInfo);
+      prototype.registerHybridMethod("getSharedSigalgs", &HybridNetSocketDriverSpec::getSharedSigalgs);
+      prototype.registerHybridMethod("isSessionReused", &HybridNetSocketDriverSpec::isSessionReused);
+      prototype.registerHybridMethod("getSession", &HybridNetSocketDriverSpec::getSession);
+      prototype.registerHybridMethod("setSession", &HybridNetSocketDriverSpec::setSession);
       prototype.registerHybridMethod("connectUnix", &HybridNetSocketDriverSpec::connectUnix);
+      prototype.registerHybridMethod("connectUnixTLS", &HybridNetSocketDriverSpec::connectUnixTLS);
+      prototype.registerHybridMethod("connectUnixTLSWithContext", &HybridNetSocketDriverSpec::connectUnixTLSWithContext);
       prototype.registerHybridMethod("write", &HybridNetSocketDriverSpec::write);
       prototype.registerHybridMethod("pause", &HybridNetSocketDriverSpec::pause);
       prototype.registerHybridMethod("resume", &HybridNetSocketDriverSpec::resume);
@@ -26,6 +40,7 @@ namespace margelo::nitro::net {
       prototype.registerHybridMethod("setTimeout", &HybridNetSocketDriverSpec::setTimeout);
       prototype.registerHybridMethod("destroy", &HybridNetSocketDriverSpec::destroy);
       prototype.registerHybridMethod("resetAndDestroy", &HybridNetSocketDriverSpec::resetAndDestroy);
+      prototype.registerHybridMethod("enableKeylog", &HybridNetSocketDriverSpec::enableKeylog);
       prototype.registerHybridMethod("setNoDelay", &HybridNetSocketDriverSpec::setNoDelay);
       prototype.registerHybridMethod("setKeepAlive", &HybridNetSocketDriverSpec::setKeepAlive);
       prototype.registerHybridMethod("getLocalAddress", &HybridNetSocketDriverSpec::getLocalAddress);

package/nitrogen/generated/shared/c++/HybridNetSocketDriverSpec.hpp

@@ -18,6 +18,7 @@
 #include <NitroModules/ArrayBuffer.hpp>
 #include <functional>
 #include <string>
+#include <optional>
 
 namespace margelo::nitro::net {
 
@@ -53,7 +54,21 @@ namespace margelo::nitro::net {
     public:
       // Methods
       virtual void connect(const std::string& host, double port) = 0;
+      virtual void connectTLS(const std::string& host, double port, const std::optional<std::string>& serverName, std::optional<bool> rejectUnauthorized) = 0;
+      virtual void connectTLSWithContext(const std::string& host, double port, const std::optional<std::string>& serverName, std::optional<bool> rejectUnauthorized, std::optional<double> secureContextId) = 0;
+      virtual std::optional<std::string> getAuthorizationError() = 0;
+      virtual std::optional<std::string> getProtocol() = 0;
+      virtual std::optional<std::string> getCipher() = 0;
+      virtual std::optional<std::string> getALPN() = 0;
+      virtual std::optional<std::string> getPeerCertificateJSON() = 0;
+      virtual std::optional<std::string> getEphemeralKeyInfo() = 0;
+      virtual std::optional<std::string> getSharedSigalgs() = 0;
+      virtual bool isSessionReused() = 0;
+      virtual std::optional<std::shared_ptr<ArrayBuffer>> getSession() = 0;
+      virtual void setSession(const std::shared_ptr<ArrayBuffer>& session) = 0;
       virtual void connectUnix(const std::string& path) = 0;
+      virtual void connectUnixTLS(const std::string& path, const std::optional<std::string>& serverName, std::optional<bool> rejectUnauthorized) = 0;
+      virtual void connectUnixTLSWithContext(const std::string& path, const std::optional<std::string>& serverName, std::optional<bool> rejectUnauthorized, std::optional<double> secureContextId) = 0;
       virtual void write(const std::shared_ptr<ArrayBuffer>& data) = 0;
       virtual void pause() = 0;
       virtual void resume() = 0;
@@ -61,6 +76,7 @@ namespace margelo::nitro::net {
       virtual void setTimeout(double timeout) = 0;
       virtual void destroy() = 0;
       virtual void resetAndDestroy() = 0;
+      virtual void enableKeylog() = 0;
       virtual void setNoDelay(bool enable) = 0;
       virtual void setKeepAlive(bool enable, double delay) = 0;
       virtual std::string getLocalAddress() = 0;

package/package.json

@@ -1,10 +1,11 @@
 {
     "name": "react-native-nitro-net",
-    "version": "0.1.5",
     "description": "Ultra-high-performance networking to React Native by combining a memory-safe Rust core with the zero-overhead Nitro Modules JSI bridge. Provides Node.js-compatible net API.",
+    "version": "0.2.0",
     "main": "./lib/index.js",
     "module": "./lib/index.js",
     "types": "./lib/index.d.ts",
+    "react-native": "src/index.ts",
     "keywords": [
         "react-native",
         "ios",
@@ -24,6 +25,7 @@
         "url": "https://github.com/iwater/react-native-nitro-net/issues"
     },
     "scripts": {
+        "one": "yarn copy-clib && yarn build && yarn pack",
         "build": "npx nitrogen@0.32.0 && tsc",
         "prepare": "npm run build",
         "copy-clib": "rm -rf ios/Frameworks/RustCNet.xcframework && cp -R ../rust_c_net/target/xcframework/RustCNet.xcframework ios/Frameworks/ && mkdir -p android/libs/arm64-v8a android/libs/armeabi-v7a android/libs/x86 android/libs/x86_64 && cp ../rust_c_net/target/aarch64-linux-android/release/librust_c_net.so android/libs/arm64-v8a/ && cp ../rust_c_net/target/armv7-linux-androideabi/release/librust_c_net.so android/libs/armeabi-v7a/ && cp ../rust_c_net/target/i686-linux-android/release/librust_c_net.so android/libs/x86/ && cp ../rust_c_net/target/x86_64-linux-android/release/librust_c_net.so android/libs/x86_64/ && cp ../rust_c_net/include/NetBindings.hpp cpp/",
@@ -32,7 +34,7 @@
     },
     "dependencies": {
         "eventemitter3": "^5.0.1",
-        "react-native-nitro-buffer": "^0.0.11",
+        "react-native-nitro-buffer": "^0.0.13",
         "readable-stream": "^4.7.0"
     },
     "devDependencies": {
@@ -56,4 +58,4 @@
         "nitrogen/",
         "*.podspec"
     ]
-}
+}

package/react-native-nitro-net.podspec

@@ -34,9 +34,7 @@ Pod::Spec.new do |s|
       "\"$(PODS_TARGET_SRCROOT)/nitrogen/generated/shared\"",
       "\"$(PODS_TARGET_SRCROOT)/nitrogen/generated/ios/c++\"",
       "\"$(PODS_TARGET_SRCROOT)/nitrogen/generated/ios\"",
-      "\"$(PODS_TARGET_SRCROOT)/cpp\"",
-      "\"$(PODS_TARGET_SRCROOT)/ios/Frameworks/RustCNet.xcframework/ios-arm64/RustCNet.framework/Headers\"",
-      "\"$(PODS_TARGET_SRCROOT)/ios/Frameworks/RustCNet.xcframework/ios-arm64_x86_64-simulator/RustCNet.framework/Headers\""
+      "\"$(PODS_TARGET_SRCROOT)/cpp\""
     ],
     "OTHER_SWIFT_FLAGS" => "-cxx-interoperability-mode=default"
   }

package/src/Net.nitro.ts

@@ -19,13 +19,29 @@ export enum NetSocketEvent {
     DRAIN = 5,
     TIMEOUT = 7,
     LOOKUP = 8,
-    DEBUG = 9
+    SESSION = 9,
+    KEYLOG = 10,
+    OCSP = 11
 }
 
 export interface NetSocketDriver extends HybridObject<{ ios: 'swift', android: 'kotlin' }> {
     readonly id: number
     connect(host: string, port: number): void
+    connectTLS(host: string, port: number, serverName?: string, rejectUnauthorized?: boolean): void
+    connectTLSWithContext(host: string, port: number, serverName?: string, rejectUnauthorized?: boolean, secureContextId?: number): void
+    getAuthorizationError(): string | undefined
+    getProtocol(): string | undefined
+    getCipher(): string | undefined
+    getALPN(): string | undefined
+    getPeerCertificateJSON(): string | undefined
+    getEphemeralKeyInfo(): string | undefined
+    getSharedSigalgs(): string | undefined
+    isSessionReused(): boolean
+    getSession(): ArrayBuffer | undefined
+    setSession(session: ArrayBuffer): void
     connectUnix(path: string): void
+    connectUnixTLS(path: string, serverName?: string, rejectUnauthorized?: boolean): void
+    connectUnixTLSWithContext(path: string, serverName?: string, rejectUnauthorized?: boolean, secureContextId?: number): void
     write(data: ArrayBuffer): void
     pause(): void
     resume(): void
@@ -33,6 +49,7 @@ export interface NetSocketDriver extends HybridObject<{ ios: 'swift', android: '
     setTimeout(timeout: number): void
     destroy(): void
     resetAndDestroy(): void
+    enableKeylog(): void
     setNoDelay(enable: boolean): void
     setKeepAlive(enable: boolean, delay: number): void
     getLocalAddress(): string
@@ -50,6 +67,7 @@ export enum NetServerEvent {
 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
+    listenTLS(port: number, secureContextId: number, backlog?: number, ipv6Only?: boolean, reusePort?: boolean): void
     listenUnix(path: string, backlog?: number): void
     /**
      * Listen on an existing file descriptor (handle)
@@ -76,6 +94,14 @@ export interface NetConfig {
 export interface NetDriver extends HybridObject<{ ios: 'swift', android: 'kotlin' }> {
     createSocket(id?: string): NetSocketDriver
     createServer(): NetServerDriver
+    createSecureContext(cert: string, key: string, passphrase?: string): number
+    createEmptySecureContext(): number
+    addCACertToSecureContext(scId: number, ca: string): void
+    addContextToSecureContext(scId: number, hostname: string, cert: string, key: string, passphrase?: string): void
+    setPFXToSecureContext(scId: number, pfx: ArrayBuffer, passphrase?: string): void
+    setOCSPResponseToSecureContext(scId: number, ocsp: ArrayBuffer): void
+    getTicketKeys(scId: number): ArrayBuffer | undefined
+    setTicketKeys(scId: number, keys: ArrayBuffer): void
     /**
      * Initialize the network module with custom configuration
      * Must be called before any other network operations

package/src/index.ts

@@ -165,10 +165,10 @@ export interface SocketOptions extends DuplexOptions {
 }
 
 export class Socket extends Duplex {
-    private _driver: NetSocketDriver | undefined;
+    protected _driver: NetSocketDriver | undefined;
     public connecting: boolean = false; // Changed from private _connecting
-    private _connected: boolean = false;
-    private _hadError: boolean = false; // Added
+    protected _connected: boolean = false;
+    protected _hadError: boolean = false; // Added
     public remoteAddress?: string;
     public remotePort?: number;
     public remoteFamily?: string;
@@ -245,13 +245,14 @@ export class Socket extends Duplex {
         if (!this._driver) return;
         const id = (this._driver as any).id ?? (this._driver as any)._id;
         this._driver.onEvent = (eventType: number, data: ArrayBuffer) => {
+            this.emit('event', eventType, data);
             if (eventType === 3) { // ERROR
                 const msg = new TextDecoder().decode(data);
                 debugLog(`Socket (id: ${id}) NATIVE ERROR: ${msg}`);
             }
-            if (eventType === 9) { // DEBUG
-                const msg = new TextDecoder().decode(data);
-                debugLog(`Socket (id: ${id}) NATIVE DEBUG: ${msg}`);
+            if (eventType === 9) { // SESSION/DEBUG
+                debugLog(`Socket (id: ${id}) NATIVE SESSION EVENT RECEIVED`);
+                this.emit('session', data);
                 return;
             }
             debugLog(`Socket (id: ${id}, localPort: ${this.localPort}) Event TYPE: ${eventType}, data len: ${data?.byteLength}`);
@@ -705,8 +706,8 @@ export class Server extends EventEmitter {
                     this.emit('error', new Error(data ? Buffer.from(data).toString() : 'Unknown server error'));
                     break;
                 case NetServerEvent.DEBUG: {
-                    const msg = data ? Buffer.from(data).toString() : 'Unknown debug message';
-                    debugLog(`Server NATIVE DEBUG: ${msg}`);
+                    debugLog(`Server NATIVE SESSION/DEBUG EVENT RECEIVED`);
+                    this.emit('session', data);
                     break;
                 }
                 case NetServerEvent.CLOSE:
@@ -726,7 +727,6 @@ export class Server extends EventEmitter {
             this.close(() => resolve());
         });
     }
-
     listen(port?: any, host?: any, backlog?: any, callback?: any): this {
         let _port = 0;
         let _host: string | undefined;
@@ -797,6 +797,13 @@ export class Server extends EventEmitter {
     }
 
     close(callback?: (err?: Error) => void): this {
+        // Destroy all active connections first
+        for (const socket of this._sockets) {
+            socket.destroy();
+        }
+        this._sockets.clear();
+        this._connections = 0;
+
         this._driver.close();
         if (callback) this.once('close', callback);
         return this;
@@ -840,6 +847,8 @@ export function createServer(options?: any, connectionListener?: (socket: Socket
     return new Server(options, connectionListener);
 }
 
+export * as tls from './tls'
+
 export {
     isIP,
     isIPv4,