uws-react-native 0.0.1-alpha.1

package/cpp/uWebSockets/uWebSockets/ChunkedEncoding.h

@@ -0,0 +1,237 @@
+/*
+ * 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.
+ */
+
+#ifndef UWS_CHUNKEDENCODING_H
+#define UWS_CHUNKEDENCODING_H
+
+/* Independent chunked encoding parser, used by HttpParser. */
+
+#include <string>
+#include <cstring>
+#include <cstdlib>
+#include <algorithm>
+#include <string_view>
+#include "MoveOnlyFunction.h"
+#include <optional>
+
+namespace uWS {
+
+    constexpr uint64_t STATE_HAS_SIZE = 1ull << (sizeof(uint64_t) * 8 - 1);//0x80000000;
+    constexpr uint64_t STATE_IS_CHUNKED = 1ull << (sizeof(uint64_t) * 8 - 2);//0x40000000;
+    constexpr uint64_t STATE_SIZE_MASK = ~(3ull << (sizeof(uint64_t) * 8 - 2));//0x3FFFFFFF;
+    constexpr uint64_t STATE_IS_ERROR = ~0ull;//0xFFFFFFFF;
+    constexpr uint64_t STATE_SIZE_OVERFLOW = 0x0Full << (sizeof(uint64_t) * 8 - 8);//0x0F000000;
+
+    inline uint64_t chunkSize(uint64_t state) {
+        return state & STATE_SIZE_MASK;
+    }
+
+    /* Reads hex number until CR or out of data to consume. Updates state. Returns bytes consumed. */
+    inline void consumeHexNumber(std::string_view &data, uint64_t &state) {
+        /* Consume everything higher than 32 */
+        while (data.length() && data.data()[0] > 32) {
+
+            unsigned char digit = (unsigned char)data.data()[0];
+            if (digit >= 'a') {
+                digit = (unsigned char) (digit - ('a' - ':'));
+            } else if (digit >= 'A') {
+                digit = (unsigned char) (digit - ('A' - ':'));
+            }
+
+            unsigned int number = ((unsigned int) digit - (unsigned int) '0');
+
+            if (number > 16 || (chunkSize(state) & STATE_SIZE_OVERFLOW)) {
+                state = STATE_IS_ERROR;
+                return;
+            }
+
+            // extract state bits
+            uint64_t bits = /*state &*/ STATE_IS_CHUNKED;
+
+            state = (state & STATE_SIZE_MASK) * 16ull + number;
+
+            state |= bits;
+            data.remove_prefix(1);
+        }
+        /* Consume everything not /n */
+        while (data.length() && data.data()[0] != '\n') {
+            data.remove_prefix(1);
+        }
+        /* Now we stand on \n so consume it and enable size */
+        if (data.length()) {
+            state += 2; // include the two last /r/n
+            state |= STATE_HAS_SIZE | STATE_IS_CHUNKED;
+            data.remove_prefix(1);
+        }
+    }
+
+    inline void decChunkSize(uint64_t &state, unsigned int by) {
+
+        //unsigned int bits = state & STATE_IS_CHUNKED;
+
+        state = (state & ~STATE_SIZE_MASK) | (chunkSize(state) - by);
+
+        //state |= bits;
+    }
+
+    inline bool hasChunkSize(uint64_t state) {
+        return state & STATE_HAS_SIZE;
+    }
+
+    /* Are we in the middle of parsing chunked encoding? */
+    inline bool isParsingChunkedEncoding(uint64_t state) {
+        return state & ~STATE_SIZE_MASK;
+    }
+
+    inline bool isParsingInvalidChunkedEncoding(uint64_t state) {
+        return state == STATE_IS_ERROR;
+    }
+
+    /* Returns next chunk (empty or not), or if all data was consumed, nullopt is returned. */
+    static std::optional<std::string_view> getNextChunk(std::string_view &data, uint64_t &state, bool trailer = false) {
+
+        while (data.length()) {
+
+            // if in "drop trailer mode", just drop up to what we have as size
+            if (((state & STATE_IS_CHUNKED) == 0) && hasChunkSize(state) && chunkSize(state)) {
+
+                //printf("Parsing trailer now\n");
+
+                while(data.length() && chunkSize(state)) {
+                    data.remove_prefix(1);
+                    decChunkSize(state, 1);
+
+                    if (chunkSize(state) == 0) {
+
+                        /* This is an actual place where we need 0 as state */
+                        state = 0;
+
+                        /* The parser MUST stop consuming here */
+                        return std::nullopt;
+                    }
+                }
+                continue;
+            }
+
+            if (!hasChunkSize(state)) {
+                consumeHexNumber(data, state);
+                if (isParsingInvalidChunkedEncoding(state)) {
+                    return std::nullopt;
+                }
+                if (hasChunkSize(state) && chunkSize(state) == 2) {
+
+                    //printf("Setting state to trailer-parsing and emitting empty chunk\n");
+
+                    // set trailer state and increase size to 4
+                    if (trailer) {
+                        state = 4 /*| STATE_IS_CHUNKED*/ | STATE_HAS_SIZE;
+                    } else {
+                        state = 2 /*| STATE_IS_CHUNKED*/ | STATE_HAS_SIZE;
+                    }
+
+                    return std::string_view(nullptr, 0);
+                }
+                continue;
+            }
+
+            // do we have data to emit all?
+            if (data.length() >= chunkSize(state)) {
+                // emit all but 2 bytes then reset state to 0 and goto beginning
+                // not fin
+                std::string_view emitSoon;
+                bool shouldEmit = false;
+                if (chunkSize(state) > 2) {
+                    emitSoon = std::string_view(data.data(), chunkSize(state) - 2);
+                    shouldEmit = true;
+                }
+                data.remove_prefix(chunkSize(state));
+                state = STATE_IS_CHUNKED;
+                if (shouldEmit) {
+                    return emitSoon;
+                }
+                continue;
+            } else {
+                /* We will consume all our input data */
+                std::string_view emitSoon;
+                if (chunkSize(state) > 2) {
+                    uint64_t maximalAppEmit = chunkSize(state) - 2;
+                    if (data.length() > maximalAppEmit) {
+                        emitSoon = data.substr(0, maximalAppEmit);
+                    } else {
+                        //cb(data);
+                        emitSoon = data;
+                    }
+                }
+                decChunkSize(state, (unsigned int) data.length());
+                state |= STATE_IS_CHUNKED;
+                // new: decrease data by its size (bug)
+                data.remove_prefix(data.length()); // ny bug fix för getNextChunk
+                if (emitSoon.length()) {
+                    return emitSoon;
+                } else {
+                    return std::nullopt;
+                }
+            }
+        }
+
+        return std::nullopt;
+    }
+
+    /* This is really just a wrapper for convenience */
+    struct ChunkIterator {
+
+        std::string_view *data;
+        std::optional<std::string_view> chunk;
+        uint64_t *state;
+        bool trailer;
+
+        ChunkIterator(std::string_view *data, uint64_t *state, bool trailer = false) : data(data), state(state), trailer(trailer) {
+            chunk = uWS::getNextChunk(*data, *state, trailer);
+        }
+
+        ChunkIterator() {
+
+        }
+
+        ChunkIterator begin() {
+            return *this;
+        }
+
+        ChunkIterator end() {
+            return ChunkIterator();
+        }
+
+        std::string_view operator*() {
+            if (!chunk.has_value()) {
+                std::abort();
+            }
+            return chunk.value();
+        }
+
+        bool operator!=(const ChunkIterator &other) const {
+            return other.chunk.has_value() != chunk.has_value();
+        }
+
+        ChunkIterator &operator++() {
+            chunk = uWS::getNextChunk(*data, *state, trailer);
+            return *this;
+        }
+
+    };
+}
+
+#endif // UWS_CHUNKEDENCODING_H

