uws-react-native 0.0.1-alpha.1

package/cpp/uWebSockets/uWebSockets/PerMessageDeflate.h

@@ -0,0 +1,303 @@
+/*
+ * Authored by Alex Hultman, 2018-2021.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* This standalone module implements deflate / inflate streams */
+
+#ifndef UWS_PERMESSAGEDEFLATE_H
+#define UWS_PERMESSAGEDEFLATE_H
+
+#include <cstdint>
+#include <cstring>
+
+/* We always define these options no matter if ZLIB is enabled or not */
+namespace uWS {
+    /* Compressor mode is 8 lowest bits where HIGH4(windowBits), LOW4(memLevel).
+     * Decompressor mode is 8 highest bits LOW4(windowBits).
+     * If compressor or decompressor bits are 1, then they are shared.
+     * If everything is just simply 0, then everything is disabled. */
+    enum CompressOptions : uint16_t {
+        /* These are not actual compression options */
+        _COMPRESSOR_MASK = 0x00FF,
+        _DECOMPRESSOR_MASK = 0x0F00,
+        /* Disabled, shared, shared are "special" values */
+        DISABLED = 0,
+        SHARED_COMPRESSOR = 1,
+        SHARED_DECOMPRESSOR = 1 << 8,
+        /* Highest 4 bits describe decompressor */
+        DEDICATED_DECOMPRESSOR_32KB = 15 << 8,
+        DEDICATED_DECOMPRESSOR_16KB = 14 << 8,
+        DEDICATED_DECOMPRESSOR_8KB = 13 << 8,
+        DEDICATED_DECOMPRESSOR_4KB = 12 << 8,
+        DEDICATED_DECOMPRESSOR_2KB = 11 << 8,
+        DEDICATED_DECOMPRESSOR_1KB = 10 << 8,
+        DEDICATED_DECOMPRESSOR_512B = 9 << 8,
+        /* Same as 32kb */
+        DEDICATED_DECOMPRESSOR = 15 << 8,
+
+        /* Lowest 8 bit describe compressor */
+        DEDICATED_COMPRESSOR_3KB = 9 << 4 | 1,
+        DEDICATED_COMPRESSOR_4KB = 9 << 4 | 2,
+        DEDICATED_COMPRESSOR_8KB = 10 << 4 | 3,
+        DEDICATED_COMPRESSOR_16KB = 11 << 4 | 4,
+        DEDICATED_COMPRESSOR_32KB = 12 << 4 | 5,
+        DEDICATED_COMPRESSOR_64KB = 13 << 4 | 6,
+        DEDICATED_COMPRESSOR_128KB = 14 << 4 | 7,
+        DEDICATED_COMPRESSOR_256KB = 15 << 4 | 8,
+        /* Same as 256kb */
+        DEDICATED_COMPRESSOR = 15 << 4 | 8
+    };
+}
+
+#if !defined(UWS_NO_ZLIB) && !defined(UWS_MOCK_ZLIB)
+#include <zlib.h>
+#endif
+
+#include <string>
+#include <optional>
+
+#ifdef UWS_USE_LIBDEFLATE
+#include "libdeflate.h"
+#include <cstring>
+#endif
+
+namespace uWS {
+
+/* Do not compile this module if we don't want it */
+#if defined(UWS_NO_ZLIB) || defined(UWS_MOCK_ZLIB)
+struct ZlibContext {};
+struct InflationStream {
+    std::optional<std::string_view> inflate(ZlibContext * /*zlibContext*/, std::string_view compressed, size_t maxPayloadLength, bool /*reset*/) {
+        return compressed.substr(0, std::min(maxPayloadLength, compressed.length()));
+    }
+    InflationStream(CompressOptions /*compressOptions*/) {
+    }
+};
+struct DeflationStream {
+    std::string_view deflate(ZlibContext * /*zlibContext*/, std::string_view raw, bool /*reset*/) {
+        return raw;
+    }
+    DeflationStream(CompressOptions /*compressOptions*/) {
+    }
+};
+#else
+
+#define LARGE_BUFFER_SIZE 1024 * 16 // todo: fix this
+
+struct ZlibContext {
+    /* Any returned data is valid until next same-class call.
+     * We need to have two classes to allow inflation followed
+     * by many deflations without modifying the inflation */
+    std::string dynamicDeflationBuffer;
+    std::string dynamicInflationBuffer;
+    char *deflationBuffer;
+    char *inflationBuffer;
+
+#ifdef UWS_USE_LIBDEFLATE
+    libdeflate_decompressor *decompressor;
+    libdeflate_compressor *compressor;
+#endif
+
+    ZlibContext() {
+        deflationBuffer = (char *) malloc(LARGE_BUFFER_SIZE);
+        inflationBuffer = (char *) malloc(LARGE_BUFFER_SIZE);
+
+#ifdef UWS_USE_LIBDEFLATE
+        decompressor = libdeflate_alloc_decompressor();
+        compressor = libdeflate_alloc_compressor(6);
+#endif
+    }
+
+    ~ZlibContext() {
+        free(deflationBuffer);
+        free(inflationBuffer);
+
+#ifdef UWS_USE_LIBDEFLATE
+        libdeflate_free_decompressor(decompressor);
+        libdeflate_free_compressor(compressor);
+#endif
+    }
+};
+
+struct DeflationStream {
+    z_stream deflationStream = {};
+
+    DeflationStream(CompressOptions compressOptions) {
+
+        /* Sliding inflator should be about 44kb by default, less than compressor */
+
+        /* Memory usage is given by 2 ^ (windowBits + 2) + 2 ^ (memLevel + 9) */
+        int windowBits = -(int) ((compressOptions & _COMPRESSOR_MASK) >> 4), memLevel = compressOptions & 0xF;
+
+        //printf("windowBits: %d, memLevel: %d\n", windowBits, memLevel);
+
+        deflateInit2(&deflationStream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, windowBits, memLevel, Z_DEFAULT_STRATEGY);
+    }
+
+    /* Deflate and optionally reset. You must not deflate an empty string. */
+    std::string_view deflate(ZlibContext *zlibContext, std::string_view raw, bool reset) {
+
+        /* Odd place to clear this one, fix */
+        zlibContext->dynamicDeflationBuffer.clear();
+
+        deflationStream.next_in = (Bytef *) raw.data();
+        deflationStream.avail_in = (unsigned int) raw.length();
+
+        /* This buffer size has to be at least 6 bytes for Z_SYNC_FLUSH to work */
+        const int DEFLATE_OUTPUT_CHUNK = LARGE_BUFFER_SIZE;
+
+        int err;
+        do {
+            deflationStream.next_out = (Bytef *) zlibContext->deflationBuffer;
+            deflationStream.avail_out = DEFLATE_OUTPUT_CHUNK;
+
+            err = ::deflate(&deflationStream, Z_SYNC_FLUSH);
+            if (Z_OK == err && deflationStream.avail_out == 0) {
+                zlibContext->dynamicDeflationBuffer.append(zlibContext->deflationBuffer, DEFLATE_OUTPUT_CHUNK - deflationStream.avail_out);
+                continue;
+            } else {
+                break;
+            }
+        } while (true);
+
+        /* This must not change avail_out */
+        if (reset) {
+            deflateReset(&deflationStream);
+        }
+
+        if (zlibContext->dynamicDeflationBuffer.length()) {
+            zlibContext->dynamicDeflationBuffer.append(zlibContext->deflationBuffer, DEFLATE_OUTPUT_CHUNK - deflationStream.avail_out);
+
+            return std::string_view((char *) zlibContext->dynamicDeflationBuffer.data(), zlibContext->dynamicDeflationBuffer.length() - 4);
+        }
+
+        /* Note: We will get an interger overflow resulting in heap buffer overflow if Z_BUF_ERROR is returned
+         * from passing 0 as avail_in. Therefore we must not deflate an empty string */
+        return {
+            zlibContext->deflationBuffer,
+            DEFLATE_OUTPUT_CHUNK - deflationStream.avail_out - 4
+        };
+    }
+
+    ~DeflationStream() {
+        deflateEnd(&deflationStream);
+    }
+};
+
+struct InflationStream {
+    z_stream inflationStream = {};
+
+    InflationStream(CompressOptions compressOptions) {
+        /* Inflation windowBits are the top 8 bits of the 16 bit compressOptions */
+        inflateInit2(&inflationStream, -(compressOptions >> 8));
+    }
+
+    ~InflationStream() {
+        inflateEnd(&inflationStream);
+    }
+
+    /* Zero length inflates are possible and valid */
+    std::optional<std::string_view> inflate(ZlibContext *zlibContext, std::string_view compressed, size_t maxPayloadLength, bool reset) {
+
+#ifdef UWS_USE_LIBDEFLATE
+        if (reset) {
+            /* Try fast path first (assuming single DEFLATE block and shared compressor aka reset = true) */
+            size_t written = 0, consumed;
+            zlibContext->dynamicInflationBuffer.clear();
+            zlibContext->dynamicInflationBuffer.reserve(maxPayloadLength);
+
+            ((char *)compressed.data())[0] |= 0x1; // BFINAL = 1
+            libdeflate_result res = libdeflate_deflate_decompress_ex(zlibContext->decompressor, compressed.data(), compressed.length(), zlibContext->dynamicInflationBuffer.data(), maxPayloadLength, &consumed, &written);
+    
+            /* Still not entirely sure why 1 extra zero byte is optional and ignored by both zlib and libdeflate in some cases */
+            /* Minimal reproducer is load_test.c with 102 byte message size. It should be tested with Chrome at various message sizes as well. */
+            if (res == 0 && (consumed == compressed.length() || (consumed + 1 == compressed.length() && compressed[consumed] == '\0'))) {
+                return std::string_view(zlibContext->dynamicInflationBuffer.data(), written);
+            } else {
+                /* We can only end up here if the first DEFLATE block was not the last, so mark it as such */
+                ((char *)compressed.data())[0] &= ~0x1; // BFINAL = 0
+            }
+        }
+#endif
+
+        /* Save off the bytes we're about to overwrite */
+        char* tailLocation = (char*)compressed.data() + compressed.length();
+        char preTailBytes[4];
+        memcpy(preTailBytes, tailLocation, 4);
+
+        /* Append tail to chunk */
+        unsigned char tail[4] = {0x00, 0x00, 0xff, 0xff};
+        memcpy(tailLocation, tail, 4);
+        compressed = {compressed.data(), compressed.length() + 4};
+
+        /* We clear this one here, could be done better */
+        zlibContext->dynamicInflationBuffer.clear();
+
+        inflationStream.next_in = (Bytef *) compressed.data();
+        inflationStream.avail_in = (unsigned int) compressed.length();
+
+        int err;
+        do {
+            inflationStream.next_out = (Bytef *) zlibContext->inflationBuffer;
+            inflationStream.avail_out = LARGE_BUFFER_SIZE;
+
+            err = ::inflate(&inflationStream, Z_SYNC_FLUSH);
+            if (err == Z_OK && inflationStream.avail_out) {
+                break;
+            }
+
+            zlibContext->dynamicInflationBuffer.append(zlibContext->inflationBuffer, LARGE_BUFFER_SIZE - inflationStream.avail_out);
+
+
+        } while (inflationStream.avail_out == 0 && zlibContext->dynamicInflationBuffer.length() <= maxPayloadLength);
+
+        if (reset) {
+            inflateReset(&inflationStream);
+        }
+
+        /* Restore the bytes we used for the tail */
+        memcpy(tailLocation, preTailBytes, 4);
+
+        if ((err != Z_BUF_ERROR && err != Z_OK) || zlibContext->dynamicInflationBuffer.length() > maxPayloadLength) {
+            return std::nullopt;
+        }
+
+        if (zlibContext->dynamicInflationBuffer.length()) {
+            zlibContext->dynamicInflationBuffer.append(zlibContext->inflationBuffer, LARGE_BUFFER_SIZE - inflationStream.avail_out);
+
+            /* Let's be strict about the max size */
+            if (zlibContext->dynamicInflationBuffer.length() > maxPayloadLength) {
+                return std::nullopt;
+            }
+
+            return std::string_view(zlibContext->dynamicInflationBuffer.data(), zlibContext->dynamicInflationBuffer.length());
+        }
+
+        /* Let's be strict about the max size */
+        if ((LARGE_BUFFER_SIZE - inflationStream.avail_out) > maxPayloadLength) {
+            return std::nullopt;
+        }
+
+        return std::string_view(zlibContext->inflationBuffer, LARGE_BUFFER_SIZE - inflationStream.avail_out);
+    }
+
+};
+
+#endif
+
+}
+
+#endif // UWS_PERMESSAGEDEFLATE_H

