uws-react-native 0.0.1-alpha.1

package/cpp/uSockets/crypto/sni_tree.cpp

@@ -0,0 +1,218 @@
+/*
+ * 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 Server Name Indication hostname tree is written in C++ but could be ported to C.
+ * Overall it looks like crap, but has no memory allocations in fast path and is O(log n). */
+
+#ifndef SNI_TREE_H
+#define SNI_TREE_H
+
+#ifndef LIBUS_NO_SSL
+
+#include <map>
+#include <memory>
+#include <string_view>
+#include <cstring>
+#include <cstdlib>
+#include <algorithm>
+
+/* We only handle a maximum of 10 labels per hostname */
+#define MAX_LABELS 10
+
+/* This cannot be shared */
+thread_local void (*sni_free_cb)(void *);
+
+struct sni_node {
+    /* Empty nodes must always hold null */
+    void *user = nullptr;
+    std::map<std::string_view, std::unique_ptr<sni_node>> children;
+
+    ~sni_node() {
+        for (auto &p : children) {
+            /* The data of our string_views are managed by malloc */
+            free((void *) p.first.data());
+
+            /* Call destructor passed to sni_free only if we hold data.
+             * This is important since sni_remove does not have sni_free_cb set */
+            if (p.second.get()->user) {
+                sni_free_cb(p.second.get()->user);
+            }
+        }
+    }
+};
+
+// this can only delete ONE single node, but may cull "empty nodes with null as data"
+void *removeUser(struct sni_node *root, unsigned int label, std::string_view *labels, unsigned int numLabels) {
+
+    /* If we are in the bottom (past bottom by one), there is nothing to remove */
+    if (label == numLabels) {
+        void *user = root->user;
+        /* Mark us for culling on the way up */
+        root->user = nullptr;
+        return user;
+    }
+
+    /* Is this label a child of root? */
+    auto it = root->children.find(labels[label]);
+    if (it == root->children.end()) {
+        /* We cannot continue */
+        return nullptr;
+    }
+
+    void *removedUser = removeUser(it->second.get(), label + 1, labels, numLabels);
+
+    /* On the way back up, we may cull empty nodes with no children.
+     * This ends up being where we remove all nodes */
+    if (it->second.get()->children.empty() && it->second.get()->user == nullptr) {
+
+        /* The data of our string_views are managed by malloc */
+        free((void *) it->first.data());
+
+        /* This can only happen with user set to null, otherwise we use sni_free_cb which is unset by sni_remove */
+        root->children.erase(it);
+    }
+
+    return removedUser;
+}
+
+void *getUser(struct sni_node *root, unsigned int label, std::string_view *labels, unsigned int numLabels) {
+
+    /* Do we have labels to match? Otherwise, return where we stand */
+    if (label == numLabels) {
+        return root->user;
+    }
+
+    /* Try and match by our label */
+    auto it = root->children.find(labels[label]);
+    if (it != root->children.end()) {
+        void *user = getUser(it->second.get(), label + 1, labels, numLabels);
+        if (user) {
+            return user;
+        }
+    }
+
+    /* Try and match by wildcard */
+    it = root->children.find("*");
+    if (it == root->children.end()) {
+        /* Matching has failed for both label and wildcard */
+        return nullptr;
+    }
+
+    /* We matched by wildcard */
+    return getUser(it->second.get(), label + 1, labels, numLabels);
+}
+
+extern "C" {
+
+    void *sni_new() {
+        return new sni_node;
+    }
+
+    void sni_free(void *sni, void (*cb)(void *)) {
+        /* We want to run this callback for every remaining name */
+        sni_free_cb = cb;
+
+        delete (sni_node *) sni;
+    }
+
+    /* Returns non-null if this name already exists */
+    int sni_add(void *sni, const char *hostname, void *user) {
+        struct sni_node *root = (struct sni_node *) sni;
+
+        /* Traverse all labels in hostname */
+        for (std::string_view view(hostname, strlen(hostname)), label;
+            view.length(); view.remove_prefix(std::min(view.length(), label.length() + 1))) {
+            /* Label is the token separated by dot */
+            label = view.substr(0, view.find('.', 0));
+
+            auto it = root->children.find(label);
+            if (it == root->children.end()) {
+                /* Duplicate this label for our kept string_view of it */
+                void *labelString = malloc(label.length());
+                memcpy(labelString, label.data(), label.length());
+
+                it = root->children.emplace(std::string_view((char *) labelString, label.length()),
+                                            std::make_unique<sni_node>()).first;
+            }
+
+            root = it->second.get();
+        }
+
+        /* We must never add multiple contexts for the same name, as that would overwrite and leak */
+        if (root->user) {
+            return 1;
+        }
+
+        root->user = user;
+
+        return 0;
+    }
+
+    /* Removes the exact match. Wildcards are treated as the verbatim asterisk char, not as an actual wildcard */
+    void *sni_remove(void *sni, const char *hostname) {
+        struct sni_node *root = (struct sni_node *) sni;
+
+        /* I guess 10 labels is an okay limit */
+        std::string_view labels[10];
+        unsigned int numLabels = 0;
+
+        /* We traverse all labels first of all */
+        for (std::string_view view(hostname, strlen(hostname)), label;
+            view.length(); view.remove_prefix(std::min(view.length(), label.length() + 1))) {
+            /* Label is the token separated by dot */
+            label = view.substr(0, view.find('.', 0));
+
+            /* Anything longer than 10 labels is forbidden */
+            if (numLabels == 10) {
+                return nullptr;
+            }
+
+            labels[numLabels++] = label;
+        }
+
+        return removeUser(root, 0, labels, numLabels);
+    }
+
+    void *sni_find(void *sni, const char *hostname) {
+        struct sni_node *root = (struct sni_node *) sni;
+
+        /* I guess 10 labels is an okay limit */
+        std::string_view labels[10];
+        unsigned int numLabels = 0;
+
+        /* We traverse all labels first of all */
+        for (std::string_view view(hostname, strlen(hostname)), label;
+            view.length(); view.remove_prefix(std::min(view.length(), label.length() + 1))) {
+            /* Label is the token separated by dot */
+            label = view.substr(0, view.find('.', 0));
+
+            /* Anything longer than 10 labels is forbidden */
+            if (numLabels == 10) {
+                return nullptr;
+            }
+
+            labels[numLabels++] = label;
+        }
+
+        return getUser(root, 0, labels, numLabels);
+    }
+
+}
+
+#endif
+
+#endif

