@encharm/cws 4.5.3 → 4.8.0

package/src/Group.h

@@ -41,6 +41,9 @@ protected:
     unsigned int maxPayload;
     Hub *hub;
     int extensionOptions;
+    int deflateWindowBits = 15;
+    int deflateMemLevel = 8;
+    int deflateLevel = 1;
     cS::Timer *timer = nullptr, *httpTimer = nullptr;
     const char *userPingMessage;
     size_t userPingMessageLength;
@@ -61,7 +64,7 @@ protected:
     void addHttpSocket(HttpSocket<isServer> *httpSocket);
     void removeHttpSocket(HttpSocket<isServer> *httpSocket);
 
-    Group(int extensionOptions, unsigned int maxPayload, Hub *hub, cS::NodeData *nodeData);
+    Group(int extensionOptions, unsigned int maxPayload, Hub *hub, cS::NodeData *nodeData, int deflateWindowBits = 15, int deflateMemLevel = 8, int deflateLevel = 1);
     void stopListening();
 
 public:

package/src/HTTPSocket.cpp

@@ -210,7 +210,7 @@ void HttpSocket<isServer>::upgrade(const char *secKey, const char *extensions, s
         std::string extensionsResponse;
         if (extensionsLength) {
             Group<isServer> *group = Group<isServer>::from(this);
-            ExtensionsNegotiator<cWS::SERVER> extensionsNegotiator(group->extensionOptions);
+            ExtensionsNegotiator<cWS::SERVER> extensionsNegotiator(group->extensionOptions, group->deflateWindowBits);
             extensionsNegotiator.readOffer(std::string(extensions, extensionsLength));
             extensionsResponse = extensionsNegotiator.generateOffer();
             if (extensionsNegotiator.getNegotiatedOptions() & PERMESSAGE_DEFLATE) {

package/src/Hub.cpp

@@ -5,87 +5,22 @@
 
 namespace cWS {
 
-z_stream *Hub::allocateDefaultCompressor(z_stream *zStream) {
-    deflateInit2(zStream, 1, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY);
-    return zStream;
+// windowBits 9..15 and memLevel 1..9 select the per-socket memory tier (zlib uses
+// about 4x the window plus a 2^(memLevel+9) byte hash table): 15/8 = ~256 KB,
+// 12/5 = ~32 KB, 10/3 = ~8 KB, 9/2 = ~4 KB. Smaller tiers trade ratio for memory.
+// level 1..9: with zlib-ng level 1 is the very fast "quick" strategy (~8% worse
+// ratio than zlib level 1), level 2 matches zlib level 1's ratio at higher speed.
+zlib::Stream *Hub::allocateDefaultCompressor(int level, int windowBits, int memLevel) {
+    return zlib::createDeflate(level, windowBits, memLevel);
 }
 
-char *Hub::deflate(char *data, size_t &length, z_stream *slidingDeflateWindow) {
-    dynamicZlibBuffer.clear();
-
-    z_stream *compressor = slidingDeflateWindow ? slidingDeflateWindow : &deflationStream;
-
-    compressor->next_in = (Bytef *) data;
-    compressor->avail_in = (unsigned int) length;
-
-    // note: zlib requires more than 6 bytes with Z_SYNC_FLUSH
-    const int DEFLATE_OUTPUT_CHUNK = LARGE_BUFFER_SIZE;
-
-    int err;
-    do {
-        compressor->next_out = (Bytef *) zlibBuffer;
-        compressor->avail_out = DEFLATE_OUTPUT_CHUNK;
-
-        err = ::deflate(compressor, Z_SYNC_FLUSH);
-        if (Z_OK == err && compressor->avail_out == 0) {
-            dynamicZlibBuffer.append(zlibBuffer, DEFLATE_OUTPUT_CHUNK - compressor->avail_out);
-            continue;
-        } else {
-            break;
-        }
-    } while (true);
-
-    // note: should not change avail_out
-    if (!slidingDeflateWindow) {
-        deflateReset(compressor);
-    }
-
-    if (dynamicZlibBuffer.length()) {
-        dynamicZlibBuffer.append(zlibBuffer, DEFLATE_OUTPUT_CHUNK - compressor->avail_out);
-
-        length = dynamicZlibBuffer.length() - 4;
-        return (char *) dynamicZlibBuffer.data();
-    }
-
-    length = DEFLATE_OUTPUT_CHUNK - compressor->avail_out - 4;
-    return zlibBuffer;
+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);
 }
 
-// todo: let's go through this code once more some time!
 char *Hub::inflate(char *data, size_t &length, size_t maxPayload) {
-    dynamicZlibBuffer.clear();
-
-    inflationStream.next_in = (Bytef *) data;
-    inflationStream.avail_in = (unsigned int) length;
-
-    int err;
-    do {
-        inflationStream.next_out = (Bytef *) zlibBuffer;
-        inflationStream.avail_out = LARGE_BUFFER_SIZE;
-        err = ::inflate(&inflationStream, Z_FINISH);
-        if (!inflationStream.avail_in) {
-            break;
-        }
-
-        dynamicZlibBuffer.append(zlibBuffer, LARGE_BUFFER_SIZE - inflationStream.avail_out);
-    } while (err == Z_BUF_ERROR && dynamicZlibBuffer.length() <= maxPayload);
-
-    inflateReset(&inflationStream);
-
-    if ((err != Z_BUF_ERROR && err != Z_OK) || dynamicZlibBuffer.length() > maxPayload) {
-        length = 0;
-        return nullptr;
-    }
-
-    if (dynamicZlibBuffer.length()) {
-        dynamicZlibBuffer.append(zlibBuffer, LARGE_BUFFER_SIZE - inflationStream.avail_out);
-
-        length = dynamicZlibBuffer.length();
-        return (char *) dynamicZlibBuffer.data();
-    }
-
-    length = LARGE_BUFFER_SIZE - inflationStream.avail_out;
-    return zlibBuffer;
+    return zlib::inflate(inflationStream, data, length, maxPayload, zlibBuffer, LARGE_BUFFER_SIZE, dynamicZlibBuffer);
 }
 
 void Hub::onServerAccept(cS::Socket *s) {

package/src/Hub.h

@@ -4,7 +4,7 @@
 #include "Group.h"
 #include "cSNode.h"
 #include <string>
-#include <zlib.h>
+#include "Zlib.h"
 #include <mutex>
 #include <map>
 
@@ -18,10 +18,10 @@ protected:
         Group<CLIENT> *group;
     };
 
-    static z_stream *allocateDefaultCompressor(z_stream *zStream);
+    static zlib::Stream *allocateDefaultCompressor(int level = 1, int windowBits = 15, int memLevel = 8);
 
-    z_stream inflationStream = {}, deflationStream = {};
-    char *deflate(char *data, size_t &length, z_stream *slidingDeflateWindow);
+    zlib::Stream *inflationStream = nullptr, *deflationStream = nullptr;
+    char *deflate(char *data, size_t &length, zlib::Stream *slidingDeflateWindow);
     char *inflate(char *data, size_t &length, size_t maxPayload);
     char *zlibBuffer;
     std::string dynamicZlibBuffer;
@@ -32,8 +32,8 @@ protected:
 
 public:
     template <bool isServer>
-    Group<isServer> *createGroup(int extensionOptions = 0, unsigned int maxPayload = 16777216) {
-        return new Group<isServer>(extensionOptions, maxPayload, this, nodeData);
+    Group<isServer> *createGroup(int extensionOptions = 0, unsigned int maxPayload = 16777216, int deflateWindowBits = 15, int deflateMemLevel = 8, int deflateLevel = 1) {
+        return new Group<isServer>(extensionOptions, maxPayload, this, nodeData, deflateWindowBits, deflateMemLevel, deflateLevel);
     }
 
     template <bool isServer>
@@ -48,10 +48,11 @@ public:
 
     Hub(int extensionOptions = 0, bool useDefaultLoop = false, unsigned int maxPayload = 16777216) : cS::Node(LARGE_BUFFER_SIZE, WebSocketProtocol<SERVER, WebSocket<SERVER>>::CONSUME_PRE_PADDING, WebSocketProtocol<SERVER, WebSocket<SERVER>>::CONSUME_POST_PADDING, useDefaultLoop),
                                              Group<SERVER>(extensionOptions, maxPayload, this, nodeData), Group<CLIENT>(0, maxPayload, this, nodeData) {
-        inflateInit2(&inflationStream, -15);
+        inflationStream = zlib::createInflate(15);
         zlibBuffer = new char[LARGE_BUFFER_SIZE];
 
-        allocateDefaultCompressor(&deflationStream);
+        // shared compressor for groups without a per-socket sliding window
+        deflationStream = allocateDefaultCompressor();
 
 #ifdef CWS_THREADSAFE
         getLoop()->preCbData = nodeData;
@@ -67,14 +68,15 @@ public:
     }
 
     ~Hub() {
-        inflateEnd(&inflationStream);
-        deflateEnd(&deflationStream);
+        zlib::destroy(inflationStream);
+        zlib::destroy(deflationStream);
         delete [] zlibBuffer;
     }
 
     using cS::Node::run;
     using cS::Node::poll;
     using cS::Node::getLoop;
+    using cS::Node::getNodeData;
     using Group<SERVER>::onConnection;
     using Group<CLIENT>::onConnection;
     using Group<SERVER>::onTransfer;

package/src/Networking.h

@@ -215,6 +215,17 @@ struct WIN32_EXPORT NodeData {
     std::vector<Poll *> changePollQueue;
     static void asyncCallback(Async *async);
 
+    // Write corking: every send() issued during one event-loop iteration is
+    // queued and flushed with a single gathered write per socket from the
+    // loop's prepare/check hooks (see Socket::flushCorked). One CorkState per
+    // loop, shared by pointer between every NodeData copy (Groups copy the
+    // Hub's NodeData). Disabled with the CWS_CORK=0 environment variable.
+    struct CorkState {
+        bool enabled = false;
+        std::vector<Poll *> pending;
+    };
+    CorkState *corkState = nullptr;
+
     static int getMemoryBlockIndex(size_t length) {
         return (int) ((length >> 4) + bool(length & 15));
     }

package/src/Socket.h

@@ -2,6 +2,9 @@
 #define SOCKET_CWS_H
 
 #include "Networking.h"
+#ifndef _WIN32
+#include <sys/uio.h>
+#endif
 
 namespace cS {
 
@@ -33,6 +36,12 @@ protected:
     void *user = nullptr;
     NodeData *nodeData;
 
+    // Corking (see NodeData::CorkState). Only WebSockets opt in; HttpSocket
+    // objects are deleted synchronously in Hub::upgrade so they must never
+    // sit in the pending list. Plain TCP only, SSL keeps the immediate path.
+    bool corkable = false;
+    bool corkPending = false;
+
     // this is not needed by HttpSocket!
     struct Queue {
         struct Message {
@@ -91,6 +100,7 @@ protected:
     }
 
     void transfer(NodeData *nodeData, void (*cb)(Poll *)) {
+        flushCorkedOnClose();
         // userData is invalid from now on till onTransfer
         setUserData(new TransferData({getFd(), ssl, getCb(), getPoll(), getUserData(), nodeData, cb}));
         stop(this->nodeData->loop);
@@ -160,10 +170,17 @@ protected:
                 Queue::Message *messagePtr = socket->messageQueue.front();
                 int sent = SSL_write(socket->ssl, messagePtr->data, (int) messagePtr->length);
                 if (sent == (ssize_t) messagePtr->length) {
-                    if (messagePtr->callback) {
-                        messagePtr->callback(p, messagePtr->callbackData, false, messagePtr->reserved);
-                    }
+                    // Pop before the callback: it may close/terminate this socket,
+                    // which frees the queue (use-after-free otherwise).
+                    auto callback = messagePtr->callback;
+                    void *callbackData = messagePtr->callbackData, *reserved = messagePtr->reserved;
                     socket->messageQueue.pop();
+                    if (callback) {
+                        callback(p, callbackData, false, reserved);
+                        if (socket->isClosed()) {
+                            return;
+                        }
+                    }
                     if (socket->messageQueue.empty()) {
                         if ((socket->state.poll & UV_WRITABLE) && SSL_want(socket->ssl) != SSL_WRITING) {
                             socket->change(socket->nodeData->loop, socket, socket->setPoll(UV_READABLE));
@@ -235,10 +252,17 @@ protected:
                     Queue::Message *messagePtr = socket->messageQueue.front();
                     ssize_t sent = ::send(socket->getFd(), messagePtr->data, messagePtr->length, MSG_NOSIGNAL);
                     if (sent == (ssize_t) messagePtr->length) {
-                        if (messagePtr->callback) {
-                            messagePtr->callback(p, messagePtr->callbackData, false, messagePtr->reserved);
-                        }
+                        // Pop before the callback: it may close/terminate this socket,
+                        // which frees the queue (use-after-free otherwise).
+                        auto callback = messagePtr->callback;
+                        void *callbackData = messagePtr->callbackData, *reserved = messagePtr->reserved;
                         socket->messageQueue.pop();
+                        if (callback) {
+                            callback(p, callbackData, false, reserved);
+                            if (socket->isClosed()) {
+                                return;
+                            }
+                        }
                         if (socket->messageQueue.empty()) {
                             // todo, remove bit, don't set directly
                             socket->change(socket->nodeData->loop, socket, socket->setPoll(UV_READABLE));
@@ -358,6 +382,21 @@ protected:
     void sendTransformed(const char *message, size_t length, void(*callback)(void *socket, void *data, bool cancelled, void *reserved), void *callbackData, D transformData) {
         size_t estimatedLength = T::estimate(message, length) + sizeof(Queue::Message);
 
+        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));
+            messagePtr->length = T::transform(message, (char *) messagePtr->data, length, transformData);
+            messagePtr->callback = callback;
+            messagePtr->callbackData = callbackData;
+            enqueue(messagePtr);
+            if (!corkPending) {
+                corkPending = true;
+                nodeData->corkState->pending.push_back(this);
+            }
+            return;
+        }
+
         if (hasEmptyQueue()) {
             if (estimatedLength <= cS::NodeData::preAllocMaxSize) {
                 int memoryLength = (int) estimatedLength;
@@ -477,8 +516,164 @@ public:
         }
     }
 
+    // ---- Write corking ------------------------------------------------------
+
+    bool corkActive() {
+        return corkable && !ssl && nodeData->corkState && nodeData->corkState->enabled;
+    }
+
+    void setCorkable(bool enable) {
+        corkable = enable;
+    }
+
+    void unregisterCork() {
+        if (!corkPending) {
+            return;
+        }
+        corkPending = false;
+        std::vector<Poll *> &pending = nodeData->corkState->pending;
+        for (size_t i = 0; i < pending.size(); i++) {
+            if (pending[i] == this) {
+                pending[i] = pending.back();
+                pending.pop_back();
+                break;
+            }
+        }
+    }
+
+    // One gathered write of (up to MAX_IOV) messages from the queue head.
+    // Returns bytes written or -1 with errno/WSAGetLastError set. Never pops.
+    ssize_t writeQueueGathered() {
+        static const int MAX_IOV = 64;
+#ifdef _WIN32
+        WSABUF bufs[MAX_IOV];
+        DWORD n = 0;
+        for (Queue::Message *m = messageQueue.front(); m && n < MAX_IOV; m = m->nextMessage) {
+            bufs[n].buf = (CHAR *) m->data;
+            bufs[n].len = (ULONG) m->length;
+            n++;
+        }
+        DWORD sent = 0;
+        if (WSASend(getFd(), bufs, n, &sent, 0, nullptr, nullptr) == SOCKET_ERROR) {
+            return -1;
+        }
+        return (ssize_t) sent;
+#else
+        iovec iov[MAX_IOV];
+        int n = 0;
+        for (Queue::Message *m = messageQueue.front(); m && n < MAX_IOV; m = m->nextMessage) {
+            iov[n].iov_base = (void *) m->data;
+            iov[n].iov_len = m->length;
+            n++;
+        }
+        msghdr msg = {};
+        msg.msg_iov = iov;
+        msg.msg_iovlen = n;
+        return ::sendmsg(getFd(), &msg, MSG_NOSIGNAL);
+#endif
+    }
+
+    // Consumes `sent` bytes from the queue head. Fully written messages are
+    // popped (their callbacks appended to `callbacks` if given); a partially
+    // written head is advanced in place. Returns true if the write was partial.
+    struct PendingCallback {
+        void (*callback)(void *socket, void *data, bool cancelled, void *reserved);
+        void *callbackData, *reserved;
+    };
+
+    bool consumeSent(ssize_t sent, std::vector<PendingCallback> *callbacks) {
+        while (sent > 0 && !messageQueue.empty()) {
+            Queue::Message *m = messageQueue.front();
+            if ((size_t) sent >= m->length) {
+                sent -= m->length;
+                if (callbacks && m->callback) {
+                    callbacks->push_back({m->callback, m->callbackData, m->reserved});
+                }
+                messageQueue.pop();
+            } else {
+                m->length -= sent;
+                m->data += sent;
+                messageQueue.totalLength -= sent;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    // Flush this socket's corked queue. Called from the loop's prepare/check
+    // hooks via flushCorked(). Whatever cannot be written now is left to the
+    // regular UV_WRITABLE drain loop, which also surfaces hard errors (onEnd).
+    void uncork() {
+        corkPending = false;
+        if (isClosed() || messageQueue.empty()) {
+            return;
+        }
+
+        std::vector<PendingCallback> callbacks;
+        bool stalled = false;
+        while (!messageQueue.empty() && !stalled) {
+            ssize_t sent = writeQueueGathered();
+            if (sent < 0) {
+                stalled = true; // would block, or hard error: drain loop reports it
+            } else {
+                stalled = consumeSent(sent, &callbacks);
+            }
+        }
+
+        if (!messageQueue.empty()) {
+            if ((getPoll() & UV_WRITABLE) == 0) {
+                setPoll(getPoll() | UV_WRITABLE);
+                changePoll(this);
+            }
+        } else if (getPoll() & UV_WRITABLE) {
+            change(nodeData->loop, this, setPoll(UV_READABLE));
+        }
+
+        for (PendingCallback &c : callbacks) {
+            c.callback(this, c.callbackData, false, c.reserved);
+            if (isClosed()) {
+                break; // callback closed us; nothing further may touch the fd
+            }
+        }
+    }
+
+    // Best effort on close/terminate/transfer: push what was corked during this
+    // iteration to the kernel so send() immediately followed by terminate()
+    // still delivers. Callbacks are not invoked; the caller drains the queue.
+    void flushCorkedOnClose() {
+        if (!corkPending) {
+            return;
+        }
+        unregisterCork();
+        if (isClosed()) {
+            return;
+        }
+        while (!messageQueue.empty()) {
+            ssize_t sent = writeQueueGathered();
+            if (sent <= 0 || consumeSent(sent, nullptr)) {
+                break;
+            }
+        }
+    }
+
+    // Loop hook: flush every socket that corked writes since the last hook.
+    static void flushCorked(NodeData *nodeData) {
+        if (!nodeData->corkState || nodeData->corkState->pending.empty()) {
+            return;
+        }
+        // Swap out the list: callbacks run during uncork() may cork new writes
+        // (picked up by the next hook) or close other sockets (their deletion
+        // is deferred to libuv's close phase, so pointers stay valid here).
+        std::vector<Poll *> batch;
+        batch.swap(nodeData->corkState->pending);
+        for (Poll *p : batch) {
+            ((Socket *) p)->uncork();
+        }
+    }
+
     template <class T>
     void closeSocket() {
+        unregisterCork();
         uv_os_sock_t fd = getFd();
         Context *netContext = nodeData->netContext;
         stop(nodeData->loop);

package/src/WebSocket.cpp

@@ -7,10 +7,12 @@ namespace cWS {
 template <bool isServer>
 WebSocket<isServer>::WebSocket(bool perMessageDeflate, cS::Socket *socket) : cS::Socket(std::move(*socket)) {
     compressionStatus = perMessageDeflate ? CompressionStatus::ENABLED : CompressionStatus::DISABLED;
+    setCorkable(true);
 
     // if we are created in a group with sliding deflate window allocate it here
     if (Group<isServer>::from(this)->extensionOptions & SLIDING_DEFLATE_WINDOW) {
-        slidingDeflateWindow = Hub::allocateDefaultCompressor(new z_stream{});
+        Group<isServer> *group = Group<isServer>::from(this);
+        slidingDeflateWindow = Hub::allocateDefaultCompressor(group->deflateLevel, group->deflateWindowBits, group->deflateMemLevel);
     }
 }
 
@@ -51,7 +53,7 @@ void WebSocket<isServer>::send(const char *message, size_t length, OpCode opCode
 
         static size_t transform(const char *src, char *dst, size_t length, TransformData transformData) {
             if (transformData.compress) {
-                char *deflated = Group<isServer>::from(transformData.s)->hub->deflate((char *) src, length, (z_stream *) transformData.s->slidingDeflateWindow);
+                char *deflated = Group<isServer>::from(transformData.s)->hub->deflate((char *) src, length, (zlib::Stream *) transformData.s->slidingDeflateWindow);
                 return WebSocketProtocol<isServer, WebSocket<isServer>>::formatMessage(dst, deflated, length, transformData.opCode, length, true);
             }
 
@@ -214,10 +216,10 @@ void WebSocket<isServer>::terminate() {
 
 #ifdef CWS_THREADSAFE
     std::lock_guard<std::recursive_mutex> lockGuard(*nodeData->asyncMutex);
+#endif
     if (isClosed()) {
         return;
     }
-#endif
 
     WebSocket<isServer>::onEnd(this);
 }
@@ -288,6 +290,8 @@ template <bool isServer>
 void WebSocket<isServer>::onEnd(cS::Socket *s) {
     WebSocket<isServer> *webSocket = static_cast<WebSocket<isServer> *>(s);
 
+    webSocket->flushCorkedOnClose();
+
     if (!webSocket->isShuttingDown()) {
         Group<isServer>::from(webSocket)->removeWebSocket(webSocket);
         Group<isServer>::from(webSocket)->disconnectionHandler(webSocket, 1006, nullptr, 0);
@@ -310,8 +314,7 @@ void WebSocket<isServer>::onEnd(cS::Socket *s) {
     // remove any per-websocket zlib memory
     if (webSocket->slidingDeflateWindow) {
         // this relates to Hub::allocateDefaultCompressor
-        deflateEnd((z_stream *) webSocket->slidingDeflateWindow);
-        delete (z_stream *) webSocket->slidingDeflateWindow;
+        zlib::destroy((zlib::Stream *) webSocket->slidingDeflateWindow);
         webSocket->slidingDeflateWindow = nullptr;
     }
 }

package/src/Zlib.cpp

@@ -0,0 +1,138 @@
+#include "Zlib.h"
+
+#ifdef CWS_ZLIB_NG
+#include "zlib-ng.h"
+typedef zng_stream ZStream;
+#define ZFN(name) zng_##name
+#define CWS_ZLIB_BACKEND "zlib-ng " ZLIBNG_VERSION
+#else
+#include <zlib.h>
+typedef z_stream ZStream;
+#define ZFN(name) name
+#define CWS_ZLIB_BACKEND "zlib " ZLIB_VERSION
+#endif
+
+namespace cWS {
+namespace zlib {
+
+struct Stream {
+    ZStream zs;
+    bool isDeflate;
+};
+
+typedef decltype(ZStream::next_in) InPtr;
+typedef decltype(ZStream::next_out) OutPtr;
+
+Stream *createDeflate(int level, int windowBits, int memLevel) {
+    Stream *stream = new Stream();
+    stream->isDeflate = true;
+    ZFN(deflateInit2)(&stream->zs, level, Z_DEFLATED, -windowBits, memLevel, Z_DEFAULT_STRATEGY);
+    return stream;
+}
+
+Stream *createInflate(int windowBits) {
+    Stream *stream = new Stream();
+    stream->isDeflate = false;
+    ZFN(inflateInit2)(&stream->zs, -windowBits);
+    return stream;
+}
+
+void reset(Stream *stream) {
+    if (stream->isDeflate) {
+        ZFN(deflateReset)(&stream->zs);
+    } else {
+        ZFN(inflateReset)(&stream->zs);
+    }
+}
+
+void destroy(Stream *stream) {
+    if (!stream) {
+        return;
+    }
+    if (stream->isDeflate) {
+        ZFN(deflateEnd)(&stream->zs);
+    } else {
+        ZFN(inflateEnd)(&stream->zs);
+    }
+    delete stream;
+}
+
+char *deflate(Stream *stream, char *data, size_t &length, char *buffer, size_t bufferSize, std::string &dynamic, bool resetAfter) {
+    ZStream &zs = stream->zs;
+    dynamic.clear();
+
+    zs.next_in = (InPtr) data;
+    zs.avail_in = (unsigned int) length;
+
+    // note: zlib requires more than 6 bytes of output space with Z_SYNC_FLUSH
+    int err;
+    do {
+        zs.next_out = (OutPtr) buffer;
+        zs.avail_out = (unsigned int) bufferSize;
+
+        err = ZFN(deflate)(&zs, Z_SYNC_FLUSH);
+        if (Z_OK == err && zs.avail_out == 0) {
+            dynamic.append(buffer, bufferSize - zs.avail_out);
+            continue;
+        } else {
+            break;
+        }
+    } while (true);
+
+    // note: must not change avail_out
+    if (resetAfter) {
+        ZFN(deflateReset)(&zs);
+    }
+
+    if (dynamic.length()) {
+        dynamic.append(buffer, bufferSize - zs.avail_out);
+        length = dynamic.length() - 4;
+        return (char *) dynamic.data();
+    }
+
+    length = bufferSize - zs.avail_out - 4;
+    return buffer;
+}
+
+char *inflate(Stream *stream, char *data, size_t &length, size_t maxPayload, char *buffer, size_t bufferSize, std::string &dynamic) {
+    ZStream &zs = stream->zs;
+    dynamic.clear();
+
+    zs.next_in = (InPtr) data;
+    zs.avail_in = (unsigned int) length;
+
+    int err;
+    do {
+        zs.next_out = (OutPtr) buffer;
+        zs.avail_out = (unsigned int) bufferSize;
+        err = ZFN(inflate)(&zs, Z_FINISH);
+        if (!zs.avail_in) {
+            break;
+        }
+
+        dynamic.append(buffer, bufferSize - zs.avail_out);
+    } while (err == Z_BUF_ERROR && dynamic.length() <= maxPayload);
+
+    ZFN(inflateReset)(&zs);
+
+    if ((err != Z_BUF_ERROR && err != Z_OK) || dynamic.length() > maxPayload) {
+        length = 0;
+        return nullptr;
+    }
+
+    if (dynamic.length()) {
+        dynamic.append(buffer, bufferSize - zs.avail_out);
+        length = dynamic.length();
+        return (char *) dynamic.data();
+    }
+
+    length = bufferSize - zs.avail_out;
+    return buffer;
+}
+
+const char *backend() {
+    return CWS_ZLIB_BACKEND;
+}
+
+}
+}