@encharm/cws 4.8.0 → 4.8.3

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## Released 4.8.3
+* Corked sends up to 1 KB use the per-loop block pool instead of malloc/free per message; queued messages remember their pool block. Also initialise the `reserved` callback argument, which was passed uninitialised for messages that hit the write queue.
+* JS: resolve the native namespace once per socket instead of on every `send`/`close`/`ping`.
+
+## Released 4.8.2
+* Accept compressed messages that end with a BFINAL=1 DEFLATE block (RFC 7692 section 7.2.3.4). Such clients (libdeflate-based and some non-zlib implementations) were disconnected on their first compressed message.
+
+## Released 4.8.1
+* Skip the kernel-level cork/uncork (two `setsockopt` calls) around every socket read when write corking is active; those writes leave in the end-of-tick gathered write anyway. Saves 1-2 us of server CPU per read.
+
 ## Released 4.8.0
 * Prebuilt bindings now compress with zlib-ng 2.2.4 (vendored in `deps/zlib-ng`, statically linked, native `zng_` API so it cannot collide with Node's zlib). Measured on a real RPC stream: level 1 costs 2.2-2.5 us/KB vs 5.6-8 us/KB with zlib. The node-gyp fallback build keeps using Node's zlib through the same `src/Zlib.cpp` wrapper.
 * New `perMessageDeflate.level` option (default 2) and a `zlibBackend` export naming the compiled-in implementation.

package/README.md

@@ -14,6 +14,9 @@ This table is true if you run ssl directly with `cws` (`Node.js`). In case if yo
 
 | cWS Version | Node 26 | Node 24  | Node 22 | Node 20 |
 |-------------|---------|----------|---------|----------
+| 4.8.3       |    X    |    X     |    X    |   X     |
+| 4.8.2       |    X    |    X     |    X    |   X     |
+| 4.8.1       |    X    |    X     |    X    |   X     |
 | 4.8.0       |    X    |    X     |    X    |   X     |
 | 4.7.0       |    X    |    X     |    X    |   X     |
 | 4.6.0       |    X    |    X     |    X    |   X     |

package/dist/client.d.ts

@@ -13,6 +13,7 @@ export declare class WebSocket {
     private external;
     private socketType;
     private compressThreshold;
+    private nativeApi;
     constructor(url: string, options?: any);
     get bufferedAmount(): number;
     get _socket(): SocketAddress;

package/dist/client.js

@@ -26,8 +26,10 @@ class WebSocket {
             message: shared_1.noop
         };
         this.socketType = 'client';
+        this.nativeApi = shared_1.native.client;
         if (!this.url && this.options.external) {
             this.socketType = 'server';
+            this.nativeApi = shared_1.native.server;
             this.external = this.options.external;
             this.compressThreshold = this.options.compressThreshold;
         }
@@ -90,7 +92,7 @@ class WebSocket {
             else if (this.compressThreshold !== undefined) {
                 compress = messageByteLength(message) >= this.compressThreshold;
             }
-            shared_1.native[this.socketType].send(this.external, message, opCode, cb ? () => process.nextTick(cb) : null, compress);
+            this.nativeApi.send(this.external, message, opCode, cb ? () => process.nextTick(cb) : null, compress);
         }
         else if (cb) {
             cb(new Error('Socket not connected'));
@@ -98,18 +100,18 @@ class WebSocket {
     }
     ping(message) {
         if (this.external) {
-            shared_1.native[this.socketType].send(this.external, message, shared_1.OPCODE_PING);
+            this.nativeApi.send(this.external, message, shared_1.OPCODE_PING);
         }
     }
     close(code = 1000, reason) {
         if (this.external) {
-            shared_1.native[this.socketType].close(this.external, code, reason);
+            this.nativeApi.close(this.external, code, reason);
             this.external = null;
         }
     }
     terminate() {
         if (this.external) {
-            shared_1.native[this.socketType].terminate(this.external);
+            this.nativeApi.terminate(this.external);
             this.external = null;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@encharm/cws",
-  "version": "4.8.0",
+  "version": "4.8.3",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "description": "cWS - fast C++ WebSocket implementation for Node.js",

package/src/HTTPSocket.cpp

@@ -289,7 +289,7 @@ void HttpSocket<isServer>::onEnd(cS::Socket *s) {
         if (message->callback) {
             message->callback(nullptr, message->callbackData, true, nullptr);
         }
-        httpSocket->messageQueue.pop();
+        httpSocket->messageQueue.pop(httpSocket->nodeData);
     }
 
     while (httpSocket->outstandingResponsesHead) {

package/src/Socket.h

@@ -50,20 +50,32 @@ protected:
             Message *nextMessage = nullptr;
             void (*callback)(void *socket, void *data, bool cancelled, void *reserved) = nullptr;
             void *callbackData = nullptr, *reserved = nullptr;
+            // >= 0: block came from NodeData's small-block pool (index for freeSmallMemoryBlock);
+            // -1: heap (new char[]). Messages are allocated as raw char arrays, so every
+            // allocation site must set this explicitly (the initializers above never run).
+            int poolIndex = -1;
         };
 
         Message *head = nullptr, *tail = nullptr;
         size_t totalLength = 0;
 
-        void pop()
+        static void release(NodeData *nodeData, Message *message) {
+            if (message->poolIndex >= 0) {
+                nodeData->freeSmallMemoryBlock((char *) message, message->poolIndex);
+            } else {
+                delete [] (char *) message;
+            }
+        }
+
+        void pop(NodeData *nodeData)
         {
             Message *nextMessage;
             if ((nextMessage = head->nextMessage)) {
                 totalLength -= head->length;
-                delete [] (char *) head;
+                release(nodeData, head);
                 head = nextMessage;
             } else {
-                delete [] (char *) head;
+                release(nodeData, head);
                 head = tail = nullptr;
                 totalLength = 0;
             }
@@ -174,7 +186,7 @@ protected:
                     // which frees the queue (use-after-free otherwise).
                     auto callback = messagePtr->callback;
                     void *callbackData = messagePtr->callbackData, *reserved = messagePtr->reserved;
-                    socket->messageQueue.pop();
+                    socket->messageQueue.pop(socket->nodeData);
                     if (callback) {
                         callback(p, callbackData, false, reserved);
                         if (socket->isClosed()) {
@@ -256,7 +268,7 @@ protected:
                         // which frees the queue (use-after-free otherwise).
                         auto callback = messagePtr->callback;
                         void *callbackData = messagePtr->callbackData, *reserved = messagePtr->reserved;
-                        socket->messageQueue.pop();
+                        socket->messageQueue.pop(socket->nodeData);
                         if (callback) {
                             callback(p, callbackData, false, reserved);
                             if (socket->isClosed()) {
@@ -318,6 +330,10 @@ protected:
         messagePtr->length = length;
         messagePtr->data = ((char *) messagePtr) + sizeof(Queue::Message);
         messagePtr->nextMessage = nullptr;
+        messagePtr->callback = nullptr;
+        messagePtr->callbackData = nullptr;
+        messagePtr->reserved = nullptr;
+        messagePtr->poolIndex = -1;
 
         if (data) {
             memcpy((char *) messagePtr->data, data, messagePtr->length);
@@ -385,10 +401,21 @@ protected:
         if (corkActive()) {
             // Frame now, write later: everything sent to this socket during the
             // current loop iteration goes out in one gathered write (uncork()).
-            Queue::Message *messagePtr = allocMessage(estimatedLength - sizeof(Queue::Message));
+            // Small messages come from the per-loop block pool (pop() returns them).
+            Queue::Message *messagePtr;
+            if (estimatedLength <= cS::NodeData::preAllocMaxSize) {
+                int memoryIndex = nodeData->getMemoryBlockIndex((int) estimatedLength);
+                messagePtr = (Queue::Message *) nodeData->getSmallMemoryBlock(memoryIndex);
+                messagePtr->data = ((char *) messagePtr) + sizeof(Queue::Message);
+                messagePtr->poolIndex = memoryIndex;
+            } else {
+                messagePtr = allocMessage(estimatedLength - sizeof(Queue::Message));
+            }
             messagePtr->length = T::transform(message, (char *) messagePtr->data, length, transformData);
+            messagePtr->nextMessage = nullptr;
             messagePtr->callback = callback;
             messagePtr->callbackData = callbackData;
+            messagePtr->reserved = nullptr;
             enqueue(messagePtr);
             if (!corkPending) {
                 corkPending = true;
@@ -405,6 +432,9 @@ protected:
                 Queue::Message *messagePtr = (Queue::Message *) nodeData->getSmallMemoryBlock(memoryIndex);
                 messagePtr->data = ((char *) messagePtr) + sizeof(Queue::Message);
                 messagePtr->length = T::transform(message, (char *) messagePtr->data, length, transformData);
+                messagePtr->nextMessage = nullptr;
+                messagePtr->reserved = nullptr;
+                messagePtr->poolIndex = memoryIndex;
 
                 bool wasTransferred;
                 if (write(messagePtr, wasTransferred)) {
@@ -589,7 +619,7 @@ public:
                 if (callbacks && m->callback) {
                     callbacks->push_back({m->callback, m->callbackData, m->reserved});
                 }
-                messageQueue.pop();
+                messageQueue.pop(nodeData);
             } else {
                 m->length -= sent;
                 m->data += sent;

package/src/WebSocket.cpp

@@ -151,6 +151,9 @@ void WebSocket<isServer>::sendPrepared(typename WebSocket<isServer>::PreparedMes
     Queue::Message *messagePtr = (Queue::Message *) nodeData->getSmallMemoryBlock(memoryIndex);
     messagePtr->data = preparedMessage->buffer;
     messagePtr->length = preparedMessage->length;
+    messagePtr->nextMessage = nullptr;
+    messagePtr->reserved = nullptr;
+    messagePtr->poolIndex = memoryIndex;
 
     bool wasTransferred;
     if (write(messagePtr, wasTransferred)) {
@@ -195,9 +198,15 @@ cS::Socket *WebSocket<isServer>::onData(cS::Socket *s, char *data, size_t length
 
     webSocket->hasOutstandingPong = false;
     if (!webSocket->isShuttingDown()) {
-        webSocket->cork(true);
+        // The kernel-level cork (TCP_CORK/TCP_NOPUSH) around a read only helps when
+        // replies are written immediately; with write corking they leave in one gathered
+        // write at the end of the tick, so skip the two setsockopt calls per read.
+        bool kernelCork = !webSocket->corkActive();
+        if (kernelCork) {
+            webSocket->cork(true);
+        }
         WebSocketProtocol<isServer, WebSocket<isServer>>::consume(data, (unsigned int) length, webSocket);
-        if (!webSocket->isClosed()) {
+        if (kernelCork && !webSocket->isClosed()) {
             webSocket->cork(false);
         }
     }
@@ -306,7 +315,7 @@ void WebSocket<isServer>::onEnd(cS::Socket *s) {
         if (message->callback) {
             message->callback(nullptr, message->callbackData, true, nullptr);
         }
-        webSocket->messageQueue.pop();
+        webSocket->messageQueue.pop(webSocket->nodeData);
     }
 
     webSocket->nodeData->clearPendingPollChanges(webSocket);

package/src/Zlib.cpp

@@ -106,7 +106,10 @@ char *inflate(Stream *stream, char *data, size_t &length, size_t maxPayload, cha
         zs.next_out = (OutPtr) buffer;
         zs.avail_out = (unsigned int) bufferSize;
         err = ZFN(inflate)(&zs, Z_FINISH);
-        if (!zs.avail_in) {
+        // Z_STREAM_END: the sender ended the message with a BFINAL=1 block, which
+        // RFC 7692 section 7.2.3.4 permits (libdeflate and some non-zlib clients do
+        // this); anything left in the input is the 4-byte tail and is ignored.
+        if (!zs.avail_in || err == Z_STREAM_END) {
             break;
         }
 
@@ -115,7 +118,7 @@ char *inflate(Stream *stream, char *data, size_t &length, size_t maxPayload, cha
 
     ZFN(inflateReset)(&zs);
 
-    if ((err != Z_BUF_ERROR && err != Z_OK) || dynamic.length() > maxPayload) {
+    if ((err != Z_BUF_ERROR && err != Z_OK && err != Z_STREAM_END) || dynamic.length() > maxPayload) {
         length = 0;
         return nullptr;
     }