package/cpp/uWebSockets/uWebSockets/ProxyParser.h

@@ -0,0 +1,187 @@
+/*
+ * Authored by Alex Hultman, 2018-2026.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* This module implements The PROXY Protocol v2 */
+
+#ifndef UWS_PROXY_PARSER_H
+#define UWS_PROXY_PARSER_H
+
+#ifdef UWS_WITH_PROXY
+
+namespace uWS {
+
+struct proxy_hdr_v2 {
+    uint8_t sig[12];  /* hex 0D 0A 0D 0A 00 0D 0A 51 55 49 54 0A */
+    uint8_t ver_cmd;  /* protocol version and command */
+    uint8_t fam;      /* protocol family and address */
+    uint16_t len;     /* number of following bytes part of the header */
+};
+
+union proxy_addr {
+    struct {        /* for TCP/UDP over IPv4, len = 12 */
+        uint32_t src_addr;
+        uint32_t dst_addr;
+        uint16_t src_port;
+        uint16_t dst_port;
+    } ipv4_addr;
+    struct {        /* for TCP/UDP over IPv6, len = 36 */
+            uint8_t  src_addr[16];
+            uint8_t  dst_addr[16];
+            uint16_t src_port;
+            uint16_t dst_port;
+    } ipv6_addr;
+};
+
+/* Byte swap for little-endian systems */
+/* Todo: This functions should be shared with the one in WebSocketProtocol.h! */
+template <typename T>
+T _cond_byte_swap(T value) {
+    uint32_t endian_test = 1;
+    if (*((char *)&endian_test)) {
+        union {
+            T i;
+            uint8_t b[sizeof(T)];
+        } src = { value }, dst;
+
+        for (unsigned int i = 0; i < sizeof(value); i++) {
+            dst.b[i] = src.b[sizeof(value) - 1 - i];
+        }
+
+        return dst.i;
+    }
+    return value;
+}
+
+struct ProxyParser {
+private:
+    union proxy_addr addr = {};
+    /* We must always consume all PROXY v2 data, even if done, but we may not overwrite our 
+     * parsed-out data one read for the first time. This property mainly fixes L4 TCP-only
+     * proxying where no HTTP-level cleaning is applied. */
+    bool done = false;
+
+    /* Default family of 0 signals no proxy address */
+    uint8_t family = 0;
+
+public:
+    /* Returns 4 or 16 bytes source address */
+    std::string_view getSourceAddress() {
+
+        // UNSPEC family and protocol
+        if (family == 0) {
+            return {};
+        }
+
+        if ((family & 0xf0) >> 4 == 1) {
+            /* Family 1 is INET4 */
+            return {(char *) &addr.ipv4_addr.src_addr, 4};
+        } else {
+            /* Family 2 is INET6 */
+            return {(char *) &addr.ipv6_addr.src_addr, 16};
+        }
+    }
+
+    unsigned int getSourcePort() {
+
+        // UNSPEC family and protocol
+        if (family == 0) {
+            return {};
+        }
+
+        if ((family & 0xf0) >> 4 == 1) {
+            /* Family 1 is INET4 */
+            return addr.ipv4_addr.src_port;
+        } else {
+            /* Family 2 is INET6 */
+            return addr.ipv6_addr.src_port;
+        }
+    }
+
+    /* Returns [done, consumed] where done = false on failure */
+    std::pair<bool, unsigned int> parse(std::string_view data) {
+
+        /* We require at least four bytes to determine protocol */
+        if (data.length() < 4) {
+            return {false, 0};
+        }
+
+        /* HTTP can never start with "\r\n\r\n", but PROXY always does */
+        if (memcmp(data.data(), "\r\n\r\n", 4)) {
+            /* This is HTTP, so be done */
+            return {true, 0};
+        }
+
+        /* We assume we are parsing PROXY V2 here */
+
+        /* We require 16 bytes here */
+        if (data.length() < 16) {
+            return {false, 0};
+        }
+
+        /* Header is 16 bytes */
+        struct proxy_hdr_v2 header;
+        memcpy(&header, data.data(), 16);
+
+        if (memcmp(header.sig, "\x0D\x0A\x0D\x0A\x00\x0D\x0A\x51\x55\x49\x54\x0A", 12)) {
+            /* This is not PROXY protocol at all */
+            return {false, 0};
+        }
+
+        /* We only support version 2 */
+        if ((header.ver_cmd & 0xf0) >> 4 != 2) {
+            return {false, 0};
+        }
+
+        //printf("Version: %d\n", (header.ver_cmd & 0xf0) >> 4);
+        //printf("Command: %d\n", (header.ver_cmd & 0x0f));
+
+        /* We get length in network byte order (todo: share this function with the rest) */
+        uint16_t hostLength = _cond_byte_swap<uint16_t>(header.len);
+
+        /* We must have all the data available */
+        if (data.length() < 16u + hostLength) {
+            return {false, 0};
+        }
+
+        /* Payload cannot be more than sizeof proxy_addr */
+        if (sizeof(proxy_addr) < hostLength) {
+            return {false, 0};
+        }
+
+        //printf("Family: %d\n", (header.fam & 0xf0) >> 4);
+        //printf("Transport: %d\n", (header.fam & 0x0f));
+
+        /* Copy payload (only if not already done so before) */
+        if (!done) {
+            /* We have 0 family by default, and UNSPEC is 0 as well */
+            family = header.fam;
+
+            memcpy(&addr, data.data() + 16, hostLength);
+
+            done = true;
+        }
+
+        /* We consumed everything */
+        return {true, 16 + hostLength};
+    }
+};
+
+}
+
+#endif
+
+#endif // UWS_PROXY_PARSER_H