package/cpp/uWebSockets/uWebSockets/ClientApp.h

@@ -0,0 +1,36 @@
+#include "MoveOnlyFunction.h"
+#include "WebSocketContext.h"
+#include <string>
+
+namespace uWS {
+
+    struct WebSocketClientBehavior {
+        MoveOnlyFunction<void()> open;
+        MoveOnlyFunction<void()> message;
+        MoveOnlyFunction<void()> close;
+        //MoveOnlyFunction<void()> failed;
+
+    };
+
+    struct ClientApp {
+
+        WebSocketContext<0, false, int> *webSocketContext;
+        // behöver ett nytt http context med minimal klient, som slår om till den riktiga websocketcontext
+        // om samma storlek på httpsocket och websocket blir det enkel övergång
+
+        ClientApp(WebSocketClientBehavior &&behavior) {
+            //webSocketContext = WebSocketContext<0, false, int>::create();
+        }
+
+        ClientApp &&connect(std::string url, std::string protocol = "") {
+
+            return std::move(*this);
+        }
+
+        void run() {
+
+        }
+
+    };
+
+}

package/cpp/uWebSockets/uWebSockets/Http3App.h

@@ -0,0 +1,140 @@
+#include "App.h"
+
+#include "Http3Response.h"
+#include "Http3Request.h"
+#include "Http3Context.h"
+
+namespace uWS {
+
+    struct H3App {
+        Http3Context *http3Context;
+
+        H3App(SocketContextOptions options = {}) {
+            /* This conversion should not be needed */
+            us_quic_socket_context_options_t h3options = {};
+
+            h3options.key_file_name = strdup(options.key_file_name);
+            h3options.cert_file_name = strdup(options.cert_file_name);
+            h3options.passphrase = strdup(options.passphrase);
+
+            /* Create the http3 context */
+            http3Context = Http3Context::create((us_loop_t *)Loop::get(), h3options);
+
+            http3Context->init();
+        }
+
+        /* Disallow copying, only move */
+        H3App(const H3App &other) = delete;
+
+        H3App(H3App &&other) {
+            /* Move HttpContext */
+            http3Context = other.http3Context;
+            other.http3Context = nullptr;
+        }
+
+        /* Host, port, callback */
+        H3App &&listen(std::string host, int port, MoveOnlyFunction<void(us_listen_socket_t *)> &&handler) {
+            if (!host.length()) {
+                return listen(port, std::move(handler));
+            }
+            handler(http3Context ? (us_listen_socket_t *) http3Context->listen(host.c_str(), port) : nullptr);
+            return std::move(*this);
+        }
+
+        /* Host, port, options, callback */
+        H3App &&listen(std::string host, int port, int options, MoveOnlyFunction<void(us_listen_socket_t *)> &&handler) {
+            if (!host.length()) {
+                return listen(port, options, std::move(handler));
+            }
+            handler(http3Context ? (us_listen_socket_t *) http3Context->listen(host.c_str(), port) : nullptr);
+            return std::move(*this);
+        }
+
+        /* Port, callback */
+        H3App &&listen(int port, MoveOnlyFunction<void(us_listen_socket_t *)> &&handler) {
+            handler(http3Context ? (us_listen_socket_t *) http3Context->listen(nullptr, port) : nullptr);
+            return std::move(*this);
+        }
+
+        /* Port, options, callback */
+        H3App &&listen(int port, int options, MoveOnlyFunction<void(us_listen_socket_t *)> &&handler) {
+            handler(http3Context ? (us_listen_socket_t *) http3Context->listen(nullptr, port) : nullptr);
+            return std::move(*this);
+        }
+
+        H3App &&get(std::string pattern, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&handler) {
+            if (http3Context) {
+                http3Context->onHttp("GET", pattern, std::move(handler));
+            }
+            return std::move(*this);
+        }
+
+        H3App &&post(std::string pattern, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&handler) {
+            if (http3Context) {
+                http3Context->onHttp("POST", pattern, std::move(handler));
+            }
+            return std::move(*this);
+        }
+
+        H3App &&options(std::string pattern, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&handler) {
+            if (http3Context) {
+                http3Context->onHttp("OPTIONS", pattern, std::move(handler));
+            }
+            return std::move(*this);
+        }
+
+        H3App &&del(std::string pattern, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&handler) {
+            if (http3Context) {
+                http3Context->onHttp("DELETE", pattern, std::move(handler));
+            }
+            return std::move(*this);
+        }
+
+        H3App &&patch(std::string pattern, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&handler) {
+            if (http3Context) {
+                http3Context->onHttp("PATCH", pattern, std::move(handler));
+            }
+            return std::move(*this);
+        }
+
+        H3App &&put(std::string pattern, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&handler) {
+            if (http3Context) {
+                http3Context->onHttp("PUT", pattern, std::move(handler));
+            }
+            return std::move(*this);
+        }
+
+        H3App &&head(std::string pattern, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&handler) {
+            if (http3Context) {
+                http3Context->onHttp("HEAD", pattern, std::move(handler));
+            }
+            return std::move(*this);
+        }
+
+        H3App &&connect(std::string pattern, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&handler) {
+            if (http3Context) {
+                http3Context->onHttp("CONNECT", pattern, std::move(handler));
+            }
+            return std::move(*this);
+        }
+
+        H3App &&trace(std::string pattern, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&handler) {
+            if (http3Context) {
+                http3Context->onHttp("TRACE", pattern, std::move(handler));
+            }
+            return std::move(*this);
+        }
+
+        /* This one catches any method */
+        H3App &&any(std::string pattern, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&handler) {
+            if (http3Context) {
+                http3Context->onHttp("*", pattern, std::move(handler));
+            }
+            return std::move(*this);
+        }
+
+        void run() {
+            uWS::Loop::get()->run();
+        }
+    };
+}

