opal-up 0.0.2 → 0.0.3

data/ext/up_ext/ProxyParser.h

@@ -0,0 +1,163 @@
+/*
+ * 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 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;
+
+    /* 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};
+        }
+    }
+
+    /* 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));
+
+        /* We have 0 family by default, and UNSPEC is 0 as well */
+        family = header.fam;
+
+        /* Copy payload */
+        memcpy(&addr, data.data() + 16, hostLength);
+
+        /* We consumed everything */
+        return {true, 16 + hostLength};
+    }
+};
+
+}
+
+#endif
+
+#endif // UWS_PROXY_PARSER_H

data/ext/up_ext/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

data/ext/up_ext/TopicTree.h

@@ -0,0 +1,363 @@
+/*
+ * 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.
+ */
+
+#ifndef UWS_TOPICTREE_H
+#define UWS_TOPICTREE_H
+
+#include <map>
+#include <list>
+#include <iostream>
+#include <unordered_set>
+#include <utility>
+#include <memory>
+#include <unordered_map>
+#include <vector>
+#include <string_view>
+#include <functional>
+#include <set>
+#include <string>
+
+namespace uWS {
+
+struct Subscriber;
+
+struct Topic : std::unordered_set<Subscriber *> {
+
+    Topic(std::string_view topic) : name(topic) {
+
+    }
+
+    std::string name;
+};
+
+struct Subscriber {
+
+    template <typename, typename> friend struct TopicTree;
+
+private:
+    /* We use a factory */
+    Subscriber() = default;
+
+    /* State of prev, next does not matter unless we are needsDrainage() since we are not in the list */
+    Subscriber *prev, *next;
+
+    /* Any one subscriber can be part of at most 32 publishes before it needs a drain,
+     * or whatever encoding of runs or whatever we might do in the future */
+    uint16_t messageIndices[32];
+
+    /* This one matters the most, if it is 0 we are not in the list of drainableSubscribers */
+    unsigned char numMessageIndices = 0;
+
+public:
+
+    /* We have a list of topics we subscribe to (read by WebSocket::iterateTopics) */
+    std::set<Topic *> topics;
+
+    /* User data */
+    void *user;
+
+    bool needsDrainage() {
+        return numMessageIndices;
+    }
+};
+
+template <typename T, typename B>
+struct TopicTree {
+
+    enum IteratorFlags {
+        LAST = 1,
+        FIRST = 2
+    };
+
+    /* Whomever is iterating this topic is locked to not modify its own list */
+    Subscriber *iteratingSubscriber = nullptr;
+
+private:
+
+    /* The drain callback must not publish, unsubscribe or subscribe.
+     * It must only cork, uncork, send, write */
+    std::function<bool(Subscriber *, T &, IteratorFlags)> cb;
+
+    /* The topics */
+    std::unordered_map<std::string_view, std::unique_ptr<Topic>> topics;
+
+    /* List of subscribers that needs drainage */
+    Subscriber *drainableSubscribers = nullptr;
+
+    /* Palette of outgoing messages, up to 64k */
+    std::vector<T> outgoingMessages;
+
+    void checkIteratingSubscriber(Subscriber *s) {
+        /* Notify user that they are doing something wrong here */
+        if (iteratingSubscriber == s) {
+            std::cerr << "Error: WebSocket must not subscribe or unsubscribe to topics while iterating its topics!" << std::endl;
+            std::terminate();
+        }
+    }
+
+    /* Warning: does NOT unlink from drainableSubscribers or modify next, prev. */
+    void drainImpl(Subscriber *s) {
+        /* Before we call cb we need to make sure this subscriber will not report needsDrainage()
+         * since WebSocket::send will call drain from within the cb in that case.*/
+        int numMessageIndices = s->numMessageIndices;
+        s->numMessageIndices = 0;
+
+        /* Then we emit cb */
+        for (int i = 0; i < numMessageIndices; i++) {
+            T &outgoingMessage = outgoingMessages[s->messageIndices[i]];
+
+            int flags = (i == numMessageIndices - 1) ? LAST : 0;
+
+            /* Returning true will stop drainage short (such as when backpressure is too high) */
+            if (cb(s, outgoingMessage, (IteratorFlags)(flags | (i == 0 ? FIRST : 0)))) {
+                break;
+            }
+        }
+    }
+
+    void unlinkDrainableSubscriber(Subscriber *s) {
+        if (s->prev) {
+            s->prev->next = s->next;
+        }
+        if (s->next) {
+            s->next->prev = s->prev;
+        }
+        /* If we are the head, then we also need to reset the head */
+        if (drainableSubscribers == s) {
+            drainableSubscribers = s->next;
+        }
+    }
+
+public:
+
+    TopicTree(std::function<bool(Subscriber *, T &, IteratorFlags)> cb) : cb(cb) {
+
+    }
+
+    /* Returns nullptr if not found */
+    Topic *lookupTopic(std::string_view topic) {
+        auto it = topics.find(topic);
+        if (it == topics.end()) {
+            return nullptr;
+        }
+        return it->second.get();
+    }
+
+    /* Subscribe fails if we already are subscribed */
+    Topic *subscribe(Subscriber *s, std::string_view topic) {
+        /* Notify user that they are doing something wrong here */
+        checkIteratingSubscriber(s);
+
+        /* Lookup or create new topic */
+        Topic *topicPtr = lookupTopic(topic);
+        if (!topicPtr) {
+            Topic *newTopic = new Topic(topic);
+            topics.insert({std::string_view(newTopic->name.data(), newTopic->name.length()), std::unique_ptr<Topic>(newTopic)});
+            topicPtr = newTopic;
+        }
+
+        /* Insert us in topic, insert topic in us */
+        auto [it, inserted] = s->topics.insert(topicPtr);
+        if (!inserted) {
+            return nullptr;
+        }
+        topicPtr->insert(s);
+
+        /* Success */
+        return topicPtr;
+    }
+
+    /* Returns ok, last, newCount */
+    std::tuple<bool, bool, int> unsubscribe(Subscriber *s, std::string_view topic) {
+        /* Notify user that they are doing something wrong here */
+        checkIteratingSubscriber(s);
+
+        /* Lookup topic */
+        Topic *topicPtr = lookupTopic(topic);
+        if (!topicPtr) {
+            /* If the topic doesn't exist we are assumed to still be subscribers of something */
+            return {false, false, -1};
+        }
+
+        /* Erase from our list first */
+        if (s->topics.erase(topicPtr) == 0) {
+            return {false, false, -1};
+        }
+
+        /* Remove us from topic */
+        topicPtr->erase(s);
+
+        int newCount = topicPtr->size();
+
+        /* If there is no subscriber to this topic, remove it */
+        if (!topicPtr->size()) {
+            /* Unique_ptr deletes the topic */
+            topics.erase(topic);
+        }
+
+        /* If we don't hold any topics we are to be freed altogether */
+        return {true, s->topics.size() == 0, newCount};
+    }
+
+    /* Factory function for creating a Subscriber */
+    Subscriber *createSubscriber() {
+        return new Subscriber();
+    }
+
+    /* This is used to end a Subscriber, before freeing it */
+    void freeSubscriber(Subscriber *s) {
+
+        /* I guess we call this one even if we are not subscribers */
+        if (!s) {
+            return;
+        }
+
+        /* For all topics, unsubscribe */
+        for (Topic *topicPtr : s->topics) {
+            /* If we are the last subscriber, simply remove the whole topic */
+            if (topicPtr->size() == 1) {
+                topics.erase(topicPtr->name);
+            } else {
+                /* Otherwise just remove us */
+                topicPtr->erase(s);
+            }
+        }
+
+        /* We also need to unlink us */
+        if (s->needsDrainage()) {
+            unlinkDrainableSubscriber(s);
+        }
+
+        delete s;
+    }
+
+    /* Mainly used by WebSocket::send to drain one socket before sending */
+    void drain(Subscriber *s) {
+        /* The list is undefined and cannot be touched unless needsDrainage(). */
+        if (s->needsDrainage()) {
+            /* This function differs from drainImpl by properly unlinking
+            * the subscriber from drainableSubscribers. drainImpl does not. */
+            unlinkDrainableSubscriber(s);
+
+            /* This one always resets needsDrainage before it calls any cb's.
+             * Otherwise we would stackoverflow when sending after publish but before drain. */
+            drainImpl(s);
+            
+            /* If we drained last subscriber, also clear outgoingMessages */
+            if (!drainableSubscribers) {
+                outgoingMessages.clear();
+            }
+        }
+    }
+
+    /* Called everytime we call send, to drain published messages so to sync outgoing messages */
+    void drain() {
+        if (drainableSubscribers) {
+            /* Drain one socket a time */
+            for (Subscriber *s = drainableSubscribers; s; s = s->next) {
+                /* Instead of unlinking every single subscriber, we just leave the list undefined
+                 * and reset drainableSubscribers ptr below. */
+                drainImpl(s);
+            }
+            /* Drain always clears drainableSubscribers and outgoingMessages */
+            drainableSubscribers = nullptr;
+            outgoingMessages.clear();
+        }
+    }
+
+    /* Big messages bypass all buffering and land directly in backpressure */
+    template <typename F>
+    bool publishBig(Subscriber *sender, std::string_view topic, B &&bigMessage, F cb) {
+        /* Do we even have this topic? */
+        auto it = topics.find(topic);
+        if (it == topics.end()) {
+            return false;
+        }
+
+        /* For all subscribers in topic */
+        for (Subscriber *s : *it->second) {
+
+            /* If we are sender then ignore us */
+            if (sender != s) {
+                cb(s, bigMessage);
+            }
+        }
+
+        return true;
+    }
+
+    /* Linear in number of affected subscribers */
+    bool publish(Subscriber *sender, std::string_view topic, T &&message) {
+        /* Do we even have this topic? */
+        auto it = topics.find(topic);
+        if (it == topics.end()) {
+            return false;
+        }
+
+        /* If we have more than 65k messages we need to drain every socket. */
+        if (outgoingMessages.size() == UINT16_MAX) {
+            /* If there is a socket that is currently corked, this will be ugly as all sockets will drain
+             * to their own backpressure */
+            drain();
+        }
+
+        /* If nobody references this message, don't buffer it */
+        bool referencedMessage = false;
+
+        /* For all subscribers in topic */
+        for (Subscriber *s : *it->second) {
+
+            /* If we are sender then ignore us */
+            if (sender != s) {
+
+                /* At least one subscriber wants this message */
+                referencedMessage = true;
+
+                /* If we already have too many outgoing messages on this subscriber, drain it now */
+                if (s->numMessageIndices == 32) {
+                    /* This one does not need to check needsDrainage here but still does. */
+                    drain(s);
+                }
+
+                /* Finally we can continue */
+                s->messageIndices[s->numMessageIndices++] = (uint16_t)outgoingMessages.size();
+                /* First message adds subscriber to list of drainable subscribers */
+                if (s->numMessageIndices == 1) {
+                    /* Insert us in the head of drainable subscribers */
+                    s->next = drainableSubscribers;
+                    s->prev = nullptr;
+                    if (s->next) {
+                        s->next->prev = s;
+                    }
+                    drainableSubscribers = s;
+                }
+            }
+        }
+
+        /* Push this message and return with success */
+        if (referencedMessage) {
+            outgoingMessages.emplace_back(message);
+        }
+
+        /* Success if someone wants it */
+        return referencedMessage;
+    }
+};
+
+}
+
+#endif