js-tcp-tunnel 1.1.0 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-tcp-tunnel",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "js tcp tunnel",
   "main": "index.js",
   "type": "module",

package/src/lib.js

@@ -6,9 +6,10 @@ import https from 'node:https'
 import { ReadableStream, TransformStream, WritableStream } from 'node:stream/web'
 
 /**
+ * @import { ReadableStreamDefaultReader, WritableStreamDefaultWriter } from 'node:stream/web'
  * @import {WebSocketServer} from 'ws'
  * @import Router from '@koa/router'
- * @import {SocketChannel, TCP_TUNNEL_DATA, TUNNEL_TCP_CLIENT_HELPER, TUNNEL_TCP_DATA_CONNECT, TUNNEL_TCP_DATA_LISTEN, TUNNEL_TCP_DATA_PINGPONG, TUNNEL_TCP_SERVER_HELPER, TunnelTcpClientHelperParam, TunnelTcpServerHelperParam} from './types.js'
+ * @import {ConnectParam, ListenParam, SocketChannel, TCP_TUNNEL_DATA, TUNNEL_TCP_DATA_CONNECT, TUNNEL_TCP_DATA_LISTEN, TUNNEL_TCP_DATA_PINGPONG, TunnelTcpClientHelperParam, TunnelTcpServerHelperParam} from './types.js'
  */
 
 const DEBUG_TUNNEL_TCP = false
