@encharm/cws 4.8.3 → 4.10.0

package/dist/index.d.ts

@@ -32,4 +32,4 @@ export declare type ServerConfigs = {
 export { WebSocket } from './client';
 export { WebSocketServer } from './server';
 export declare const secureProtocol: string;
-export { zlibBackend } from './shared';
+export { zlibBackend, sendThread } from './shared';

package/dist/index.js

@@ -8,3 +8,4 @@ Object.defineProperty(exports, "WebSocketServer", { enumerable: true, get: funct
 exports.secureProtocol = 'TLSv1_2_method';
 var shared_1 = require("./shared");
 Object.defineProperty(exports, "zlibBackend", { enumerable: true, get: function () { return shared_1.zlibBackend; } });
+Object.defineProperty(exports, "sendThread", { enumerable: true, get: function () { return shared_1.sendThread; } });

package/dist/shared.d.ts

@@ -10,4 +10,5 @@ export declare const SLIDING_DEFLATE_WINDOW: number;
 export declare const DEFAULT_PAYLOAD_LIMIT: number;
 export declare const native: any;
 export declare const zlibBackend: string;
+export declare const sendThread: string;
 export declare function setupNative(group: any, type: string, wsServer?: WebSocketServer): void;

package/dist/shared.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupNative = exports.zlibBackend = exports.native = exports.DEFAULT_PAYLOAD_LIMIT = exports.SLIDING_DEFLATE_WINDOW = exports.PERMESSAGE_DEFLATE = exports.APP_PING_CODE = exports.OPCODE_BINARY = exports.OPCODE_PING = exports.OPCODE_TEXT = exports.noop = void 0;
+exports.setupNative = exports.sendThread = exports.zlibBackend = exports.native = exports.DEFAULT_PAYLOAD_LIMIT = exports.SLIDING_DEFLATE_WINDOW = exports.PERMESSAGE_DEFLATE = exports.APP_PING_CODE = exports.OPCODE_BINARY = exports.OPCODE_PING = exports.OPCODE_TEXT = exports.noop = void 0;
 const client_1 = require("./client");
 exports.noop = () => { };
 exports.OPCODE_TEXT = 1;
@@ -20,6 +20,7 @@ exports.native = (() => {
     }
 })();
 exports.zlibBackend = exports.native.zlibBackend;
+exports.sendThread = exports.native.sendThread;
 function setupNative(group, type, wsServer) {
     exports.native.setNoop(exports.noop);
     exports.native[type].group.onConnection(group, (external) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@encharm/cws",
-  "version": "4.8.3",
+  "version": "4.10.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "description": "cWS - fast C++ WebSocket implementation for Node.js",
@@ -8,7 +8,7 @@
     "lint": "tslint -c tslint.json 'lib/**/*.ts'",
     "test": "nyc mocha './tests/**/*.test.ts' --exit",
     "clean": "rimraf dist/bindings/*",
-    "install": "node-gyp rebuild > build_log.txt 2>&1 || exit 0",
+    "install": "node scripts/install.js",
     "build-ts": "rimraf dist/*.js && rimraf dist/*.ts && npm run lint && tsc",
     "build-cpp": "node-gyp rebuild > build_log.txt 2>&1 || exit 0"
   },

package/scripts/install.js

@@ -0,0 +1,21 @@
+// npm/yarn `install` hook. The package ships prebuilt bindings under dist/bindings; only
+// fall back to a node-gyp source build (against Node's own zlib, no zlib-ng) when none
+// matches this platform and Node ABI. Set CWS_FORCE_BUILD=1 to build regardless.
+// The build is best effort: failures are logged to build_log.txt and never fail the install.
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const root = path.join(__dirname, '..');
+const binding = path.join(root, 'dist', 'bindings', `cws_${process.platform}_${process.arch}_node${process.versions.modules}.node`);
+
+if (fs.existsSync(binding) && !process.env.CWS_FORCE_BUILD) {
+  process.exit(0);
+}
+
+const log = fs.openSync(path.join(root, 'build_log.txt'), 'w');
+fs.writeSync(log, process.env.CWS_FORCE_BUILD ? `CWS_FORCE_BUILD set, building from source (prebuilt: ${binding})\n` : `no prebuilt binding at ${binding}, building from source\n`);
+spawnSync('node-gyp', ['rebuild'], { cwd: root, stdio: ['ignore', log, log], shell: true });
+fs.closeSync(log);
+process.exit(0);

package/src/Addon.cpp

@@ -24,6 +24,8 @@ void Initialize(Local<Object> exports) {
                String::NewFromUtf8(isolate, cWS::zlib::backend()).ToLocalChecked()).Check();
   hub.getNodeData()->corkState->enabled = corkEnabledFromEnv();
   registerCheck(isolate);
+  exports->Set(isolate->GetCurrentContext(), String::NewFromUtf8(isolate, "sendThread").ToLocalChecked(),
+               String::NewFromUtf8(isolate, cS::SendWorker::status()).ToLocalChecked()).Check();
 }
 
 NODE_MODULE(addon, Initialize)

package/src/Addon.h

@@ -6,6 +6,7 @@
 #include <openssl/ssl.h>
 #include <uv.h>
 #include <cstring>
+#include "SendWorker.h"
 
 #define NODE_WANT_INTERNALS 1
 
@@ -97,6 +98,11 @@ void registerCheck(Isolate *isolate) {
   });
   uv_unref((uv_handle_t *)&check);
 
+  // Send worker thread: only meaningful with corking, whose end-of-tick flush feeds it.
+  if (hub.getNodeData()->corkState->enabled) {
+    cS::SendWorker::init((uv_loop_t *)hub.getLoop());
+  }
+
   uv_prepare_init((uv_loop_t *)hub.getLoop(), &corkPrepare);
   uv_prepare_start(&corkPrepare, [](uv_prepare_t *) {
     cS::Socket::flushCorked(hub.getNodeData());

package/src/Hub.cpp

@@ -15,8 +15,10 @@ zlib::Stream *Hub::allocateDefaultCompressor(int level, int windowBits, int memL
 }
 
 char *Hub::deflate(char *data, size_t &length, zlib::Stream *slidingDeflateWindow) {
-    zlib::Stream *compressor = slidingDeflateWindow ? slidingDeflateWindow : deflationStream;
-    return zlib::deflate(compressor, data, length, zlibBuffer, LARGE_BUFFER_SIZE, dynamicZlibBuffer, !slidingDeflateWindow);
+    if (!slidingDeflateWindow) {
+        return zlib::deflateIndependent(deflationStream, data, length, zlibBuffer, LARGE_BUFFER_SIZE, dynamicZlibBuffer);
+    }
+    return zlib::deflate(slidingDeflateWindow, data, length, zlibBuffer, LARGE_BUFFER_SIZE, dynamicZlibBuffer, false);
 }
 
 char *Hub::inflate(char *data, size_t &length, size_t maxPayload) {

package/src/MicroDeflate.h

@@ -0,0 +1,109 @@
+#ifndef CWS_MICRODEFLATE_H
+#define CWS_MICRODEFLATE_H
+
+// Minimal raw-DEFLATE encoder for independent messages (permessage-deflate without
+// context takeover, i.e. the shared-compressor mode). One fixed-Huffman block, greedy
+// LZ77 over a 4-byte hash, no lazy matching, no stream state, and no per-message table
+// clearing: stale entries are validated by position and content. Output ends the way
+// Z_SYNC_FLUSH ends (empty stored block); the returned length already excludes the
+// trailing 00 00 ff ff, as RFC 7692 requires. Measured on a real BSON RPC stream: same
+// ratio as zlib-ng level 1 at ~1.7x its speed, mostly by skipping the 64 KB hash reset
+// zlib performs per message. Decodes with any inflater.
+//
+// Not for context takeover: matches never reference earlier messages.
+
+#include <cstdint>
+#include <cstring>
+#include <cstddef>
+
+namespace cWS {
+namespace microdeflate {
+
+// Worst case output for `length` input bytes (all literals at 9 bits + block overhead).
+inline size_t bound(size_t length) {
+    return length + length / 8 + 32;
+}
+
+class Encoder {
+    static const int HASH_BITS = 13;
+    uint32_t table[1 << HASH_BITS];
+
+    static const uint16_t *lenBase() { static const uint16_t t[29] = {3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258}; return t; }
+    static const uint8_t *lenExtra() { static const uint8_t t[29] = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0}; return t; }
+    static const uint16_t *distBase() { static const uint16_t t[30] = {1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577}; return t; }
+    static const uint8_t *distExtra() { static const uint8_t t[30] = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; return t; }
+
+    struct Tables {
+        uint16_t litCode[288]; uint8_t litBits[288];
+        uint8_t lenCode[259];
+        uint8_t distCode[32769];
+        uint8_t distCodeRev[30];
+        static uint32_t rev(uint32_t v, int n) { uint32_t r = 0; for (int i = 0; i < n; i++) { r = (r << 1) | (v & 1); v >>= 1; } return r; }
+        Tables() {
+            for (int i = 0; i < 288; i++) {
+                int bits, code;
+                if (i < 144) { bits = 8; code = 0x30 + i; }
+                else if (i < 256) { bits = 9; code = 0x190 + (i - 144); }
+                else if (i < 280) { bits = 7; code = i - 256; }
+                else { bits = 8; code = 0xC0 + (i - 280); }
+                litCode[i] = (uint16_t) rev(code, bits); litBits[i] = (uint8_t) bits;
+            }
+            for (int c = 0; c < 29; c++) for (int l = lenBase()[c]; l < (c < 28 ? lenBase()[c + 1] : 259); l++) lenCode[l] = (uint8_t) c;
+            for (int c = 0; c < 30; c++) { for (int d = distBase()[c]; d < (c < 29 ? distBase()[c + 1] : 32769); d++) distCode[d] = (uint8_t) c; distCodeRev[c] = (uint8_t) rev(c, 5); }
+        }
+    };
+    static const Tables &tables() { static const Tables t; return t; }
+
+    struct BitWriter {
+        uint8_t *out; size_t pos = 0; uint64_t acc = 0; int n = 0;
+        inline void put(uint32_t v, int bits) { acc |= (uint64_t) v << n; n += bits; while (n >= 8) { out[pos++] = (uint8_t) acc; acc >>= 8; n -= 8; } }
+        inline void flushByte() { if (n) { out[pos++] = (uint8_t) acc; acc = 0; n = 0; } }
+    };
+
+    static inline uint32_t hash4(const uint8_t *p) { uint32_t v; memcpy(&v, p, 4); return (v * 2654435761u) >> (32 - HASH_BITS); }
+
+public:
+    Encoder() { memset(table, 0xff, sizeof(table)); tables(); }
+
+    // `out` must have room for bound(length) bytes. Returns the compressed length
+    // (without the 4-byte sync-flush tail).
+    size_t compress(const uint8_t *in, size_t length, uint8_t *out) {
+        const Tables &t = tables();
+        BitWriter w{out};
+        w.put(0, 1); w.put(1, 2);                          // BFINAL=0, BTYPE=01 (fixed Huffman)
+        size_t i = 0;
+        const size_t limit = length >= 4 ? length - 4 : 0;
+        while (i < limit) {
+            uint32_t h = hash4(in + i);
+            uint32_t cand = table[h];
+            table[h] = (uint32_t) i;
+            if (cand < i && i - cand <= 32768 && memcmp(in + cand, in + i, 4) == 0) {
+                size_t maxLen = length - i; if (maxLen > 258) maxLen = 258;
+                size_t m = 4;
+                while (m < maxLen && in[cand + m] == in[i + m]) m++;
+                uint32_t dist = (uint32_t) (i - cand);
+                int lc = t.lenCode[m];
+                w.put(t.litCode[257 + lc], t.litBits[257 + lc]);
+                if (lenExtra()[lc]) w.put((uint32_t) (m - lenBase()[lc]), lenExtra()[lc]);
+                int dc = t.distCode[dist];
+                w.put(t.distCodeRev[dc], 5);
+                if (distExtra()[dc]) w.put(dist - distBase()[dc], distExtra()[dc]);
+                if (i + 1 < limit) table[hash4(in + i + 1)] = (uint32_t) (i + 1);
+                i += m;
+            } else {
+                w.put(t.litCode[in[i]], t.litBits[in[i]]);
+                i++;
+            }
+        }
+        for (; i < length; i++) w.put(t.litCode[in[i]], t.litBits[in[i]]);
+        w.put(t.litCode[256], t.litBits[256]);             // end of block
+        w.put(0, 1); w.put(0, 2); w.flushByte();           // empty stored block: BFINAL=0, BTYPE=00, then byte-align
+        out[w.pos++] = 0; out[w.pos++] = 0; out[w.pos++] = 0xff; out[w.pos++] = 0xff;
+        return w.pos - 4;
+    }
+};
+
+}
+}
+
+#endif // CWS_MICRODEFLATE_H

package/src/Networking.h

@@ -34,8 +34,11 @@
 #define be64toh(x) __builtin_bswap64(x)
 #else
 #define __thread __declspec(thread)
-#define htobe64(x) htonll(x)
-#define be64toh(x) ntohll(x)
+// Windows is little-endian; the intrinsic avoids depending on WinSock's htonll/ntohll,
+// whose declaration depends on SDK version macros that not every translation unit sets.
+#include <stdlib.h>
+#define htobe64(x) _byteswap_uint64(x)
+#define be64toh(x) _byteswap_uint64(x)
 #define pthread_t DWORD
 #define pthread_self GetCurrentThreadId
 #endif

package/src/SendWorker.cpp

@@ -0,0 +1,229 @@
+#include "SendWorker.h"
+#include "Socket.h"
+#include "Zlib.h"
+#include "cWS.h"
+#include "readerwriterqueue.h"
+#include <thread>
+#include <cstdlib>
+#include <cstring>
+#include <cerrno>
+#include <cctype>
+#include <string>
+
+namespace cS {
+
+namespace {
+    bool workerActive = false;
+    const char *workerStatus = "not initialised";
+    moodycamel::BlockingReaderWriterQueue<Socket::SendOp *> *toWorker = nullptr;
+    moodycamel::ReaderWriterQueue<Socket::SendOp *> *toMain = nullptr;
+    uv_async_t mainWake;
+
+    void onMainWake(uv_async_t *) {
+        Socket::SendOp *op;
+        while (toMain->try_dequeue(op)) {
+            Socket::sendComplete(op);
+        }
+    }
+
+    void workerLoop() {
+        Socket::SendOp *op;
+        for (;;) {
+            toWorker->wait_dequeue(op);
+            Socket::performSend(op);
+            toMain->enqueue(op);
+            uv_async_send(&mainWake);
+        }
+    }
+}
+
+bool SendWorker::init(uv_loop_t *loop) {
+    const char *disabled = getenv("CWS_SEND_THREAD");
+    std::string value = disabled ? disabled : "";
+    for (char &c : value) c = (char) tolower((unsigned char) c);
+    if (value == "0" || value == "false" || value == "off" || value == "no") {
+        workerStatus = "disabled by CWS_SEND_THREAD";
+        return false;
+    }
+    toWorker = new moodycamel::BlockingReaderWriterQueue<Socket::SendOp *>(4096);
+    toMain = new moodycamel::ReaderWriterQueue<Socket::SendOp *>(4096);
+    uv_async_init(loop, &mainWake, onMainWake);
+    uv_unref((uv_handle_t *) &mainWake); // completions alone must not keep the process alive
+    std::thread(workerLoop).detach();
+    workerActive = true;
+    workerStatus = "active";
+    return true;
+}
+
+bool SendWorker::active() { return workerActive; }
+const char *SendWorker::status() { return workerStatus; }
+
+bool SendWorker::submit(void *op) {
+    // try_enqueue never allocates; a full queue means "send it yourself this tick".
+    return toWorker->try_enqueue((Socket::SendOp *) op);
+}
+
+// ---- Socket side (needs Socket internals) ----
+
+// Deflates a pending message with the given stream and replaces its raw payload with a
+// framed compressed message. Shared between the worker (its own compressor) and the
+// main-thread materialize path (the hub's).
+static void deflateAndFrame(Socket::Queue::Message *m, cWS::zlib::Stream *stream, bool resetAfter, char *buffer, size_t bufferSize, std::string &dynamic) {
+    size_t compressedLength = m->length;
+    // resetAfter == independent message (no context takeover): microdeflate; else the socket's window
+    char *deflated = resetAfter ? cWS::zlib::deflateIndependent(stream, (char *) m->data, compressedLength, buffer, bufferSize, dynamic)
+                                : cWS::zlib::deflate(stream, (char *) m->data, compressedLength, buffer, bufferSize, dynamic, false);
+    const size_t HEADER = cWS::WebSocketProtocol<true, cWS::WebSocket<true>>::LONG_MESSAGE_HEADER;
+    char *frame = new char[compressedLength + HEADER];
+    size_t frameLength = cWS::WebSocketProtocol<true, cWS::WebSocket<true>>::formatMessage(frame, deflated, compressedLength, (cWS::OpCode) m->opCode, compressedLength, true);
+    delete [] (char *) m->data;
+    m->data = frame;
+    m->length = frameLength;
+    m->ownsData = true;
+    m->compressPending = false;
+}
+
+namespace {
+    // worker-thread compression state: its own shared compressor and scratch buffers
+    cWS::zlib::Stream *workerDeflate = nullptr;
+    const size_t WORKER_BUFFER = 300 * 1024;
+    char *workerBuffer = nullptr;
+    std::string workerDynamic;
+}
+
+void Socket::materializeOnMain(Socket *s, Queue::Message *m, cWS::zlib::Stream *stream, bool resetAfter, char *buffer, size_t bufferSize, std::string &dynamic) {
+    deflateAndFrame(m, stream, resetAfter, buffer, bufferSize, dynamic);
+}
+
+void Socket::performSend(SendOp *op) {
+    if (!workerDeflate) {
+        workerDeflate = cWS::zlib::createDeflate(1, 15, 8);
+        workerBuffer = new char[WORKER_BUFFER];
+    }
+    // 1. deflate + frame anything still pending, with this socket's window or the shared one
+    cWS::zlib::Stream *stream = op->deflateWindow ? (cWS::zlib::Stream *) op->deflateWindow : workerDeflate;
+    for (Queue::Message *m = op->head; m; m = m->nextMessage) {
+        if (m->compressPending) {
+            deflateAndFrame(m, stream, !op->deflateWindow, workerBuffer, WORKER_BUFFER, workerDynamic);
+        }
+    }
+    // 2. gather
+    op->count = 0;
+    op->bytes = 0;
+    for (Queue::Message *m = op->head; m; m = m->nextMessage) {
+#ifdef _WIN32
+        op->bufs[op->count].buf = (CHAR *) m->data;
+        op->bufs[op->count].len = (ULONG) m->length;
+#else
+        op->iov[op->count].iov_base = (void *) m->data;
+        op->iov[op->count].iov_len = m->length;
+#endif
+        op->bytes += m->length;
+        op->count++;
+    }
+#ifdef _WIN32
+    DWORD sent = 0;
+    if (WSASend(op->fd, op->bufs, (DWORD) op->count, &sent, 0, nullptr, nullptr) == SOCKET_ERROR) {
+        op->result = -1;
+        op->error = WSAGetLastError();
+    } else {
+        op->result = (ssize_t) sent;
+        op->error = 0;
+    }
+#else
+    msghdr msg = {};
+    msg.msg_iov = op->iov;
+    msg.msg_iovlen = op->count;
+    op->result = ::sendmsg(op->fd, &msg, MSG_NOSIGNAL);
+    op->error = op->result < 0 ? errno : 0;
+#endif
+}
+
+static bool sendWouldBlock(int error) {
+#ifdef _WIN32
+    return error == WSAEWOULDBLOCK;
+#else
+    return error == EWOULDBLOCK || error == EAGAIN;
+#endif
+}
+
+void Socket::sendComplete(SendOp *op) {
+    Socket *s = op->socket;
+    if (!s) {
+        // socket closed while the op was in flight: release its messages, then the fd we kept open
+        for (Queue::Message *m = op->head; m;) {
+            Queue::Message *next = m->nextMessage;
+            if (m->callback) {
+                m->callback(nullptr, m->callbackData, true, m->reserved);
+            }
+            Queue::release(op->nodeData, m);
+            m = next;
+        }
+        if (op->closeFd) {
+            op->nodeData->netContext->closeSocket(op->fd);
+        }
+        if (op->destroyWindow) {
+            cWS::zlib::destroy((cWS::zlib::Stream *) op->destroyWindow);
+        }
+        delete op;
+        return;
+    }
+    s->sendOp = nullptr;
+
+    ssize_t res = op->result;
+    if (res < 0) {
+        if (sendWouldBlock(op->error)) {
+            res = 0;
+        } else {
+            s->requeueFront(op);
+            delete op;
+            if (s->endCb) {
+                s->endCb(s);
+            }
+            return;
+        }
+    }
+
+    std::vector<PendingCallback> callbacks;
+    size_t sent = (size_t) res, opBytes = op->bytes;
+    while (sent > 0 && op->head) {
+        Queue::Message *m = op->head;
+        if (sent >= m->length) {
+            sent -= m->length;
+            op->bytes -= m->length;
+            if (m->callback) {
+                callbacks.push_back({m->callback, m->callbackData, m->reserved});
+            }
+            op->head = m->nextMessage;
+            Queue::release(op->nodeData, m);
+        } else {
+            m->length -= sent;
+            m->data += sent;
+            op->bytes -= sent;
+            sent = 0;
+        }
+    }
+    if (!op->head) {
+        op->tail = nullptr;
+    }
+    bool complete = (size_t) res == opBytes;
+    s->requeueFront(op);
+    delete op;
+
+    if (!s->messageQueue.empty()) {
+        if (complete) {
+            s->submitToWorker();                  // more arrived while in flight
+        } else if ((s->getPoll() & UV_WRITABLE) == 0) {
+            s->setPoll(s->getPoll() | UV_WRITABLE); // kernel buffer full: the drain loop resumes when writable
+            s->changePoll(s);
+        }
+    }
+    for (PendingCallback &c : callbacks) {
+        c.callback(s, c.callbackData, false, c.reserved);
+        if (s->isClosed()) {
+            break;
+        }
+    }
+}
+
+}

package/src/SendWorker.h

@@ -0,0 +1,25 @@
+#ifndef CWS_SEND_WORKER_H
+#define CWS_SEND_WORKER_H
+
+// Send worker thread. The end-of-tick flush hands each socket's queued frames to
+// one worker thread as an op; the worker does the gathered send syscall (the
+// kernel's TCP work is charged to it, not to the JS thread) and posts the op back.
+// Both directions are single-producer/single-consumer lock-free queues
+// (deps/readerwriterqueue); the worker parks on a semaphore when idle and the main
+// thread is woken through a uv_async. Disabled with CWS_SEND_THREAD=0.
+
+#include <uv.h>
+
+namespace cS {
+
+struct SendWorker {
+    static bool init(uv_loop_t *loop);
+    static bool active();
+    static const char *status();   // "active", or why not
+    // Main thread only. Returns false if the queue is full; the caller then sends synchronously.
+    static bool submit(void *op);
+};
+
+}
+
+#endif // CWS_SEND_WORKER_H