@bbk47/toolbox 1.0.7 → 1.0.8

package/lib/index.js

@@ -6,3 +6,7 @@ exports.uuid = require('./uuid');
 exports.retry = require('./retry');
 exports.deferred = require('./deferred');
 exports.merge = require('./merge');
+exports.timeout = require('./timeout');
+exports.transport = require('./transport');
+exports.proxy = require('./proxy');
+exports.server = require('./server');

package/lib/proxy.js

@@ -0,0 +1,62 @@
+const net = require('net');
+const socks5 = require('./socks5');
+
+exports.createSocks5Proxy = function (cSock, onConnect) {
+    var stage = 'INIT';
+    cSock.on('data', function dataListener(data) {
+        if (stage === 'INIT') {
+            cSock.write('\x05\x00');
+            stage = 'ADDR';
+            return;
+        } else if (stage === 'ADDR') {
+            onConnect(data.slice(3), (err) => {
+                if (!err) {
+                    stage = 'STREAM';
+                    cSock.write('\x05\x00\x00\x01\x00\x00\x00\x00\x00\x00');
+                    cSock.removeAllListeners('data');
+                    cSock.pause(); // for pipe start stream
+                } else {
+                    cSock.destroy();
+                }
+            });
+            return;
+        }
+    });
+
+    cSock.on('error', function (error) {
+        cSock.destroy();
+    });
+};
+
+exports.createConnectProxy = function (cSock, onConnect) {
+    var stage = 'INIT';
+    cSock.on('data', (data) => {
+        if (stage === 'INIT') {
+            const str = data.toString('ascii');
+            const lines = str.split(/\s/g);
+            if (lines[0] !== 'CONNECT') {
+                cSock.destroy();
+                return;
+            }
+            const hoststr = lines[1];
+            const reqhost = hoststr.split(':');
+            const hostname = reqhost[0];
+            const port = Number(reqhost[1]);
+            const socksAddrInfo = socks5.buildSocks5Addr(hostname, port);
+            onConnect(socksAddrInfo, (err) => {
+                if (!err) {
+                    cSock.write(Buffer.from('HTTP/1.1 200 Connection Established\r\n\r\n'));
+                    stage = 'STREAM';
+                    cSock.removeAllListeners('data');
+                    cSock.pause(); // for pipe start stream
+                } else {
+                    cSock.destroy();
+                }
+            });
+        }
+    });
+
+    cSock.on('error', function (error) {
+        cSock.destroy();
+    });
+};

package/lib/server.js

@@ -0,0 +1,61 @@
+const net = require('net');
+const http = require('http');
+const tls = require('tls');
+const http2 = require('http2');
+const url = require('url');
+const WebSocket = require('ws');
+
+exports.createWsServer = function (workPath, handler, httpHandler) {
+    const server = http.createServer(function (req, res) {
+        if (httpHandler) {
+            httpHandler(req, res);
+        }
+    });
+    const wss = new WebSocket.Server({ noServer: true, clientTracking: false });
+    wss.on('connection', function (wsconn) {
+        handler(wsconn);
+    });
+    server.on('upgrade', function (request, socket, head) {
+        const pathname = url.parse(request.url).pathname;
+        if (pathname === workPath) {
+            wss.handleUpgrade(request, socket, head, function done(ws) {
+                wss.emit('connection', ws, request);
+            });
+        } else {
+            socket.destroy();
+        }
+    });
+    return server;
+};
+
+exports.createHttp2Server = function (tlsOpts, workPath, handler, httpHandler) {
+    const http2Opts = Object.assign({ allowHTTP1: true }, tlsOpts);
+    const server = http2.createSecureServer(http2Opts, function (req, res) {
+        if (httpHandler) {
+            httpHandler(req, res);
+        }
+    });
+    server.on('stream', function (stream, headers) {
+        const path = headers[':path'];
+        if (path === workPath) {
+            handler(stream);
+        } else {
+            stream.destroy();
+        }
+    });
+    return server;
+};
+
+exports.createTcpServer = function (handler) {
+    const server = net.createServer(function (conn) {
+        handler(conn);
+    });
+    return server;
+};
+
+exports.createTlsServer = function (tlsOpts, handler) {
+    const server = tls.createServer(tlsOpts, function (conn) {
+        handler(conn);
+    });
+    return server;
+};

package/lib/timeout.js

@@ -0,0 +1,3 @@
+const timeoutPromise = (time) => new Promise((resolve) => setTimeout(() => resolve('timeout:' + time), time));
+
+exports.timeoutPromise = timeoutPromise;

package/lib/transport/creater.js