package/cpp/uWebSockets/uWebSockets/QueryParser.h

@@ -0,0 +1,120 @@
+/*
+ * Authored by Alex Hultman, 2018-2020.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* This module implements URI query parsing and retrieval of value given key */
+
+#ifndef UWS_QUERYPARSER_H
+#define UWS_QUERYPARSER_H
+
+#include <string_view>
+
+namespace uWS {
+
+    /* Takes raw query including initial '?' sign. Will inplace decode, so input will mutate */
+    static inline std::string_view getDecodedQueryValue(std::string_view key, std::string_view rawQuery) {
+
+        /* Can't have a value without a key */
+        if (!key.length()) {
+            return {};
+        }
+
+        /* Start with the whole querystring including initial '?' */
+        std::string_view queryString = rawQuery;
+
+        /* List of key, value could be cached for repeated fetches similar to how headers are, todo! */
+        while (queryString.length()) {
+            /* Find boundaries of this statement */
+            std::string_view statement = queryString.substr(1, queryString.find('&', 1) - 1);
+
+            /* Only bother if first char of key match (early exit) */
+            if (statement.length() && statement[0] == key[0]) {
+                /* Equal sign must be present and not in the end of statement */
+                auto equality = statement.find('=');
+                if (equality != std::string_view::npos) {
+
+                    std::string_view statementKey = statement.substr(0, equality);
+                    std::string_view statementValue = statement.substr(equality + 1);
+
+                    /* String comparison */
+                    if (key == statementKey) {
+
+                        /* Decode value inplace, put null at end if before length of original */
+                        char *in = (char *) statementValue.data();
+
+                        /* Write offset */
+                        unsigned int out = 0;
+
+                        /* Walk over all chars until end or null char, decoding in place */
+                        for (unsigned int i = 0; i < statementValue.length() && in[i]; i++) {
+                                /* Only bother with '%' */
+                                if (in[i] == '%') {
+                                    /* Do we have enough data for two bytes hex? */
+                                    if (i + 2 >= statementValue.length()) {
+                                        return {};
+                                    }
+
+                                    /* Two bytes hex */
+                                    int hex1 = in[i + 1] - '0';
+                                    if (hex1 > 9) {
+                                        hex1 &= 223;
+                                        hex1 -= 7;
+                                    }
+
+                                    int hex2 = in[i + 2] - '0';
+                                    if (hex2 > 9) {
+                                        hex2 &= 223;
+                                        hex2 -= 7;
+                                    }
+
+                                    *((unsigned char *) &in[out]) = (unsigned char) (hex1 * 16 + hex2);
+                                    i += 2;
+                                } else {
+                                    /* Is this even a rule? */
+                                    if (in[i] == '+') {
+                                        in[out] = ' ';
+                                    } else {
+                                        in[out] = in[i];
+                                    }
+                                }
+
+                                /* We always only write one char */
+                                out++;
+                        }
+
+                        /* If decoded string is shorter than original, put null char to stop next read */
+                        if (out < statementValue.length()) {
+                            in[out] = 0;
+                        }
+
+                        return statementValue.substr(0, out);
+                    }
+                } else {
+                    /* This querystring is invalid, cannot parse it */
+                    return {nullptr, 0};
+                }
+            }
+
+            queryString.remove_prefix(statement.length() + 1);
+        }
+
+        /* Nothing found is given as nullptr, while empty string is given as some pointer to the given buffer */
+        return {nullptr, 0};
+    }
+
+}
+
+#endif