package/cpp/uSockets/eventing/asio.cpp

@@ -0,0 +1,475 @@
+/*
+ * 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.
+ */
+
+extern "C" {
+    #include "libusockets.h"
+    #include "internal/internal.h"
+    #include <stdlib.h>
+}
+
+#ifdef LIBUS_USE_ASIO
+
+#include <boost/asio.hpp>
+#include <iostream>
+#include <mutex>
+#include <memory>
+#include <boost/version.hpp>
+
+// New interfaces require boost 1.66.0
+#if BOOST_VERSION < 106600
+#define LIBUS_USE_OLD_ASIO
+#define LIBUS_ASIO_DESCRIPTOR boost::asio::posix::stream_descriptor
+#define LIBUS_ASIO_LOOP boost::asio::io_service
+#else
+#define LIBUS_ASIO_DESCRIPTOR boost::asio::posix::descriptor
+#define LIBUS_ASIO_LOOP boost::asio::io_context
+#endif
+
+// setting polls to 1 disables fallthrough
+int polls = 0; // temporary solution keeping track of outstanding work
+
+// define a timer internally as something that inherits from callback_t
+// us_timer_t is convertible to this one
+struct boost_timer : us_internal_callback_t {
+    boost::asio::deadline_timer timer;
+    std::shared_ptr<boost_timer> isValid;
+
+    unsigned char nr = 0;
+
+    boost_timer(LIBUS_ASIO_LOOP *io) : timer(*io) {
+        isValid.reset(this, [](boost_timer *t) {});
+    }
+};
+
+struct boost_block_poll_t : LIBUS_ASIO_DESCRIPTOR {
+
+    boost_block_poll_t(LIBUS_ASIO_LOOP *io, us_poll_t *p) : LIBUS_ASIO_DESCRIPTOR(*io), p(p) {
+        isValid.reset(this, [](boost_block_poll_t *t) {});
+    }
+
+    std::shared_ptr<boost_block_poll_t> isValid;
+
+    unsigned char nr = 0;
+    struct us_poll_t *p;
+};
+
+extern "C" {
+
+// poll
+void us_poll_init(struct us_poll_t *p, LIBUS_SOCKET_DESCRIPTOR fd, int poll_type) {
+    struct boost_block_poll_t *boost_block = (struct boost_block_poll_t *) p->boost_block;
+    boost_block->assign(fd);
+    p->poll_type = poll_type;
+    p->events = 0;
+
+    p->fd = fd; //apparently we access fd after close
+}
+
+void us_poll_free(struct us_poll_t *p, struct us_loop_t *loop) {
+    struct boost_block_poll_t *boost_block = (struct boost_block_poll_t *) p->boost_block;
+
+    delete boost_block;
+    free(p);
+}
+
+void poll_for_error(struct boost_block_poll_t *boost_block) {
+    /* There is no such thing as polling for error in old asio */
+#ifndef LIBUS_USE_OLD_ASIO
+    polls++;
+    boost_block->async_wait(boost::asio::posix::descriptor::wait_type::wait_error, [nr = boost_block->nr, weakBoostBlock = std::weak_ptr<boost_block_poll_t>(boost_block->isValid)](boost::system::error_code ec) {
+        polls--;
+        
+        if (ec != boost::asio::error::operation_aborted) {
+
+            // post mortem check
+            struct boost_block_poll_t *boost_block;
+            if (auto observe = weakBoostBlock.lock()) {
+                boost_block = observe.get();
+            } else {
+                return;
+            }
+
+            // get boost_block from weakptr
+            if (nr != boost_block->nr) {
+                return;
+            }
+
+            poll_for_error(boost_block); // ska man verkligen polla for error igen
+            us_internal_dispatch_ready_poll(boost_block->p, 1, LIBUS_SOCKET_READABLE | LIBUS_SOCKET_WRITABLE);
+        }
+    });
+#endif
+}
+
+void poll_for_read(struct boost_block_poll_t *boost_block);
+
+inline void handle_read(const std::weak_ptr<boost_block_poll_t> &weakBoostBlock, unsigned char nr, boost::system::error_code ec) {
+    if (ec != boost::asio::error::operation_aborted) {
+
+        // post mortem check
+        struct boost_block_poll_t *boost_block;
+        if (auto observe = weakBoostBlock.lock()) {
+            boost_block = observe.get();
+        } else {
+            return;
+        }
+
+        // get boost_block from weakptr
+        if (nr != boost_block->nr) {
+            return;
+        }
+
+        poll_for_read(boost_block);
+        us_internal_dispatch_ready_poll(boost_block->p, ec ? -1 : 0, LIBUS_SOCKET_READABLE);
+    }
+}
+
+void poll_for_read(struct boost_block_poll_t *boost_block) {
+    polls++;
+#ifndef LIBUS_USE_OLD_ASIO
+    boost_block->async_wait(boost::asio::posix::descriptor::wait_type::wait_read, [nr = boost_block->nr, weakBoostBlock = std::weak_ptr<boost_block_poll_t>(boost_block->isValid)](boost::system::error_code ec) {
+        polls--;
+        handle_read(weakBoostBlock, nr, ec);
+    });
+#else
+    boost_block->async_read_some(boost::asio::null_buffers(), [nr = boost_block->nr, weakBoostBlock = std::weak_ptr<boost_block_poll_t>(boost_block->isValid)](boost::system::error_code ec, std::size_t) {
+        polls--;
+        handle_read(weakBoostBlock, nr, ec);
+    });
+#endif
+}
+
+void poll_for_write(struct boost_block_poll_t *boost_block);
+
+inline void handle_write(const std::weak_ptr<boost_block_poll_t> &weakBoostBlock, unsigned char nr, boost::system::error_code ec) {
+    if (ec != boost::asio::error::operation_aborted) {
+
+        // post mortem check
+        struct boost_block_poll_t *boost_block;
+        if (auto observe = weakBoostBlock.lock()) {
+            boost_block = observe.get();
+        } else {
+            return;
+        }
+
+        // get boost_block from weakptr
+        if (nr != boost_block->nr) {
+            return;
+        }
+        poll_for_write(boost_block);
+        us_internal_dispatch_ready_poll(boost_block->p, ec ? -1 : 0, LIBUS_SOCKET_WRITABLE);
+    }
+}
+
+void poll_for_write(struct boost_block_poll_t *boost_block) {
+    polls++;
+#ifndef LIBUS_USE_OLD_ASIO
+    boost_block->async_wait(boost::asio::posix::descriptor::wait_type::wait_write, [nr = boost_block->nr, weakBoostBlock = std::weak_ptr<boost_block_poll_t>(boost_block->isValid)](boost::system::error_code ec) {
+        polls--;
+        handle_write(weakBoostBlock, nr, ec);
+    });
+#else
+    boost_block->async_write_some(boost::asio::null_buffers(), [nr = boost_block->nr, weakBoostBlock = std::weak_ptr<boost_block_poll_t>(boost_block->isValid)](boost::system::error_code ec, std::size_t) {
+        polls--;
+        handle_write(weakBoostBlock, nr, ec);
+    });
+#endif
+}
+
+void us_poll_start(struct us_poll_t *p, struct us_loop_t *loop, int events) {
+    struct boost_block_poll_t *boost_block = (struct boost_block_poll_t *) p->boost_block;
+
+    p->events = events;
+    poll_for_error(boost_block);
+
+    if (events & LIBUS_SOCKET_READABLE) {
+        poll_for_read(boost_block);
+    }
+
+    if (events & LIBUS_SOCKET_WRITABLE) {
+        poll_for_write(boost_block);
+    }
+}
+
+void us_poll_change(struct us_poll_t *p, struct us_loop_t *loop, int events) {
+    struct boost_block_poll_t *boost_block = (struct boost_block_poll_t *) p->boost_block;
+
+    boost_block->nr++;
+    boost_block->cancel();
+
+    us_poll_start(p, loop, events);
+}
+
+void us_poll_stop(struct us_poll_t *p, struct us_loop_t *loop) {
+    struct boost_block_poll_t *boost_block = (struct boost_block_poll_t *) p->boost_block;
+
+    boost_block->nr++;
+    boost_block->release();
+}
+
+int us_poll_events(struct us_poll_t *p) {
+    return p->events;
+}
+
+unsigned int us_internal_accept_poll_event(struct us_poll_t *p) {
+    return 0;
+}
+
+int us_internal_poll_type(struct us_poll_t *p) {
+    return p->poll_type;
+}
+
+void us_internal_poll_set_type(struct us_poll_t *p, int poll_type) {
+    p->poll_type = poll_type;
+}
+
+LIBUS_SOCKET_DESCRIPTOR us_poll_fd(struct us_poll_t *p) {
+    struct boost_block_poll_t *boost_block = (struct boost_block_poll_t *) p->boost_block;
+
+
+    return p->fd;
+
+    //return boost_block->native_handle();
+}
+
+// if we get an io_context ptr as hint, we use it
+// otherwise we create a new one for only us
+struct us_loop_t *us_create_loop(void *hint, void (*wakeup_cb)(struct us_loop_t *loop), void (*pre_cb)(struct us_loop_t *loop), void (*post_cb)(struct us_loop_t *loop), unsigned int ext_size) {
+    struct us_loop_t *loop = (struct us_loop_t *) malloc(sizeof(struct us_loop_t) + ext_size);
+
+    loop->io = hint ? hint : new LIBUS_ASIO_LOOP();
+    loop->is_default = hint != 0;
+
+    // here we create two unreffed handles - timer and async
+    us_internal_loop_data_init(loop, wakeup_cb, pre_cb, post_cb);
+
+    // if we do not own this loop, we need to integrate and set up timer
+    if (hint) {
+        us_loop_integrate(loop);
+    }
+
+    return loop;
+}
+
+// based on if this was default loop or not
+void us_loop_free(struct us_loop_t *loop) {
+    us_internal_loop_data_free(loop);
+
+    if (!loop->is_default) {
+        delete (LIBUS_ASIO_LOOP *) loop->io;
+    }
+
+    free(loop);
+}
+
+// we need fallthrough to correspond to our polls
+// therefore we exit when our polls are 0
+// if third party asio server wants to keep the loop running
+// they have to use a guard such as a us_timer_t
+void us_loop_run(struct us_loop_t *loop) {
+    us_loop_integrate(loop);
+
+    // this way of running adds one extra epoll_wait per event loop iteration
+    // but does not add per-poll overhead. besides, asio is sprinkled with inefficiencies
+    // everywhere so it's negligible for what it solves (we must have pre, post callbacks)
+    while (polls) {
+        us_internal_loop_pre(loop);
+        size_t num = ((LIBUS_ASIO_LOOP *) loop->io)->run_one();
+        if (!num) {
+            break;
+        }
+        
+        for (int i = 0; true; i++) {
+            num = ((LIBUS_ASIO_LOOP *) loop->io)->poll_one();
+            if (!num || i == 999) {
+                break;
+            }
+        }
+        us_internal_loop_post(loop);
+    }
+}
+
+struct us_poll_t *us_create_poll(struct us_loop_t *loop, int fallthrough, unsigned int ext_size) {
+    struct us_poll_t *p = (struct us_poll_t *) malloc(sizeof(struct us_poll_t) + ext_size);
+    p->boost_block = new boost_block_poll_t( (LIBUS_ASIO_LOOP *)loop->io, p);
+
+    return p;
+}
+
+/* If we update our block position we have to updarte the uv_poll data to point to us */
+struct us_poll_t *us_poll_resize(struct us_poll_t *p, struct us_loop_t *loop, unsigned int ext_size) {
+    p = (struct us_poll_t *) realloc(p, sizeof(struct us_poll_t) + ext_size);
+
+    // captures must never capture p directly, only boost_block and derive p from there
+    ((struct boost_block_poll_t *) p->boost_block)->p = p;
+
+    return p;
+}
+
+// timer
+struct us_timer_t *us_create_timer(struct us_loop_t *loop, int fallthrough, unsigned int ext_size) {
+    struct boost_timer *cb = (struct boost_timer *) malloc(sizeof(struct boost_timer) + ext_size);
+
+    // inplace construct the timer on this callback_t
+    new (cb) boost_timer((LIBUS_ASIO_LOOP *)loop->io);
+
+    cb->loop = loop;
+    cb->cb_expects_the_loop = 0;
+    cb->p.poll_type = POLL_TYPE_CALLBACK; // this is missing from libuv flow
+
+    if (fallthrough) {
+        //uv_unref((uv_handle_t *) uv_timer);
+    }
+
+    return (struct us_timer_t *) cb;
+}
+
+void *us_timer_ext(struct us_timer_t *timer) {
+    return ((struct boost_timer *) timer) + 1;
+}
+
+void us_timer_close(struct us_timer_t *t) {
+    ((boost_timer *) t)->timer.cancel();
+    ((boost_timer *) t)->~boost_timer();
+    free(t);
+}
+
+void poll_for_timeout(struct boost_timer *b_timer, int repeat_ms) {
+    b_timer->timer.async_wait([nr = b_timer->nr, repeat_ms, weakBoostBlock = std::weak_ptr<boost_timer>(b_timer->isValid)](const boost::system::error_code &ec) {
+        if (ec != boost::asio::error::operation_aborted) {
+
+            struct boost_timer *b_timer;
+            if (auto observe = weakBoostBlock.lock()) {
+                b_timer = observe.get();
+            } else {
+                return;
+            }
+
+            if (nr != b_timer->nr) {
+                return;
+            }
+
+            if (repeat_ms) {
+
+                if (!polls) {
+                    // we do fallthrough if no other polling
+                    // this is problematic if WE fallthrough
+                    // but other parts do not
+                    // that causes timeouts to stop working
+                    // we should really ask the executor if there is work
+                    // if there is, then continue ticking until there isn't
+                    return;
+                }
+
+                b_timer->timer.expires_at(b_timer->timer.expires_at() + boost::posix_time::milliseconds(repeat_ms));
+                poll_for_timeout(b_timer, repeat_ms);
+            }
+            us_internal_dispatch_ready_poll((struct us_poll_t *)b_timer, 0, LIBUS_SOCKET_READABLE);
+        }
+    });
+}
+
+void us_timer_set(struct us_timer_t *t, void (*cb)(struct us_timer_t *t), int ms, int repeat_ms) {
+    struct boost_timer *b_timer = (struct boost_timer *) t;
+
+    if (!ms) {
+        b_timer->nr++;
+        b_timer->timer.cancel();
+    } else {
+        b_timer->cb = (void(*)(struct us_internal_callback_t *)) cb;
+
+        b_timer->timer.expires_from_now(boost::posix_time::milliseconds(ms));
+        poll_for_timeout(b_timer, repeat_ms);
+    }
+}
+
+struct us_loop_t *us_timer_loop(struct us_timer_t *t) {
+    struct us_internal_callback_t *internal_cb = (struct us_internal_callback_t *) t;
+
+    return internal_cb->loop;
+}
+
+// async (internal only) probably map to io_context::post
+struct boost_async : us_internal_callback_t {
+    std::mutex m;
+    std::shared_ptr<boost_async> isValid;
+
+    boost_async() {
+        isValid.reset(this, [](boost_async *a) {});
+    }
+};
+
+struct us_internal_async *us_internal_create_async(struct us_loop_t *loop, int fallthrough, unsigned int ext_size) {
+    struct boost_async *cb = (struct boost_async *) malloc(sizeof(struct boost_async) + ext_size);
+
+    // inplace construct
+    new (cb) boost_async();
+
+    // these properties are accessed from another thread when wakeup
+    cb->m.lock();
+    cb->loop = loop; // the only lock needed
+    cb->cb_expects_the_loop = 0;
+    cb->p.poll_type = POLL_TYPE_CALLBACK; // this is missing from libuv flow
+    cb->m.unlock();
+
+    if (fallthrough) {
+        //uv_unref((uv_handle_t *) uv_timer);
+    }
+
+    return (struct us_internal_async *) cb;
+}
+
+void us_internal_async_close(struct us_internal_async *a) {
+    ((boost_async *) a)->~boost_async();
+    free(a);
+}
+
+void us_internal_async_set(struct us_internal_async *a, void (*cb)(struct us_internal_async *)) {
+    struct boost_async *internal_cb = (struct boost_async *) a;
+
+    internal_cb->cb = (void(*)(struct us_internal_callback_t *)) cb;
+}
+
+void us_internal_async_wakeup(struct us_internal_async *a) {
+    struct boost_async *cb = (struct boost_async *) a;
+
+    // this doesn't really guarantee loop.io being visible here
+    // really we should use the loops mutex, and have the loops constructor
+    // use its own mutex, then we are guaranteed to have visibility here
+    cb->m.lock();
+    LIBUS_ASIO_LOOP *io = (LIBUS_ASIO_LOOP *)cb->loop->io;
+    cb->m.unlock();
+
+    // should increase and decrease polls (again, loop mutex)
+    io->post([weakBoostBlock = std::weak_ptr<boost_async>(cb->isValid)]() {
+
+        // was the async deleted before we came here?
+        struct boost_async *cb;
+        if (auto observe = weakBoostBlock.lock()) {
+            cb = observe.get();
+        } else {
+            return;
+        }
+
+        us_internal_dispatch_ready_poll((struct us_poll_t *) cb, 0, 0);
+
+    });
+}
+
+}
+
+#endif