package/cpp/uWebSockets/uWebSockets/Http3Context.h

@@ -0,0 +1,157 @@
+
+extern "C" {
+#include "quic.h"
+}
+
+#include "Http3ContextData.h"
+#include "Http3ResponseData.h"
+
+namespace uWS {
+    struct Http3Context {
+        static Http3Context *create(us_loop_t *loop, us_quic_socket_context_options_t options) {
+
+            /* Create quic socket context (assumes h3 for now) */
+            auto *context = us_create_quic_socket_context(loop, options, sizeof(Http3ContextData));
+
+            /* Specify application callbacks */
+            us_quic_socket_context_on_stream_data(context, [](us_quic_stream_t *s, char *data, int length) {
+
+                Http3ResponseData *responseData = (Http3ResponseData *) us_quic_stream_ext(s);
+                
+                /* We never emit FIN here */
+                if (responseData->onData) {
+                    responseData->onData({data, (size_t) length}, false);
+                }
+            });
+            us_quic_socket_context_on_stream_end(context, [](us_quic_stream_t *s) {
+
+                Http3ResponseData *responseData = (Http3ResponseData *) us_quic_stream_ext(s);
+                
+                /* Emit FIN to app */
+                if (responseData->onData) {
+                    responseData->onData({nullptr, 0}, true);
+                }
+
+                /* Have we written our entire backpressure, if any? */
+                // if (responseData->buffer.length() && (responseData->bufferOffset == (int) responseData->buffer.length())) {
+                //     printf("We got FIN and we have no backpressure, closing stream now!\n");
+                //     //us_quic_stream_close(s);
+                // } else {
+                //     //printf("We got FIN but we have data to write, so keeping connection half-closed!\n");
+                // }
+
+            });
+            us_quic_socket_context_on_stream_open(context, [](us_quic_stream_t *s, int is_client) {
+
+                printf("Stream open!\n");
+
+                /* Inplace init our per stream data */
+                new (us_quic_stream_ext(s)) Http3ResponseData();
+            });
+            us_quic_socket_context_on_close(context, [](us_quic_socket_t *s) {
+                printf("QUIC socket disconnected!\n");
+            });
+            us_quic_socket_context_on_stream_writable(context, [](us_quic_stream_t *s) {
+                Http3ResponseData *responseData = (Http3ResponseData *) us_quic_stream_ext(s);
+
+                /* Either we handle the streaming or we let the application handle it */
+                if (responseData->onWritable) {
+                    responseData->onWritable(responseData->offset);
+                } else {
+                    int written = us_quic_stream_write(s, (char *) responseData->backpressure.data(), responseData->backpressure.length());
+                    responseData->backpressure.erase(written);
+
+                    if (responseData->backpressure.length() == 0) {
+                        printf("wrote until end, shutting down now!\n");
+                        us_quic_stream_shutdown(s);
+                        us_quic_stream_close(s);
+                    }
+                }
+            });
+            us_quic_socket_context_on_stream_headers(context, [](us_quic_stream_t *s) {
+
+                /* This is the main place of start for requests */
+                Http3ContextData *contextData = (Http3ContextData *) us_quic_socket_context_ext(us_quic_socket_context(us_quic_stream_socket(s)));
+
+                Http3Request *req = nullptr;
+
+                std::string_view upperCasedMethod = req->getHeader(":method");
+                std::string_view path = req->getHeader(":path");
+                
+                contextData->router.getUserData() = {(Http3Response *) s, (Http3Request *) nullptr};
+                contextData->router.route(upperCasedMethod, path);
+
+            });
+            us_quic_socket_context_on_open(context, [](us_quic_socket_t *s, int is_client) {
+                printf("QUIC socket connected!\n");
+            });
+            us_quic_socket_context_on_stream_close(context, [](us_quic_stream_t *s) {
+
+                printf("Stream closed!\n");
+
+                //lsquic_stream_has_unacked_data
+
+                Http3ResponseData *responseData = (Http3ResponseData *) us_quic_stream_ext(s);
+                
+                if (responseData->onAborted) {
+                    responseData->onAborted();
+                }
+
+                //printf("Freeing per stream data in on_stream_close in uws!\n");
+
+                responseData->~Http3ResponseData();
+            });
+
+            return (Http3Context *) context;
+
+            // call init here after setting the ext to Http3ContextData
+        }
+
+        us_quic_listen_socket_t *listen(const char *host, int port) {
+            /* The listening socket is the actual UDP socket used */
+            us_quic_listen_socket_t *listen_socket = us_quic_socket_context_listen((us_quic_socket_context_t *) this, host, port, sizeof(Http3ResponseData));
+
+            //printf("Listen socket is: %p\n", listen_socket);
+
+            return listen_socket;
+        }
+
+        void init() {
+            // set all callbacks here
+
+
+
+            Http3ContextData *contextData = (Http3ContextData *) us_quic_socket_context_ext((us_quic_socket_context_t *) this);
+
+            //printf("init: %p\n", contextData);
+
+            new (contextData) Http3ContextData();
+
+        }
+
+        // generic for get, post, any, etc
+        void onHttp(std::string method, std::string path, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&cb) {
+            // modifies the router we own as part of Http3ContextData, used in callbacks set in init
+        
+            Http3ContextData *contextData = (Http3ContextData *) us_quic_socket_context_ext((us_quic_socket_context_t *) this);
+
+            /* Todo: This is ugly, fix */
+            std::vector<std::string> methods;
+            if (method == "*") {
+                methods = {"*"}; //bug! needs to be upper cased!
+                // router.upperCasedMethods;
+            } else {
+                methods = {method};
+            }
+
+            contextData->router.add(methods, path, [handler = std::move(cb)](HttpRouter<Http3ContextData::RouterData> *router) mutable {
+
+                Http3ContextData::RouterData &routerData = router->getUserData();
+
+                handler(routerData.res, routerData.req);
+
+                return true;
+            });
+        }
+    };
+}

package/cpp/uWebSockets/uWebSockets/Http3ContextData.h

@@ -0,0 +1,21 @@
+#include "HttpRouter.h"
+
+struct Http3Response;
+struct Http3Request;
+
+namespace uWS {
+
+    struct Http3ContextData {
+        struct RouterData {
+            Http3Response *res;
+            Http3Request *req;
+        };
+
+        HttpRouter<RouterData> router;
+
+        Http3ContextData() {
+            //printf("Constructing http3contextdata: %p\n", this);
+        }
+    };
+    
+}

package/cpp/uWebSockets/uWebSockets/Http3Request.h

@@ -0,0 +1,22 @@
+extern "C" {
+#include "quic.h"
+}
+
+namespace uWS {
+
+    struct Http3Request {
+
+        std::string_view getHeader(std::string_view key) {
+            for (int i = 0, more = 1; more; i++) {
+                char *name, *value;
+                int name_length, value_length;
+                if ((more = us_quic_socket_context_get_header(nullptr, i, &name, &name_length, &value, &value_length))) {
+                    if (name_length == (int) key.length() && !memcmp(name, key.data(), key.length())) {
+                        return {value, (size_t) value_length};
+                    }
+                }
+            }
+            return {nullptr, 0};
+        }
+    };
+}