@@ -0,0 +1,64 @@
+const WebSocket = require('ws');
+const net = require('net');
+const http2 = require('http2');
+const tls = require('tls');
+
+const Transport = require('./transport');
+
+exports.createWebsocketTransport = function (params, onOpen) {
+    let tunnelWsUrl = `${params.secure ? 'wss' : 'ws'}://${params.host}:${params.port}${params.path}`;
+    const ws = new WebSocket(tunnelWsUrl, { perMessageDeflate: false, handshakeTimeout: 3000 });
+    const ts = new Transport({ type: 'ws', conn: ws });
+    ws.on('open', onOpen);
+    return ts;
+};
+
+exports.createHttp2Transport = function (params, onOpen) {
+    const http2Url = `https://${params.host}:${params.port}`;
+    const client = http2.connect(http2Url, {
+        rejectUnauthorized: false,
+        requestCert: true,
+    });
+    const http2stream = client.request({
+        ':method': 'POST',
+        ':path': params.path || '/',
+        'Content-Type': 'octet-stream',
+    });
+    http2stream.on('response', onOpen);
+    const ts = new Transport({ type: 'h2', conn: http2stream });
+    return ts;
+};
+
+exports.createTlsTransport = function (params, onOpen) {
+    const tlsOpts = {
+        rejectUnauthorized: false,
+        host: params.host,
+        port: params.port,
+    };
+    const tlsConn = tls.connect(tlsOpts, function () {
+        onOpen();
+    });
+    const ts = new Transport({ type: 'tls', conn: tlsConn });
+    return ts;
+};
+
+exports.createTcpTransport = function (params, onOpen) {
+    const socket = new net.Socket();
+    socket.connect(params.port, params.host, function () {
+        onOpen();
+    });
+    return new Transport({ type: 'tcp', conn: socket });
+};
+
+exports.createUnixsocketTransport = function (params, onOpen) {
+    const socket = new net.Socket();
+    socket.connect(params.path, function () {
+        onOpen();
+    });
+    const ts = new Transport({ type: 'domainsocket', conn: socket });
+    return ts;
+};
+
+exports.wrapSocket = function (type, conn) {
+    return new Transport({ type, conn });
+};

package/lib/transport/helper.js

@@ -0,0 +1,62 @@
+const WebSocket = require('ws');
+
+function bindStreamSocket(stream, onData, onError, onClose) {
+    var buffcache = Buffer.from([]);
+    stream.on('data', function (data) {
+        buffcache = Buffer.concat([buffcache, data]);
+        var datalen = 0;
+        var pack;
+        while (true) {
+            if (buffcache.length <= 2) {
+                return;
+            }
+            datalen = buffcache[0] * 256 + buffcache[1];
+            if (buffcache.length < datalen + 2) {
+                return;
+            }
+            pack = buffcache.slice(2, datalen + 2);
+            buffcache = buffcache.slice(datalen + 2);
+            onData(pack);
+        }
+    });
+    stream.on('close', function (code) {
+        onClose(code);
+    });
+    stream.on('error', function (err) {
+        stream.destroy();
+        onError(err);
+    });
+}
+
+function bindWebsocket(ws, onData, onError, onClose) {
+    ws.on('message', onData);
+    ws.on('close', (code) => {
+        onClose(code);
+    });
+    ws.on('error', (err) => {
+        ws.close();
+        onError(err);
+    });
+}
+
+function tcpsocketSend(socket, data) {
+    var datalen = data.length;
+    if (socket.writable) {
+        socket.write(Buffer.concat([Buffer.from([datalen >> 8, datalen % 256]), data]));
+    } else {
+        throw Error('socket cannot writeable!');
+    }
+}
+
+function websocketSend(ws, data) {
+    if (ws.readyState === WebSocket.OPEN) {
+        ws.send(data, { binary: true });
+    } else {
+        throw Error('ws socket not open!' + ws.readyState);
+    }
+}
+
+exports.websocketSend = websocketSend;
+exports.tcpsocketSend = tcpsocketSend;
+exports.bindStreamSocket = bindStreamSocket;
+exports.bindWebsocket = bindWebsocket;

package/lib/transport/index.js

@@ -0,0 +1,11 @@
+const Transport = require('./transport');
+const creater = require('./creater');
+const helper = require('./helper');
+
+exports.Transport = Transport;
+exports.creater = creater;
+exports.helper = helper;
+
+exports.wrapSocket = function (type, conn) {
+    return new Transport({ type, conn });
+};

package/lib/transport/transport.js

@@ -0,0 +1,38 @@
+const { websocketSend, tcpsocketSend, bindWebsocket, bindStreamSocket } = require('./helper');
+
+class Transport {
+    constructor(opts) {
+        this.type = opts.type;
+        this.conn = opts.conn;
+    }
+
+    sendPacket(binarydata) {
+        if (this.type === 'ws') {
+            websocketSend(this.conn, binarydata);
+        } else {
+            tcpsocketSend(this.conn, binarydata);
+        }
+    }
+
+    bindEvents(onData, onError, onClose) {
+        if (this.type === 'ws') {
+            bindWebsocket(this.conn, onData, onError, onClose);
+        } else {
+            bindStreamSocket(this.conn, onData, onError, onClose);
+        }
+    }
+
+    close() {
+        try {
+            if (this.type === 'ws' || this.type === 'h2') {
+                this.conn.close();
+            } else {
+                this.conn.destroy();
+            }
+        } catch (err) {
+            // ignore
+        }
+    }
+}
+
+module.exports = Transport;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bbk47/toolbox",
-    "version": "1.0.7",
+    "version": "1.0.8",
     "description": "toolbox for bbk",
     "main": "lib/index.js",
     "scripts": {
@@ -17,7 +17,8 @@
     },
     "homepage": "https://github.com/bbk47/toolboxjs#readme",
     "dependencies": {
-        "date-format": "^3.0.0"
+        "date-format": "^3.0.0",
+        "ws": "2.3.x"
     },
     "devDependencies": {
         "mocha": "^5.2.0"