@react-native-ohos/react-native-tcp-socket 6.2.1-rc.1

package/src/TLSServer.js

@@ -0,0 +1,70 @@
+'use strict';
+
+import { Image } from 'react-native';
+import Server from './Server';
+import TLSSocket from './TLSSocket';
+
+/**
+ * @typedef {object} TLSServerOptions
+ * @property {any} keystore
+ *
+ * @extends {Server}
+ */
+export default class TLSServer extends Server {
+    /**
+     * @param {(socket: TLSSocket) => void} [secureConnectionListener] Automatically set as a listener for the `'secureConnection'` event.
+     */
+    constructor(secureConnectionListener) {
+        super();
+        if (secureConnectionListener) this.on('secureConnection', secureConnectionListener);
+        this._registerTLSEvents();
+    }
+
+    /**
+     * @param {TLSServerOptions} options TLS server options
+     */
+    setSecureContext(options) {
+        /** @private */
+        this._options = { ...options };
+        this._options.keystore = Image.resolveAssetSource(this._options.keystore).uri;
+    }
+
+    /**
+     * Start a server listening for connections.
+     *
+     * This function is asynchronous. When the server starts listening, the `'listening'` event will be emitted.
+     * The last parameter `callback` will be added as a listener for the `'listening'` event.
+     *
+     * The `server.listen()` method can be called again if and only if there was an error during the first
+     * `server.listen()` call or `server.close()` has been called. Otherwise, an `ERR_SERVER_ALREADY_LISTEN`
+     * error will be thrown.
+     *
+     * @param {{ port: number; host: string; reuseAddress?: boolean}} options
+     * @param {() => void} [callback]
+     * @override
+     */
+    listen(options, callback) {
+        const newOptions = { ...options };
+        // @ts-ignore
+        newOptions['tls'] = this._options;
+        return super.listen(newOptions, callback);
+    }
+
+    /**
+     * @private
+     */
+    _registerTLSEvents() {
+        this._secureConnectionListener = this._eventEmitter.addListener(
+            'secureConnection',
+            (evt) => {
+                if (evt.id !== this._id) return;
+                const standardSocket = this._buildSocket(evt.info);
+                standardSocket._unregisterEvents();
+                const tlsSocket = new TLSSocket(standardSocket);
+                this._addConnection(tlsSocket);
+                this.emit('connection', standardSocket);
+                this.emit('secureConnection', tlsSocket);
+            }
+        );
+    }
+}

package/src/TLSSocket.js

@@ -0,0 +1,93 @@
+'use strict';
+
+import { Image, NativeModules, TurboModuleRegistry } from 'react-native';
+const Sockets = TurboModuleRegistry ? TurboModuleRegistry.get('TcpSocketModule') : NativeModules.TcpSockets;
+import Socket from './Socket';
+
+/**
+ * @typedef {object} TLSSocketOptions
+ * @property {any} [ca]
+ * @property {any} [key]
+ * @property {any} [cert]
+ * @property {string} [androidKeyStore]
+ * @property {string} [certAlias]
+ * @property {string} [keyAlias]
+ * @property {string[]} [resolvedKeys]
+ *
+ * @extends {Socket}
+ */
+export default class TLSSocket extends Socket {
+    /**
+     * @param {Socket} socket Any instance of `Socket`.
+     * @param {TLSSocketOptions} [options] Options for the TLS socket.
+     */
+    constructor(socket, options = {}) {
+        super();
+        /** @private */
+        this._options = { ...options };
+        TLSSocket.resolveAssetIfNeeded(this._options, 'ca');
+        TLSSocket.resolveAssetIfNeeded(this._options, 'key');
+        TLSSocket.resolveAssetIfNeeded(this._options, 'cert');
+
+        /** @private */
+        this._socket = socket;
+        // @ts-ignore
+        this._setId(this._socket._id);
+        this._startTLS();
+        if (socket.pending || socket.connecting) socket.once('connect', () => this._initialize());
+        else this._initialize();
+    }
+
+    /**
+     * @private
+     */
+    _initialize() {
+        // Avoid calling twice destroy() if an error occurs
+        this._socket._errorListener?.remove();
+        this.on('error', (error) => this._socket.emit('error', error));
+        this._setConnected({
+            // @ts-ignore
+            localAddress: this._socket.localAddress,
+            // @ts-ignore
+            localPort: this._socket.localPort,
+            // @ts-ignore
+            remoteAddress: this._socket.remoteAddress,
+            // @ts-ignore
+            remotePort: this._socket.remotePort,
+            // @ts-ignore
+            remoteFamily: this._socket.remoteFamily,
+        });
+    }
+
+    /**
+     * @private
+     */
+    _startTLS() {
+        Sockets.startTLS(this._id, this._options);
+    }
+
+    getCertificate() {
+        return Sockets.getCertificate(this._id);
+    }
+
+    getPeerCertificate() {
+        return Sockets.getPeerCertificate(this._id);
+    }
+
+    /**
+     * @private
+     * Resolves the asset source if necessary and registers the resolved key.
+     * @param {TLSSocketOptions} options The options object containing the source to be resolved.
+     * @param {'ca' | 'key' | 'cert'} key The key name being resolved.
+     */
+    static resolveAssetIfNeeded(options, key) {
+        const source = options[key];
+        if (source && typeof source !== 'string') {
+            if (!options.resolvedKeys) {
+                options.resolvedKeys = [];
+            }
+            options.resolvedKeys.push(key);
+            options[key] = Image.resolveAssetSource(source).uri;
+        }
+    }
+}