@@ -307,7 +308,6 @@ export function printTcpTunnelData(data) {
         [TUNNEL_TCP_TYPE_CLOSE]: 'TUNNEL_TCP_TYPE_CLOSE     ',
         [TUNNEL_TCP_TYPE_PING]: 'TUNNEL_TCP_TYPE_PING      ',
         [TUNNEL_TCP_TYPE_PONG]: 'TUNNEL_TCP_TYPE_PONG      ',
-        [TUNNEL_TCP_TYPE_ACK]: 'TUNNEL_TCP_TYPE_ACK       ',
     }[data.type]} recv: ${(tcpTunnelDataRecv)} send: ${(tcpTunnelDataSend)} size:${data.buffer.length}`
 }
 
@@ -420,7 +420,6 @@ export const TUNNEL_TCP_TYPE_ERROR = 0x8117f762
 export const TUNNEL_TCP_TYPE_CLOSE = 0x72fd6470
 export const TUNNEL_TCP_TYPE_PING = 0x4768e1ba
 export const TUNNEL_TCP_TYPE_PONG = 0x106f43fb
-export const TUNNEL_TCP_TYPE_ACK = 0xc5870539
 
 /**
  * @param {TCP_TUNNEL_DATA} box
@@ -531,46 +530,15 @@ export function createTimeBufferedTransformStream(bufferTime) {
 export function pipeSocketDataWithChannel(channelMap, channelId, encodeWriter) {
     let channel = channelMap.get(channelId)
     let socket = channel.socket
-    let signal = Promise_withResolvers()
-    signal.resolve()
     let sendPackSize = 0
-    let remoteRecvPackSize = 0
-    channel.notify = (size) => {
-        remoteRecvPackSize = size
-        signal.resolve()
-    }
     let [clientKey, clientIv] = channel.key_iv
     let bufferedTransform = createTimeBufferedTransformStream(50)
-    let backPressureTimer = null
     Readable.toWeb(socket).pipeThrough(bufferedTransform).pipeTo(new WritableStream({
         /**
          * @param {Uint8Array<ArrayBuffer>} chunk
          */
         async write(chunk) {
             const buffer = await encrypt(chunk, clientKey, clientIv)
-            let bufferPackSize = sendPackSize - remoteRecvPackSize
-            if (DEBUG_TUNNEL_TCP) {
-                console.warn('bufferPackSize:', bufferPackSize)
-            }
-            if (bufferPackSize > 10) {
-                signal.resolve()
-                signal = Promise_withResolvers()
-                const s = signal
-                backPressureTimer = setTimeout(() => {
-                    s.resolve()
-                    console.error('pipeSocketDataWithChannel timeout close channel')
-                    sendPackSize = 0
-                    this.close()
-                }, 10_000).unref()
-                if (DEBUG_TUNNEL_TCP) {
-                    console.info('stop wait signal', ' sendPackSize:', sendPackSize, ' recvPackSize:', remoteRecvPackSize, ' bufferPackSize:', bufferPackSize)
-                }
-            }
-            await signal.promise
-            if (backPressureTimer) {
-                clearTimeout(backPressureTimer)
-                backPressureTimer = null
-            }
             await encodeWriter.write(buildTcpTunnelData({
                 type: TUNNEL_TCP_TYPE_DATA,
                 srcId: channel.srcId,
@@ -710,7 +678,6 @@ async function dispatchClientBufferData(param, setup, listenKeyParamMap, channel
             dstChannel: data.srcChannel,
             recvPackSize: 0,
             key_iv,
-            notify: null,
         }
         channelMap.set(channelId, channel)
         connectSocket.on('connect', () => {
@@ -805,43 +772,10 @@ async function dispatchClientBufferData(param, setup, listenKeyParamMap, channel
                 await channel.writer.write(buffer)
             }
             channel.recvPackSize++
-            await sendAck(encodeWriter, channel)
         } else {
             await closeRemoteChannel(encodeWriter, data)
         }
     }
-    if (data.type == TUNNEL_TCP_TYPE_ACK) {
-        let channelId = data.dstChannel
-        let channel = channelMap.get(channelId)
-        if (channel) {
-            channel.srcId = data.dstId
-            channel.dstId = data.srcId
-            let size = readUInt32LE(data.buffer, 0)
-            channel.notify(size)
-        } else {
-            await closeRemoteChannel(encodeWriter, data)
-        }
-    }
-}
-
-/**
- * @param {WritableStreamDefaultWriter<Uint8Array>} encodeWriter
- * @param {SocketChannel} channel
- */
-export async function sendAck(encodeWriter, channel) {
-    if (channel.recvPackSize % 5 != 0) {
-        return
-    }
-    let sizeBuffer = new Uint8Array(4)
-    writeUInt32LE(sizeBuffer, channel.recvPackSize, 0)
-    await encodeWriter.write(buildTcpTunnelData({
-        type: TUNNEL_TCP_TYPE_ACK,
-        srcId: channel.srcId,
-        srcChannel: channel.srcChannel,
-        dstId: channel.dstId,
-        dstChannel: channel.dstChannel,
-        buffer: sizeBuffer,
-    }))
 }
 
 /**
@@ -871,6 +805,9 @@ export function createTunnelTcpServerHelper(param) {
     if (DEBUG_TUNNEL_TCP) {
         let writer = encodeWriter
         encodeWriter = new WritableStream({
+            /**
+             * @param {Uint8Array<ArrayBuffer>} chunk
+             */
             async write(chunk) {
                 tcpTunnelDataSend += chunk.length
                 let data = parseTcpTunnelData(chunk)
@@ -881,6 +818,9 @@ export function createTunnelTcpServerHelper(param) {
     }
 
     decode.readable.pipeTo(new WritableStream({
+        /**
+         * @param {Uint8Array<ArrayBuffer>} chunk
+         */
         async write(chunk) {
             try {
                 await dispatchServerBufferData(param, encodeWriter, chunk)
@@ -901,66 +841,115 @@ export function createTunnelTcpServerHelper(param) {
         buffer: new Uint8Array(0),
     }))
 
-    /** @type{TUNNEL_TCP_SERVER_HELPER} */
-    let helper = { readable: encode.readable, writable: decode.writable, reader: null, writer: null, dstId: id, }
-    return helper
+    return new TunnelTcpServerHelper(id, encode, decode)
 }
 
 /**
  * @param {TunnelTcpClientHelperParam} param 
  */
 export function createTunnelTcpClientHelper(param) {
-    /** @type{Map<number,SocketChannel>} */
-    let channelMap = new Map()
-
-    /** @type{Map<string,{host:string;port:number;key_iv:[CryptoKey, Uint8Array<ArrayBuffer>]}>} */
-    let listenKeyParamMap = new Map()
-
     let server_key_iv = buildKeyIv(param.serverKey, 10)
-
-    param.signal.addEventListener('abort', () => {
-        channelMap.values().forEach(o => {
-            o.socket.destroy()
-        })
-    })
-
     let encode = createEncodeStream(server_key_iv)
     let decode = createDecodeStream(server_key_iv)
-    let encodeWriter = encode.writable.getWriter()
-    if (DEBUG_TUNNEL_TCP) {
-        let writer = encodeWriter
-        encodeWriter = new WritableStream({
-            async write(chunk) {
-                tcpTunnelDataSend += chunk.length
-                let data = parseTcpTunnelData(chunk)
-                console.info('send', printTcpTunnelData(data))
-                writer.write(chunk)
-            }
-        }).getWriter()
+    return new TunnelTcpClientHelper(param, encode, decode)
+}
+
+export class TunnelTcpServerHelper {
+    dstId = 0
+    /** @type{ReadableStream<Uint8Array<ArrayBuffer>>} */
+    readable = null
+    /** @type{WritableStream<Uint8Array<ArrayBuffer>>} */
+    writable = null
+    /** @type{ReadableStreamDefaultReader<Uint8Array<ArrayBuffer>>} */
+    reader = null
+    /** @type{WritableStreamDefaultWriter<Uint8Array<ArrayBuffer>>} */
+    writer = null
+    /**
+     * @param {number} id
+     * @param {TransformStream<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>} encode
+     * @param {TransformStream<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>} decode
+     */
+    constructor(id, encode, decode) {
+        this.dstId = id
+        this.readable = encode.readable
+        this.writable = decode.writable
     }
+}
 
-    decode.readable.pipeTo(new WritableStream({
-        /**
-         * @param {Uint8Array<ArrayBuffer>} buffer
-         */
-        async write(buffer) {
-            try {
-                await dispatchClientBufferData(param, setup, listenKeyParamMap, channelMap, encodeWriter, buffer)
-            } catch (error) {
-                console.error('decode.readable.pipeTo.write', error.message)
-            }
+export class TunnelTcpClientHelper {
+    /** @type{ReadableStream<Uint8Array<ArrayBuffer>>} */
+    readable = null
+    /** @type{WritableStream<Uint8Array<ArrayBuffer>>} */
+    writable = null
+    /** @type{ReadableStreamDefaultReader<Uint8Array<ArrayBuffer>>} */
+    reader = null
+    /** @type{WritableStreamDefaultWriter<Uint8Array<ArrayBuffer>>} */
+    writer = null
+    /** @type{TunnelTcpClientHelperParam} */
+    param = null
+
+    /** @type{Map<number,SocketChannel>} */
+    channelMap = new Map()
+    /** @type{Map<string,{host:string;port:number;key_iv:[CryptoKey, Uint8Array<ArrayBuffer>]}>} */
+    listenKeyParamMap = new Map()
+    /** @type{Set<ListenParam>} */
+    listenParams = new Set()
+    /** @type{WritableStreamDefaultWriter<Uint8Array<ArrayBuffer>>} */
+    encodeWriter = null
+
+    /**
+     * @param {TunnelTcpClientHelperParam} param
+     * @param {TransformStream<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>} encode
+     * @param {TransformStream<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>} decode
+     */
+    constructor(param, encode, decode) {
+        this.param = param
+        this.readable = encode.readable
+        this.writable = decode.writable
+
+        param.signal.addEventListener('abort', () => {
+            this.channelMap.values().forEach(o => {
+                o.socket.destroy()
+            })
+        })
+
+        this.encodeWriter = encode.writable.getWriter()
+        if (DEBUG_TUNNEL_TCP) {
+            let writer = this.encodeWriter
+            this.encodeWriter = new WritableStream({
+                async write(chunk) {
+                    tcpTunnelDataSend += chunk.length
+                    let data = parseTcpTunnelData(chunk)
+                    console.info('send', printTcpTunnelData(data))
+                    writer.write(chunk)
+                }
+            }).getWriter()
         }
-    }))
 
-    let outParam = param
-    let listenParams = new Set()
+        const thiz = this
+        decode.readable.pipeTo(new WritableStream({
+            /**
+             * @param {Uint8Array<ArrayBuffer>} buffer
+             */
+            async write(buffer) {
+                try {
+                    await Promise.race([
+                        sleep(5000),
+                        dispatchClientBufferData(param, () => thiz.setup(), thiz.listenKeyParamMap, thiz.channelMap, thiz.encodeWriter, buffer),
+                    ])
+                } catch (error) {
+                    console.error('decode.readable.pipeTo.write', error.message)
+                }
+            }
+        }))
+    }
 
-    async function setup() {
-        channelMap.forEach((channel) => {
-            channel.srcId = param.clientDataId
+    async setup() {
+        this.channelMap.forEach((channel) => {
+            channel.srcId = this.param.clientDataId
             /** @type{TUNNEL_TCP_DATA_PINGPONG} */
             let pingData = { time: Date.now() }
-            encodeWriter.write(buildTcpTunnelData({
+            this.encodeWriter.write(buildTcpTunnelData({
                 type: TUNNEL_TCP_TYPE_PING,
                 srcId: channel.srcId,
                 srcChannel: channel.srcChannel,
@@ -969,34 +958,29 @@ export function createTunnelTcpClientHelper(param) {
                 buffer: Uint8Array_from(JSON.stringify(pingData)),
             }))
         })
-        for (const param of listenParams) {
-            await listen(param)
+        for (const param of this.listenParams) {
+            await this.listen(param)
         }
     }
 
     /**
-     * @param {{ 
-     * clientKey?:string;
-     * tunnelKey:string;
-     * host?:string;
-     * port:number; 
-     * }} param
+     * @param {ListenParam} param
      */
-    async function listen(param) {
-        listenParams.add(param)
-        console.info('listenParams size', listenParams.size)
-        if (outParam.clientDataId < 1) {
+    async listen(param) {
+        this.listenParams.add(param)
+        console.info('listenParams size', this.listenParams.size)
+        if (this.param.clientDataId < 1) {
             console.info('skip send listen dataId == 0')
             return
         }
         let key = sha512(param.tunnelKey)
         let key_iv = await buildKeyIv(param.clientKey, 10)
-        listenKeyParamMap.set(key, { host: param.host, port: param.port, key_iv })
+        this.listenKeyParamMap.set(key, { host: param.host, port: param.port, key_iv })
         /** @type{TUNNEL_TCP_DATA_LISTEN} */
         let listenData = { key: key }
-        await encodeWriter.write(buildTcpTunnelData({
+        await this.encodeWriter.write(buildTcpTunnelData({
             type: TUNNEL_TCP_TYPE_LISTEN,
-            srcId: outParam.clientDataId,
+            srcId: this.param.clientDataId,
             srcChannel: 0,
             dstId: 0,
             dstChannel: 0,
@@ -1005,19 +989,15 @@ export function createTunnelTcpClientHelper(param) {
     }
 
     /**
-     * @param {{ 
-     * clientKey?:string;
-     * tunnelKey: string;
-     * port: number;
-     * }} param
+     * @param {ConnectParam} param
      */
-    async function connect(param) {
+    async connect(param) {
         let key_iv = await buildKeyIv(param.clientKey, 10)
         let server = net.createServer((socket) => {
-            let channelId = outParam.uniqueId++
+            let channelId = this.param.uniqueId++
             socket.on('error', (err) => {
                 console.error('createTunnelTcpClientHelper on socket error', err.message)
-                channelMap.delete(channelId)
+                this.channelMap.delete(channelId)
             })
             /** @type{TUNNEL_TCP_DATA_CONNECT} */
             let connectData = { key: sha512(param.tunnelKey) }
@@ -1025,16 +1005,15 @@ export function createTunnelTcpClientHelper(param) {
             let channel = {
                 writer: Writable.toWeb(socket).getWriter(),
                 socket,
-                srcId: outParam.clientDataId,
+                srcId: this.param.clientDataId,
                 srcChannel: channelId,
                 dstId: 0,
                 dstChannel: 0,
                 recvPackSize: 0,
                 key_iv,
-                notify: null,
             }
-            channelMap.set(channelId, channel)
-            encodeWriter.write(buildTcpTunnelData({
+            this.channelMap.set(channelId, channel)
+            this.encodeWriter.write(buildTcpTunnelData({
                 type: TUNNEL_TCP_TYPE_CONNECT,
                 srcId: channel.srcId,
                 srcChannel: channel.srcChannel,
@@ -1046,13 +1025,8 @@ export function createTunnelTcpClientHelper(param) {
         server.on('error', (err) => {
             console.error('createTunnelTcpClientHelper connect on server error', err.message)
         })
-        outParam.signal.addEventListener('abort', () => { server.close() })
+        this.param.signal.addEventListener('abort', () => { server.close() })
     }
-
-    /** @type{TUNNEL_TCP_CLIENT_HELPER} */
-    let helper = { readable: encode.readable, writable: decode.writable, reader: null, writer: null, listen, connect, param: outParam }
-    return helper
-
 }
 
 
@@ -1246,7 +1220,10 @@ export function createTunnelTcpClientWebSocket(param) {
                 await signal.promise
             }
             if (!param.signal.aborted) {
-                await socketWriter.write(chunk)
+                await Promise.race([
+                    sleep(5000),
+                    socketWriter.write(chunk),
+                ])
             }
         }
     }))

package/src/lib.test.js

@@ -645,8 +645,8 @@ test('terminal-server', async () => {
 
     await sleep(20_000)
 
-    strictEqual(socketCreateCount, 2)
-    strictEqual(recvCount, 14)
+    strictEqual(socketCreateCount, 1)
+    strictEqual(recvCount, 25)
 
     console.info('over!')
 })

package/src/types.ts

@@ -58,34 +58,19 @@ export type TUNNEL_TCP_SERVER = {
     encodeWriter: WritableStreamDefaultWriter<Uint8Array>
 }
 
-export type TUNNEL_TCP_SERVER_HELPER = {
-    readable: ReadableStream<Uint8Array<ArrayBuffer>>
-    writable: WritableStream<Uint8Array<ArrayBuffer>>
-    reader: ReadableStreamDefaultReader<Uint8Array<ArrayBuffer>>
-    writer: WritableStreamDefaultWriter<Uint8Array<ArrayBuffer>>
-    dstId: number
+export type ListenParam = {
+    clientKey?: string;
+    tunnelKey: string;
+    host?: string;
+    port: number;
 }
 
-export type TUNNEL_TCP_CLIENT_HELPER = {
-    readable: ReadableStream<Uint8Array<ArrayBuffer>>
-    writable: WritableStream<Uint8Array<ArrayBuffer>>
-    reader: ReadableStreamDefaultReader<Uint8Array<ArrayBuffer>>
-    writer: WritableStreamDefaultWriter<Uint8Array<ArrayBuffer>>
-    param: TunnelTcpClientHelperParam
-    listen: (param: {
-        clientKey?: string
-        tunnelKey: string
-        host?: string
-        port: number
-    }) => Promise<void>
-    connect: (param: {
-        clientKey?: string
-        tunnelKey: string
-        port: number
-    }) => Promise<void>
+export type ConnectParam = {
+    clientKey?: string;
+    tunnelKey: string;
+    port: number;
 }
 
-
 export type SocketChannel = {
     writer: WritableStreamDefaultWriter<Uint8Array<ArrayBuffer>>
     socket: net.Socket
@@ -93,7 +78,6 @@ export type SocketChannel = {
     dstId: number
     srcChannel: number
     dstChannel: number
-    notify: (size: number) => void
     recvPackSize: number
     key_iv: [CryptoKey, Uint8Array<ArrayBuffer>]
 }