opal-up 0.0.2 → 0.0.3

data/ext/up_ext/libuwebsockets.h

@@ -0,0 +1,260 @@
+/*
+ * Copyright 2022 Ciro Spaciari
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef LIBUWS_CAPI_HEADER
+#define LIBUWS_CAPI_HEADER
+
+#include <stddef.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include "libusockets.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+#ifdef _WIN32
+#  define DLL_EXPORT __declspec( dllexport )
+#else
+#  define DLL_EXPORT
+#endif
+
+    DLL_EXPORT typedef enum
+    {
+        /* 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
+    } uws_compress_options_t;
+
+    DLL_EXPORT typedef enum
+    {
+        CONTINUATION = 0,
+        TEXT = 1,
+        BINARY = 2,
+        CLOSE = 8,
+        PING = 9,
+        PONG = 10
+    } uws_opcode_t;
+
+    DLL_EXPORT typedef enum
+    {
+        BACKPRESSURE,
+        SUCCESS,
+        DROPPED
+    } uws_sendstatus_t;
+
+    DLL_EXPORT typedef struct
+    {
+
+        int port;
+        const char *host;
+        int options;
+    } uws_app_listen_config_t;
+
+    DLL_EXPORT typedef struct {
+        bool ok;
+        bool has_responded;
+    } uws_try_end_result_t;
+
+    DLL_EXPORT struct uws_app_s;
+    DLL_EXPORT struct uws_req_s;
+    DLL_EXPORT struct uws_res_s;
+    DLL_EXPORT struct uws_websocket_s;
+    DLL_EXPORT struct uws_header_iterator_s;
+    DLL_EXPORT typedef struct uws_app_s uws_app_t;
+    DLL_EXPORT typedef struct uws_req_s uws_req_t;
+    DLL_EXPORT typedef struct uws_res_s uws_res_t;
+    DLL_EXPORT typedef struct uws_socket_context_s uws_socket_context_t;
+    DLL_EXPORT typedef struct uws_websocket_s uws_websocket_t;
+
+    DLL_EXPORT typedef void (*uws_websocket_handler)(uws_websocket_t *ws, void* user_data);
+    DLL_EXPORT typedef void (*uws_websocket_message_handler)(uws_websocket_t *ws, const char *message, size_t length, uws_opcode_t opcode, void* user_data);
+    DLL_EXPORT typedef void (*uws_websocket_ping_pong_handler)(uws_websocket_t *ws, const char *message, size_t length, void* user_data);
+    DLL_EXPORT typedef void (*uws_websocket_close_handler)(uws_websocket_t *ws, int code, const char *message, size_t length, void* user_data);
+    DLL_EXPORT typedef void (*uws_websocket_upgrade_handler)(uws_res_t *response, uws_req_t *request, uws_socket_context_t *context, void* user_data);
+    DLL_EXPORT typedef void (*uws_websocket_subscription_handler)(uws_websocket_t *ws, const char *topic_name, size_t topic_name_length, int new_number_of_subscriber, int old_number_of_subscriber, void* user_data);
+
+    DLL_EXPORT typedef struct
+    {
+        uws_compress_options_t compression;
+        /* Maximum message size we can receive */
+        unsigned int maxPayloadLength;
+        /* 2 minutes timeout is good */
+        unsigned short idleTimeout;
+        /* 64kb backpressure is probably good */
+        unsigned int maxBackpressure;
+        bool closeOnBackpressureLimit;
+        /* This one depends on kernel timeouts and is a bad default */
+        bool resetIdleTimeoutOnSend;
+        /* A good default, esp. for newcomers */
+        bool sendPingsAutomatically;
+        /* Maximum socket lifetime in seconds before forced closure (defaults to disabled) */
+        unsigned short maxLifetime;
+        uws_websocket_upgrade_handler upgrade;
+        uws_websocket_handler open;
+        uws_websocket_message_handler message;
+        uws_websocket_handler drain;
+        uws_websocket_ping_pong_handler ping;
+        uws_websocket_ping_pong_handler pong;
+        uws_websocket_close_handler close;
+        uws_websocket_subscription_handler subscription;
+    } uws_socket_behavior_t;
+
+    DLL_EXPORT typedef void (*uws_listen_handler)(struct us_listen_socket_t *listen_socket, uws_app_listen_config_t config, void *user_data);
+    DLL_EXPORT typedef void (*uws_listen_domain_handler)(struct us_listen_socket_t *listen_socket, const char* domain, size_t domain_length, int options, void *user_data);
+    DLL_EXPORT typedef void (*uws_method_handler)(uws_res_t *response, uws_req_t *request, void *user_data);
+    DLL_EXPORT typedef void (*uws_filter_handler)(uws_res_t *response, int, void *user_data);
+    DLL_EXPORT typedef void (*uws_missing_server_handler)(const char *hostname, size_t hostname_length, void *user_data);
+    DLL_EXPORT typedef void (*uws_get_headers_server_handler)(const char *header_name, size_t header_name_size, const char *header_value, size_t header_value_size, void *user_data);
+    //Basic HTTP
+    DLL_EXPORT uws_app_t *uws_create_app(int ssl, struct us_socket_context_options_t options);
+    DLL_EXPORT void uws_app_destroy(int ssl, uws_app_t *app);
+    DLL_EXPORT void uws_app_get(int ssl, uws_app_t *app, const char *pattern, uws_method_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_post(int ssl, uws_app_t *app, const char *pattern, uws_method_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_options(int ssl, uws_app_t *app, const char *pattern, uws_method_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_delete(int ssl, uws_app_t *app, const char *pattern, uws_method_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_patch(int ssl, uws_app_t *app, const char *pattern, uws_method_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_put(int ssl, uws_app_t *app, const char *pattern, uws_method_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_head(int ssl, uws_app_t *app, const char *pattern, uws_method_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_connect(int ssl, uws_app_t *app, const char *pattern, uws_method_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_trace(int ssl, uws_app_t *app, const char *pattern, uws_method_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_any(int ssl, uws_app_t *app, const char *pattern, uws_method_handler handler, void *user_data);
+
+    DLL_EXPORT void uws_app_run(int ssl, uws_app_t *);
+
+    DLL_EXPORT void uws_app_listen(int ssl, uws_app_t *app, int port, uws_listen_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_listen_with_config(int ssl, uws_app_t *app, uws_app_listen_config_t config, uws_listen_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_listen_domain(int ssl, uws_app_t *app, const char *domain, size_t domain_length, uws_listen_domain_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_listen_domain_with_options(int ssl, uws_app_t *app, const char *domain,size_t domain_length, int options, uws_listen_domain_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_domain(int ssl, uws_app_t *app, const char* server_name, size_t server_name_length);
+    DLL_EXPORT void uws_app_close(int ssl,  uws_app_t *app);
+
+    DLL_EXPORT bool uws_constructor_failed(int ssl, uws_app_t *app);
+    DLL_EXPORT unsigned int uws_num_subscribers(int ssl, uws_app_t *app, const char *topic, size_t topic_length);
+    DLL_EXPORT bool uws_publish(int ssl, uws_app_t *app, const char *topic, size_t topic_length, const char *message, size_t message_length, uws_opcode_t opcode, bool compress);
+    DLL_EXPORT void *uws_get_native_handle(int ssl, uws_app_t *app);
+    DLL_EXPORT void uws_remove_server_name(int ssl, uws_app_t *app, const char *hostname_pattern, size_t hostname_pattern_length);
+    DLL_EXPORT void uws_add_server_name(int ssl, uws_app_t *app, const char *hostname_pattern, size_t hostname_pattern_length);
+    DLL_EXPORT void uws_add_server_name_with_options(int ssl, uws_app_t *app, const char *hostname_pattern, size_t hostname_pattern_length, struct us_socket_context_options_t options);
+    DLL_EXPORT void uws_missing_server_name(int ssl, uws_app_t *app, uws_missing_server_handler handler, void *user_data);
+    DLL_EXPORT void uws_filter(int ssl, uws_app_t *app, uws_filter_handler handler, void *user_data);
+
+    //WebSocket
+    DLL_EXPORT void uws_ws(int ssl, uws_app_t *app, const char *pattern, uws_socket_behavior_t behavior, void* user_data);
+    DLL_EXPORT void *uws_ws_get_user_data(int ssl, uws_websocket_t *ws);
+    DLL_EXPORT void uws_ws_close(int ssl, uws_websocket_t *ws);
+    DLL_EXPORT uws_sendstatus_t uws_ws_send(int ssl, uws_websocket_t *ws, const char *message, size_t length, uws_opcode_t opcode);
+    DLL_EXPORT uws_sendstatus_t uws_ws_send_with_options(int ssl, uws_websocket_t *ws, const char *message, size_t length, uws_opcode_t opcode, bool compress, bool fin);
+    DLL_EXPORT uws_sendstatus_t uws_ws_send_fragment(int ssl, uws_websocket_t *ws, const char *message, size_t length, bool compress);
+    DLL_EXPORT uws_sendstatus_t uws_ws_send_first_fragment(int ssl, uws_websocket_t *ws, const char *message, size_t length, bool compress);
+    DLL_EXPORT uws_sendstatus_t uws_ws_send_first_fragment_with_opcode(int ssl, uws_websocket_t *ws, const char *message, size_t length, uws_opcode_t opcode, bool compress);
+    DLL_EXPORT uws_sendstatus_t uws_ws_send_last_fragment(int ssl, uws_websocket_t *ws, const char *message, size_t length, bool compress);
+    DLL_EXPORT void uws_ws_end(int ssl, uws_websocket_t *ws, int code, const char *message, size_t length);
+    DLL_EXPORT void uws_ws_cork(int ssl, uws_websocket_t *ws, void (*handler)(void *user_data), void *user_data);
+
+    DLL_EXPORT bool uws_ws_subscribe(int ssl, uws_websocket_t *ws, const char *topic, size_t length);
+    DLL_EXPORT bool uws_ws_unsubscribe(int ssl, uws_websocket_t *ws, const char *topic, size_t length);
+    DLL_EXPORT bool uws_ws_is_subscribed(int ssl, uws_websocket_t *ws, const char *topic, size_t length);
+    DLL_EXPORT void uws_ws_iterate_topics(int ssl, uws_websocket_t *ws, void (*callback)(const char *topic, size_t length, void *user_data), void *user_data);
+    DLL_EXPORT bool uws_ws_publish(int ssl, uws_websocket_t *ws, const char *topic, size_t topic_length, const char *message, size_t message_length);
+    DLL_EXPORT bool uws_ws_publish_with_options(int ssl, uws_websocket_t *ws, const char *topic, size_t topic_length, const char *message, size_t message_length, uws_opcode_t opcode, bool compress);
+    DLL_EXPORT unsigned int uws_ws_get_buffered_amount(int ssl, uws_websocket_t *ws);
+    DLL_EXPORT size_t uws_ws_get_remote_address(int ssl, uws_websocket_t *ws, const char **dest);
+    DLL_EXPORT size_t uws_ws_get_remote_address_as_text(int ssl, uws_websocket_t *ws, const char **dest);
+
+    //Response
+    DLL_EXPORT void uws_res_end(int ssl, uws_res_t *res, const char *data, size_t length, bool close_connection);
+    DLL_EXPORT uws_try_end_result_t uws_res_try_end(int ssl, uws_res_t *res, const char *data, size_t length, uintmax_t total_size, bool close_connection);
+    DLL_EXPORT void uws_res_cork(int ssl, uws_res_t *res, void(*callback)(uws_res_t *res, void* user_data) ,void* user_data);
+    DLL_EXPORT void uws_res_pause(int ssl, uws_res_t *res);
+    DLL_EXPORT void uws_res_resume(int ssl, uws_res_t *res);
+    DLL_EXPORT void uws_res_write_continue(int ssl, uws_res_t *res);
+    DLL_EXPORT void uws_res_write_status(int ssl, uws_res_t *res, const char *status, size_t length);
+    DLL_EXPORT void uws_res_write_header(int ssl, uws_res_t *res, const char *key, size_t key_length, const char *value, size_t value_length);
+
+    DLL_EXPORT void uws_res_write_header_int(int ssl, uws_res_t *res, const char *key, size_t key_length, uint64_t value);
+    DLL_EXPORT void uws_res_end_without_body(int ssl, uws_res_t *res, bool close_connection);
+    DLL_EXPORT bool uws_res_write(int ssl, uws_res_t *res, const char *data, size_t length);
+    DLL_EXPORT uintmax_t uws_res_get_write_offset(int ssl, uws_res_t *res);
+    DLL_EXPORT void uws_res_override_write_offset(int ssl, uws_res_t *res, uintmax_t offset);
+    DLL_EXPORT bool uws_res_has_responded(int ssl, uws_res_t *res);
+    DLL_EXPORT void uws_res_on_writable(int ssl, uws_res_t *res, bool (*handler)(uws_res_t *res, uintmax_t, void *optional_data), void *user_data);
+    DLL_EXPORT void uws_res_on_aborted(int ssl, uws_res_t *res, void (*handler)(uws_res_t *res, void *optional_data), void *optional_data);
+    DLL_EXPORT void uws_res_on_data(int ssl, uws_res_t *res, void (*handler)(uws_res_t *res, const char *chunk, size_t chunk_length, bool is_end, void *optional_data), void *optional_data);
+    DLL_EXPORT void uws_res_upgrade(int ssl, uws_res_t *res, void *data, const char *sec_web_socket_key, size_t sec_web_socket_key_length, const char *sec_web_socket_protocol, size_t sec_web_socket_protocol_length, const char *sec_web_socket_extensions, size_t sec_web_socket_extensions_length, uws_socket_context_t *ws);
+    DLL_EXPORT size_t uws_res_get_remote_address(int ssl, uws_res_t *res, const char **dest);
+    DLL_EXPORT size_t uws_res_get_remote_address_as_text(int ssl, uws_res_t *res, const char **dest);
+#ifdef UWS_WITH_PROXY
+    DLL_EXPORT size_t uws_res_get_proxied_remote_address(int ssl, uws_res_t *res, const char **dest);
+    DLL_EXPORT size_t uws_res_get_proxied_remote_address_as_text(int ssl, uws_res_t *res, const char **dest);
+#endif
+    DLL_EXPORT void *uws_res_get_native_handle(int ssl, uws_res_t *res);
+
+    //Request
+    DLL_EXPORT bool uws_req_is_ancient(uws_req_t *res);
+    DLL_EXPORT bool uws_req_get_yield(uws_req_t *res);
+    DLL_EXPORT void uws_req_set_yield(uws_req_t *res, bool yield);
+    DLL_EXPORT size_t uws_req_get_url(uws_req_t *res, const char **dest);
+    DLL_EXPORT size_t uws_req_get_full_url(uws_req_t *res, const char **dest);
+    DLL_EXPORT size_t uws_req_get_method(uws_req_t *res, const char **dest);
+    DLL_EXPORT size_t uws_req_get_case_sensitive_method(uws_req_t *res, const char **dest);
+
+    DLL_EXPORT size_t uws_req_get_header(uws_req_t *res, const char *lower_case_header, size_t lower_case_header_length, const char **dest);
+    DLL_EXPORT void uws_req_for_each_header(uws_req_t *res, uws_get_headers_server_handler handler, void *user_data);
+    DLL_EXPORT size_t uws_req_get_query(uws_req_t *res, const char *key, size_t key_length, const char **dest);
+    DLL_EXPORT size_t uws_req_get_parameter(uws_req_t *res, unsigned short index, const char **dest);
+
+    DLL_EXPORT struct us_loop_t *uws_get_loop();
+    DLL_EXPORT struct us_loop_t *uws_get_loop_with_native(void* existing_native_loop);
+    DLL_EXPORT void uws_loop_defer(struct us_loop_t *loop, void( cb(void *user_data) ), void *user_data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/up_ext/loop.c

@@ -0,0 +1,386 @@
+/*
+ * 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 LIBUS_USE_IO_URING
+
+#include "libusockets.h"
+#include "internal.h"
+#include <stdlib.h>
+
+/* The loop has 2 fallthrough polls */
+void us_internal_loop_data_init(struct us_loop_t *loop, void (*wakeup_cb)(struct us_loop_t *loop),
+    void (*pre_cb)(struct us_loop_t *loop), void (*post_cb)(struct us_loop_t *loop)) {
+    loop->data.sweep_timer = us_create_timer(loop, 1, 0);
+    loop->data.recv_buf = malloc(LIBUS_RECV_BUFFER_LENGTH + LIBUS_RECV_BUFFER_PADDING * 2);
+    loop->data.ssl_data = 0;
+    loop->data.head = 0;
+    loop->data.iterator = 0;
+    loop->data.closed_head = 0;
+    loop->data.low_prio_head = 0;
+    loop->data.low_prio_budget = 0;
+
+    loop->data.pre_cb = pre_cb;
+    loop->data.post_cb = post_cb;
+    loop->data.iteration_nr = 0;
+
+    loop->data.wakeup_async = us_internal_create_async(loop, 1, 0);
+    us_internal_async_set(loop->data.wakeup_async, (void (*)(struct us_internal_async *)) wakeup_cb);
+}
+
+void us_internal_loop_data_free(struct us_loop_t *loop) {
+#ifndef LIBUS_NO_SSL
+    us_internal_free_loop_ssl_data(loop);
+#endif
+
+    free(loop->data.recv_buf);
+
+    us_timer_close(loop->data.sweep_timer);
+    us_internal_async_close(loop->data.wakeup_async);
+}
+
+void us_wakeup_loop(struct us_loop_t *loop) {
+    us_internal_async_wakeup(loop->data.wakeup_async);
+}
+
+void us_internal_loop_link(struct us_loop_t *loop, struct us_socket_context_t *context) {
+    /* Insert this context as the head of loop */
+    context->next = loop->data.head;
+    context->prev = 0;
+    if (loop->data.head) {
+        loop->data.head->prev = context;
+    }
+    loop->data.head = context;
+}
+
+/* Unlink is called before free */
+void us_internal_loop_unlink(struct us_loop_t *loop, struct us_socket_context_t *context) {
+    if (loop->data.head == context) {
+        loop->data.head = context->next;
+        if (loop->data.head) {
+            loop->data.head->prev = 0;
+        }
+    } else {
+        context->prev->next = context->next;
+        if (context->next) {
+            context->next->prev = context->prev;
+        }
+    }
+}
+
+/* This functions should never run recursively */
+void us_internal_timer_sweep(struct us_loop_t *loop) {
+    struct us_internal_loop_data_t *loop_data = &loop->data;
+    /* For all socket contexts in this loop */
+    for (loop_data->iterator = loop_data->head; loop_data->iterator; loop_data->iterator = loop_data->iterator->next) {
+
+        struct us_socket_context_t *context = loop_data->iterator;
+
+        /* Update this context's timestamps (this could be moved to loop and done once) */
+        context->global_tick++;
+        unsigned char short_ticks = context->timestamp = context->global_tick % 240;
+        unsigned char long_ticks = context->long_timestamp = (context->global_tick / 15) % 240;
+
+        /* Begin at head */
+        struct us_socket_t *s = context->head_sockets;
+        while (s) {
+            /* Seek until end or timeout found (tightest loop) */
+            while (1) {
+                /* We only read from 1 random cache line here */
+                if (short_ticks == s->timeout || long_ticks == s->long_timeout) {
+                    break;
+                }
+
+                /* Did we reach the end without a find? */
+                if ((s = s->next) == 0) {
+                    goto next_context;
+                }
+            }
+
+            /* Here we have a timeout to emit (slow path) */
+            context->iterator = s;
+
+            if (short_ticks == s->timeout) {
+                s->timeout = 255;
+                context->on_socket_timeout(s);
+            }
+
+            if (context->iterator == s && long_ticks == s->long_timeout) {
+                s->long_timeout = 255;
+                context->on_socket_long_timeout(s);
+            }   
+
+            /* Check for unlink / link (if the event handler did not modify the chain, we step 1) */
+            if (s == context->iterator) {
+                s = s->next;
+            } else {
+                /* The iterator was changed by event handler */
+                s = context->iterator;
+            }
+        }
+        /* We always store a 0 to context->iterator here since we are no longer iterating this context */
+        next_context:
+        context->iterator = 0;
+    }
+}
+
+/* We do not want to block the loop with tons and tons of CPU-intensive work for SSL handshakes.
+ * Spread it out during many loop iterations, prioritizing already open connections, they are far
+ * easier on CPU */
+static const int MAX_LOW_PRIO_SOCKETS_PER_LOOP_ITERATION = 5;
+
+void us_internal_handle_low_priority_sockets(struct us_loop_t *loop) {
+    struct us_internal_loop_data_t *loop_data = &loop->data;
+    struct us_socket_t *s;
+
+    loop_data->low_prio_budget = MAX_LOW_PRIO_SOCKETS_PER_LOOP_ITERATION;
+
+    for (s = loop_data->low_prio_head; s && loop_data->low_prio_budget > 0; s = loop_data->low_prio_head, loop_data->low_prio_budget--) {
+        /* Unlink this socket from the low-priority queue */
+        loop_data->low_prio_head = s->next;
+        if (s->next) s->next->prev = 0;
+        s->next = 0;
+
+        us_internal_socket_context_link_socket(s->context, s);
+        us_poll_change(&s->p, us_socket_context(0, s)->loop, us_poll_events(&s->p) | LIBUS_SOCKET_READABLE);
+
+        s->low_prio_state = 2;
+    }
+}
+
+/* Note: Properly takes the linked list and timeout sweep into account */
+void us_internal_free_closed_sockets(struct us_loop_t *loop) {
+    /* Free all closed sockets (maybe it is better to reverse order?) */
+    if (loop->data.closed_head) {
+        for (struct us_socket_t *s = loop->data.closed_head; s; ) {
+            struct us_socket_t *next = s->next;
+            us_poll_free((struct us_poll_t *) s, loop);
+            s = next;
+        }
+        loop->data.closed_head = 0;
+    }
+}
+
+void sweep_timer_cb(struct us_internal_callback_t *cb) {
+    us_internal_timer_sweep(cb->loop);
+}
+
+long long us_loop_iteration_number(struct us_loop_t *loop) {
+    return loop->data.iteration_nr;
+}
+
+/* These may have somewhat different meaning depending on the underlying event library */
+void us_internal_loop_pre(struct us_loop_t *loop) {
+    loop->data.iteration_nr++;
+    us_internal_handle_low_priority_sockets(loop);
+    loop->data.pre_cb(loop);
+}
+
+void us_internal_loop_post(struct us_loop_t *loop) {
+    us_internal_free_closed_sockets(loop);
+    loop->data.post_cb(loop);
+}
+
+struct us_socket_t *us_adopt_accepted_socket(int ssl, struct us_socket_context_t *context, LIBUS_SOCKET_DESCRIPTOR accepted_fd,
+    unsigned int socket_ext_size, char *addr_ip, int addr_ip_length) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        return (struct us_socket_t *)us_internal_ssl_adopt_accepted_socket((struct us_internal_ssl_socket_context_t *)context, accepted_fd,
+            socket_ext_size, addr_ip, addr_ip_length);
+    }
+#endif
+    struct us_poll_t *accepted_p = us_create_poll(context->loop, 0, sizeof(struct us_socket_t) - sizeof(struct us_poll_t) + socket_ext_size);
+    us_poll_init(accepted_p, accepted_fd, POLL_TYPE_SOCKET);
+    us_poll_start(accepted_p, context->loop, LIBUS_SOCKET_READABLE);
+
+    struct us_socket_t *s = (struct us_socket_t *) accepted_p;
+
+    s->context = context;
+    s->timeout = 255;
+    s->long_timeout = 255;
+    s->low_prio_state = 0;
+
+    /* We always use nodelay */
+    bsd_socket_nodelay(accepted_fd, 1);
+
+    us_internal_socket_context_link_socket(context, s);
+
+    context->on_open(s, 0, addr_ip, addr_ip_length);
+    return s;
+}
+
+void us_internal_dispatch_ready_poll(struct us_poll_t *p, int error, int events) {
+    switch (us_internal_poll_type(p)) {
+    case POLL_TYPE_CALLBACK: {
+            struct us_internal_callback_t *cb = (struct us_internal_callback_t *) p;
+            /* Timers, asyncs should accept (read), while UDP sockets should obviously not */
+            if (!cb->leave_poll_ready) {
+                /* Let's just have this macro to silence the CodeQL alert regarding empty function when using libuv */
+    #ifndef LIBUS_USE_LIBUV
+                us_internal_accept_poll_event(p);
+    #endif
+            }
+            cb->cb(cb->cb_expects_the_loop ? (struct us_internal_callback_t *) cb->loop : (struct us_internal_callback_t *) &cb->p);
+        }
+        break;
+    case POLL_TYPE_SEMI_SOCKET: {
+            /* Both connect and listen sockets are semi-sockets
+             * but they poll for different events */
+            if (us_poll_events(p) == LIBUS_SOCKET_WRITABLE) {
+                struct us_socket_t *s = (struct us_socket_t *) p;
+
+                /* It is perfectly possible to come here with an error */
+                if (error) {
+                    /* Emit error, close without emitting on_close */
+                    s->context->on_connect_error(s, 0);
+                    us_socket_close_connecting(0, s);
+                } else {
+                    /* All sockets poll for readable */
+                    us_poll_change(p, s->context->loop, LIBUS_SOCKET_READABLE);
+
+                    /* We always use nodelay */
+                    bsd_socket_nodelay(us_poll_fd(p), 1);
+
+                    /* We are now a proper socket */
+                    us_internal_poll_set_type(p, POLL_TYPE_SOCKET);
+
+                    /* If we used a connection timeout we have to reset it here */
+                    us_socket_timeout(0, s, 0);
+
+                    s->context->on_open(s, 1, 0, 0);
+                }
+            } else {
+                struct us_listen_socket_t *listen_socket = (struct us_listen_socket_t *) p;
+                struct bsd_addr_t addr;
+
+                LIBUS_SOCKET_DESCRIPTOR client_fd = bsd_accept_socket(us_poll_fd(p), &addr);
+                if (client_fd == LIBUS_SOCKET_ERROR) {
+                    /* Todo: start timer here */
+
+                } else {
+
+                    /* Todo: stop timer if any */
+
+                    do {
+                        struct us_socket_context_t *context = us_socket_context(0, &listen_socket->s);
+                        /* See if we want to export the FD or keep it here (this event can be unset) */
+                        if (context->on_pre_open == 0 || context->on_pre_open(client_fd) == client_fd) {
+
+                            /* Adopt the newly accepted socket */
+                            us_adopt_accepted_socket(0, context,
+                                client_fd, listen_socket->socket_ext_size, bsd_addr_get_ip(&addr), bsd_addr_get_ip_length(&addr));
+
+                            /* Exit accept loop if listen socket was closed in on_open handler */
+                            if (us_socket_is_closed(0, &listen_socket->s)) {
+                                break;
+                            }
+
+                        }
+
+                    } while ((client_fd = bsd_accept_socket(us_poll_fd(p), &addr)) != LIBUS_SOCKET_ERROR);
+                }
+            }
+        }
+        break;
+    case POLL_TYPE_SOCKET_SHUT_DOWN:
+    case POLL_TYPE_SOCKET: {
+            /* We should only use s, no p after this point */
+            struct us_socket_t *s = (struct us_socket_t *) p;
+
+            /* Such as epollerr epollhup */
+            if (error) {
+                /* Todo: decide what code we give here */
+                s = us_socket_close(0, s, 0, NULL);
+                return;
+            }
+
+            if (events & LIBUS_SOCKET_WRITABLE) {
+                /* Note: if we failed a write as a socket of one loop then adopted
+                 * to another loop, this will be wrong. Absurd case though */
+                s->context->loop->data.last_write_failed = 0;
+
+                s = s->context->on_writable(s);
+
+                if (us_socket_is_closed(0, s)) {
+                    return;
+                }
+
+                /* If we have no failed write or if we shut down, then stop polling for more writable */
+                if (!s->context->loop->data.last_write_failed || us_socket_is_shut_down(0, s)) {
+                    us_poll_change(&s->p, us_socket_context(0, s)->loop, us_poll_events(&s->p) & LIBUS_SOCKET_READABLE);
+                }
+            }
+
+            if (events & LIBUS_SOCKET_READABLE) {
+                /* Contexts may prioritize down sockets that are currently readable, e.g. when SSL handshake has to be done.
+                 * SSL handshakes are CPU intensive, so we limit the number of handshakes per loop iteration, and move the rest
+                 * to the low-priority queue */
+                if (s->context->is_low_prio(s)) {
+                    if (s->low_prio_state == 2) {
+                        s->low_prio_state = 0; /* Socket has been delayed and now it's time to process incoming data for one iteration */
+                    } else if (s->context->loop->data.low_prio_budget > 0) {
+                        s->context->loop->data.low_prio_budget--; /* Still having budget for this iteration - do normal processing */
+                    } else {
+                        us_poll_change(&s->p, us_socket_context(0, s)->loop, us_poll_events(&s->p) & LIBUS_SOCKET_WRITABLE);
+                        us_internal_socket_context_unlink_socket(s->context, s);
+
+                        /* Link this socket to the low-priority queue - we use a LIFO queue, to prioritize newer clients that are
+                         * maybe not already timeouted - sounds unfair, but works better in real-life with smaller client-timeouts
+                         * under high load */
+                        s->prev = 0;
+                        s->next = s->context->loop->data.low_prio_head;
+                        if (s->next) s->next->prev = s;
+                        s->context->loop->data.low_prio_head = s;
+
+                        s->low_prio_state = 1;
+
+                        break;
+                    }
+                }
+
+                int length = bsd_recv(us_poll_fd(&s->p), s->context->loop->data.recv_buf + LIBUS_RECV_BUFFER_PADDING, LIBUS_RECV_BUFFER_LENGTH, 0);
+                if (length > 0) {
+                    s = s->context->on_data(s, s->context->loop->data.recv_buf + LIBUS_RECV_BUFFER_PADDING, length);
+                } else if (!length) {
+                    if (us_socket_is_shut_down(0, s)) {
+                        /* We got FIN back after sending it */
+                        /* Todo: We should give "CLEAN SHUTDOWN" as reason here */
+                        s = us_socket_close(0, s, 0, NULL);
+                    } else {
+                        /* We got FIN, so stop polling for readable */
+                        us_poll_change(&s->p, us_socket_context(0, s)->loop, us_poll_events(&s->p) & LIBUS_SOCKET_WRITABLE);
+                        s = s->context->on_end(s);
+                    }
+                } else if (length == LIBUS_SOCKET_ERROR && !bsd_would_block()) {
+                    /* Todo: decide also here what kind of reason we should give */
+                    s = us_socket_close(0, s, 0, NULL);
+                }
+            }
+        }
+        break;
+    }
+}
+
+/* Integration only requires the timer to be set up */
+void us_loop_integrate(struct us_loop_t *loop) {
+    us_timer_set(loop->data.sweep_timer, (void (*)(struct us_timer_t *)) sweep_timer_cb, LIBUS_TIMEOUT_GRANULARITY * 1000, LIBUS_TIMEOUT_GRANULARITY * 1000);
+}
+
+void *us_loop_ext(struct us_loop_t *loop) {
+    return loop + 1;
+}
+
+#endif