package/src/TcpSocketModule.ts

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+import type { TurboModule } from 'react-native/Libraries/TurboModule/RCTExport';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+
+    listen(cId: number, options: Object): void;
+
+    close(cid: number): void;
+
+    destroy(cid: number): void;
+
+    end(cid: number): void;
+
+    pause(cid: number): void;
+
+    resume(cid: number): void;
+
+    connect(cId: number, host: string, port: number, options: Object): void;
+
+    startTLS(cId: number, tlsOptions: Object): void;
+
+    write(cId: number, base64String: string, msgId: number): void;
+
+    setNoDelay(cId: number, noDelay: boolean): void;
+
+    setKeepAlive(cId: number, enable: boolean, initialDelay: number): void;
+
+    getPeerCertificate(cId: number): Promise<string>;
+
+    getCertificate(cId: number): Promise<string>;
+}
+
+
+export default TurboModuleRegistry.get<Spec>('TcpSocketModule') as Spec | null;

package/src/index.js

@@ -0,0 +1,131 @@
+'use strict';
+
+import Socket from './Socket';
+import Server from './Server';
+import TLSServer from './TLSServer';
+import TLSSocket from './TLSSocket';
+
+/**
+ * @param {(socket: Socket) => void} connectionListener
+ * @returns {Server}
+ */
+function createServer(connectionListener) {
+    return new Server(connectionListener);
+}
+
+/**
+ * @param {import('./TLSServer').TLSServerOptions} options
+ * @param {(socket: TLSSocket) => void} connectionListener
+ * @returns {TLSServer}
+ */
+function createTLSServer(options, connectionListener) {
+    const server = new TLSServer(connectionListener);
+    server.setSecureContext(options);
+    return server;
+}
+
+/**
+ * The `callback` function, if specified, will be added as a listener for the `'secureConnect'` event.
+ *
+ * @param {import('./TLSSocket').TLSSocketOptions & import('./Socket').ConnectionOptions} options
+ * @param {() => void} [callback]
+ * @returns {TLSSocket}
+ */
+function connectTLS(options, callback) {
+    const socket = new Socket();
+    const tlsSocket = new TLSSocket(socket, options);
+    socket.once('connect', () => tlsSocket.emit('secureConnect'));
+    if (callback) tlsSocket.once('secureConnect', callback);
+    socket.connect(options);
+    return tlsSocket;
+}
+
+/**
+ * @param {import('./Socket').ConnectionOptions} options
+ * @param {() => void} callback
+ * @returns {Socket}
+ */
+function createConnection(options, callback) {
+    const tcpSocket = new Socket();
+    return tcpSocket.connect(options, callback);
+}
+
+// IPv4 Segment
+const v4Seg = '(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])';
+const v4Str = `(${v4Seg}[.]){3}${v4Seg}`;
+const IPv4Reg = new RegExp(`^${v4Str}$`);
+
+// IPv6 Segment
+const v6Seg = '(?:[0-9a-fA-F]{1,4})';
+const IPv6Reg = new RegExp(
+    '^(' +
+        `(?:${v6Seg}:){7}(?:${v6Seg}|:)|` +
+        `(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|` +
+        `(?:${v6Seg}:){5}(?::${v4Str}|(:${v6Seg}){1,2}|:)|` +
+        `(?:${v6Seg}:){4}(?:(:${v6Seg}){0,1}:${v4Str}|(:${v6Seg}){1,3}|:)|` +
+        `(?:${v6Seg}:){3}(?:(:${v6Seg}){0,2}:${v4Str}|(:${v6Seg}){1,4}|:)|` +
+        `(?:${v6Seg}:){2}(?:(:${v6Seg}){0,3}:${v4Str}|(:${v6Seg}){1,5}|:)|` +
+        `(?:${v6Seg}:){1}(?:(:${v6Seg}){0,4}:${v4Str}|(:${v6Seg}){1,6}|:)|` +
+        `(?::((?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:))` +
+        ')(%[0-9a-zA-Z-.:]{1,})?$'
+);
+
+/**
+ * Returns `true` if input is a version 4 IP address, otherwise returns `false`.
+ *
+ * @param {string} input
+ */
+function isIPv4(input) {
+    return IPv4Reg.test(input);
+}
+
+/**
+ * Returns `true` if input is a version 6 IP address, otherwise returns `false`.
+ *
+ * @param {string} input
+ */
+function isIPv6(input) {
+    return IPv6Reg.test(input);
+}
+
+/**
+ * Tests if input is an IP address. Returns `0` for invalid strings, returns `4` for IP version 4 addresses, and returns `6` for IP version 6 addresses.
+ *
+ * @param {string} input
+ */
+function isIP(input) {
+    if (isIPv4(input)) return 4;
+    else if (isIPv6(input)) return 6;
+    return 0;
+}
+
+export default {
+    connect: createConnection,
+    createServer,
+    createConnection,
+    createTLSServer,
+    connectTLS,
+    isIP,
+    isIPv4,
+    isIPv6,
+    Server,
+    Socket,
+    TLSServer,
+    TLSSocket,
+};
+
+// @ts-ignore
+module.exports = {
+    connect: createConnection,
+    createServer,
+    createConnection,
+    createTLSServer,
+    connectTLS,
+    isIP,
+    isIPv4,
+    isIPv6,
+    Server,
+    Socket,
+    TLSServer,
+    TLSSocket,
+};