aboutsummaryrefslogtreecommitdiff
path: root/src/deps
diff options
context:
space:
mode:
Diffstat (limited to 'src/deps')
-rw-r--r--src/deps/_libusockets.h289
-rw-r--r--src/deps/libuwsockets.cpp984
-rw-r--r--src/deps/uws.zig626
3 files changed, 1899 insertions, 0 deletions
diff --git a/src/deps/_libusockets.h b/src/deps/_libusockets.h
new file mode 100644
index 000000000..5456ff921
--- /dev/null
+++ b/src/deps/_libusockets.h
@@ -0,0 +1,289 @@
+
+#ifndef LIBUWS_CAPI_HEADER
+#define LIBUWS_CAPI_HEADER
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <uws/uSockets/src/libusockets.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+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;
+
+typedef enum {
+ CONTINUATION = 0,
+ TEXT = 1,
+ BINARY = 2,
+ CLOSE = 8,
+ PING = 9,
+ PONG = 10
+} uws_opcode_t;
+
+typedef enum { BACKPRESSURE, SUCCESS, DROPPED } uws_sendstatus_t;
+
+typedef struct {
+
+ int port;
+ const char *host;
+ int options;
+} uws_app_listen_config_t;
+
+struct uws_app_s;
+struct uws_req_s;
+struct uws_res_s;
+struct uws_websocket_s;
+struct uws_header_iterator_s;
+typedef struct uws_app_s uws_app_t;
+typedef struct uws_req_s uws_req_t;
+typedef struct uws_res_s uws_res_t;
+typedef struct uws_socket_context_s uws_socket_context_t;
+typedef struct uws_websocket_s uws_websocket_t;
+
+typedef void (*uws_websocket_handler)(uws_websocket_t *ws);
+typedef void (*uws_websocket_message_handler)(uws_websocket_t *ws,
+ const char *message,
+ size_t length,
+ uws_opcode_t opcode);
+typedef void (*uws_websocket_ping_pong_handler)(uws_websocket_t *ws,
+ const char *message,
+ size_t length);
+typedef void (*uws_websocket_close_handler)(uws_websocket_t *ws, int code,
+ const char *message, size_t length);
+typedef void (*uws_websocket_upgrade_handler)(uws_res_t *response,
+ uws_req_t *request,
+ uws_socket_context_t *context);
+
+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_socket_behavior_t;
+
+typedef void (*uws_listen_handler)(struct us_listen_socket_t *listen_socket,
+ uws_app_listen_config_t config,
+ void *user_data);
+typedef void (*uws_method_handler)(uws_res_t *response, uws_req_t *request,
+ void *user_data);
+typedef void (*uws_filter_handler)(uws_res_t *response, int, void *user_data);
+typedef void (*uws_missing_server_handler)(const char *hostname,
+ void *user_data);
+// Basic HTTP
+uws_app_t *uws_create_app(int ssl, struct us_socket_context_options_t options);
+void uws_app_destroy(int ssl, uws_app_t *app);
+void uws_app_get(int ssl, uws_app_t *app, const char *pattern,
+ uws_method_handler handler, void *user_data);
+void uws_app_post(int ssl, uws_app_t *app, const char *pattern,
+ uws_method_handler handler, void *user_data);
+void uws_app_options(int ssl, uws_app_t *app, const char *pattern,
+ uws_method_handler handler, void *user_data);
+void uws_app_delete(int ssl, uws_app_t *app, const char *pattern,
+ uws_method_handler handler, void *user_data);
+void uws_app_patch(int ssl, uws_app_t *app, const char *pattern,
+ uws_method_handler handler, void *user_data);
+void uws_app_put(int ssl, uws_app_t *app, const char *pattern,
+ uws_method_handler handler, void *user_data);
+void uws_app_head(int ssl, uws_app_t *app, const char *pattern,
+ uws_method_handler handler, void *user_data);
+void uws_app_connect(int ssl, uws_app_t *app, const char *pattern,
+ uws_method_handler handler, void *user_data);
+void uws_app_trace(int ssl, uws_app_t *app, const char *pattern,
+ uws_method_handler handler, void *user_data);
+void uws_app_any(int ssl, uws_app_t *app, const char *pattern,
+ uws_method_handler handler, void *user_data);
+
+void uws_app_run(int ssl, uws_app_t *);
+
+void uws_app_listen(int ssl, uws_app_t *app, int port,
+ uws_listen_handler handler, void *user_data);
+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);
+bool uws_constructor_failed(int ssl, uws_app_t *app);
+unsigned int uws_num_subscribers(int ssl, uws_app_t *app, const char *topic);
+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);
+void *uws_get_native_handle(int ssl, uws_app_t *app);
+void uws_remove_server_name(int ssl, uws_app_t *app,
+ const char *hostname_pattern);
+void uws_add_server_name(int ssl, uws_app_t *app, const char *hostname_pattern);
+void uws_add_server_name_with_options(
+ int ssl, uws_app_t *app, const char *hostname_pattern,
+ struct us_socket_context_options_t options);
+void uws_missing_server_name(int ssl, uws_app_t *app,
+ uws_missing_server_handler handler,
+ void *user_data);
+void uws_filter(int ssl, uws_app_t *app, uws_filter_handler handler,
+ void *user_data);
+
+// WebSocket
+void uws_ws(int ssl, uws_app_t *app, const char *pattern,
+ uws_socket_behavior_t behavior);
+void *uws_ws_get_user_data(int ssl, uws_websocket_t *ws);
+void uws_ws_close(int ssl, uws_websocket_t *ws);
+uws_sendstatus_t uws_ws_send(int ssl, uws_websocket_t *ws, const char *message,
+ size_t length, uws_opcode_t opcode);
+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);
+uws_sendstatus_t uws_ws_send_fragment(int ssl, uws_websocket_t *ws,
+ const char *message, size_t length,
+ bool compress);
+uws_sendstatus_t uws_ws_send_first_fragment(int ssl, uws_websocket_t *ws,
+ const char *message, size_t length,
+ bool compress);
+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);
+uws_sendstatus_t uws_ws_send_last_fragment(int ssl, uws_websocket_t *ws,
+ const char *message, size_t length,
+ bool compress);
+void uws_ws_end(int ssl, uws_websocket_t *ws, int code, const char *message,
+ size_t length);
+void uws_ws_cork(int ssl, uws_websocket_t *ws, void (*handler)(void *user_data),
+ void *user_data);
+bool uws_ws_subscribe(int ssl, uws_websocket_t *ws, const char *topic,
+ size_t length);
+bool uws_ws_unsubscribe(int ssl, uws_websocket_t *ws, const char *topic,
+ size_t length);
+bool uws_ws_is_subscribed(int ssl, uws_websocket_t *ws, const char *topic,
+ size_t length);
+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);
+bool uws_ws_publish(int ssl, uws_websocket_t *ws, const char *topic,
+ size_t topic_length, const char *message,
+ size_t message_length);
+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);
+unsigned int uws_ws_get_buffered_amount(int ssl, uws_websocket_t *ws);
+size_t uws_ws_get_remote_address(int ssl, uws_websocket_t *ws,
+ const char **dest);
+size_t uws_ws_get_remote_address_as_text(int ssl, uws_websocket_t *ws,
+ const char **dest);
+
+// Response
+void uws_res_end(int ssl, uws_res_t *res, const char *data, size_t length,
+ bool close_connection);
+void uws_res_pause(int ssl, uws_res_t *res);
+void uws_res_resume(int ssl, uws_res_t *res);
+void uws_res_write_continue(int ssl, uws_res_t *res);
+void uws_res_write_status(int ssl, uws_res_t *res, const char *status,
+ size_t length);
+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);
+
+void uws_res_write_header_int(int ssl, uws_res_t *res, const char *key,
+ size_t key_length, uint64_t value);
+void uws_res_end_without_body(int ssl, uws_res_t *res);
+bool uws_res_write(int ssl, uws_res_t *res, const char *data, size_t length);
+uintmax_t uws_res_get_write_offset(int ssl, uws_res_t *res);
+bool uws_res_has_responded(int ssl, uws_res_t *res);
+void uws_res_on_writable(int ssl, uws_res_t *res,
+ bool (*handler)(uws_res_t *res, uintmax_t,
+ void *opcional_data),
+ void *user_data);
+void uws_res_on_aborted(int ssl, uws_res_t *res,
+ void (*handler)(uws_res_t *res, void *opcional_data),
+ void *opcional_data);
+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 *opcional_data),
+ void *opcional_data);
+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);
+
+// Request
+bool uws_req_is_ancient(uws_req_t *res);
+bool uws_req_get_yield(uws_req_t *res);
+void uws_req_set_field(uws_req_t *res, bool yield);
+size_t uws_req_get_url(uws_req_t *res, const char **dest);
+size_t uws_req_get_method(uws_req_t *res, const char **dest);
+size_t uws_req_get_header(uws_req_t *res, const char *lower_case_header,
+ size_t lower_case_header_length, const char **dest);
+size_t uws_req_get_query(uws_req_t *res, const char *key, size_t key_length,
+ const char **dest);
+size_t uws_req_get_parameter(uws_req_t *res, unsigned short index,
+ const char **dest);
+
+struct us_loop_t *uws_get_loop();
+
+void uws_loop_addPostHandler(us_loop_t *loop, void *ctx_,
+ void (*cb)(void *ctx, us_loop_t *loop));
+void uws_loop_removePostHandler(us_loop_t *loop, void *key);
+void uws_loop_addPreHandler(us_loop_t *loop, void *key,
+ void (*cb)(void *ctx, us_loop_t *loop));
+void uws_loop_removePreHandler(us_loop_t *loop, void *ctx_);
+void uws_loop_defer(us_loop_t *loop, void *ctx, void (*cb)(void *ctx));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif \ No newline at end of file
diff --git a/src/deps/libuwsockets.cpp b/src/deps/libuwsockets.cpp
new file mode 100644
index 000000000..ec082db43
--- /dev/null
+++ b/src/deps/libuwsockets.cpp
@@ -0,0 +1,984 @@
+#include "_libusockets.h"
+#include <string_view>
+#include <uws/src/App.h>
+
+extern "C" {
+
+uws_app_t *uws_create_app(int ssl, struct us_socket_context_options_t options) {
+ if (ssl) {
+ uWS::SocketContextOptions sco;
+ sco.ca_file_name = options.ca_file_name;
+ sco.cert_file_name = options.cert_file_name;
+ sco.dh_params_file_name = options.dh_params_file_name;
+ sco.key_file_name = options.key_file_name;
+ sco.passphrase = options.passphrase;
+ sco.ssl_prefer_low_memory_usage = options.ssl_prefer_low_memory_usage;
+ return (uws_app_t *)new uWS::SSLApp(sco);
+ }
+
+ return (uws_app_t *)new uWS::App();
+}
+
+void uws_app_get(int ssl, uws_app_t *app, const char *pattern,
+ uws_method_handler handler, void *user_data) {
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ uwsApp->get(pattern, [handler, user_data](auto *res, auto *req) {
+ handler((uws_res_t *)res, (uws_req_t *)req, user_data);
+ });
+ } else {
+ uWS::App *uwsApp = (uWS::App *)app;
+ uwsApp->get(pattern, [handler, user_data](auto *res, auto *req) {
+ handler((uws_res_t *)res, (uws_req_t *)req, user_data);
+ });
+ }
+}
+void uws_app_post(int ssl, uws_app_t *app, const char *pattern,
+ uws_method_handler handler, void *user_data) {
+
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ uwsApp->post(pattern, [handler, user_data](auto *res, auto *req) {
+ handler((uws_res_t *)res, (uws_req_t *)req, user_data);
+ });
+ } else {
+ uWS::App *uwsApp = (uWS::App *)app;
+ uwsApp->post(pattern, [handler, user_data](auto *res, auto *req) {
+ handler((uws_res_t *)res, (uws_req_t *)req, user_data);
+ });
+ }
+}
+void uws_app_options(int ssl, uws_app_t *app, const char *pattern,
+ uws_method_handler handler, void *user_data) {
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ uwsApp->options(pattern, [handler, user_data](auto *res, auto *req) {
+ handler((uws_res_t *)res, (uws_req_t *)req, user_data);
+ });
+ } else {
+ uWS::App *uwsApp = (uWS::App *)app;
+ uwsApp->options(pattern, [handler, user_data](auto *res, auto *req) {
+ handler((uws_res_t *)res, (uws_req_t *)req, user_data);
+ });
+ }
+}
+void uws_app_delete(int ssl, uws_app_t *app, const char *pattern,
+ uws_method_handler handler, void *user_data) {
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ uwsApp->del(pattern, [handler, user_data](auto *res, auto *req) {
+ handler((uws_res_t *)res, (uws_req_t *)req, user_data);
+ });
+ } else {
+ uWS::App *uwsApp = (uWS::App *)app;
+ uwsApp->del(pattern, [handler, user_data](auto *res, auto *req) {
+ handler((uws_res_t *)res, (uws_req_t *)req, user_data);
+ });
+ }
+}
+void uws_app_patch(int ssl, uws_app_t *app, const char *pattern,
+ uws_method_handler handler, void *user_data) {
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ uwsApp->patch(pattern, [handler, user_data](auto *res, auto *req) {
+ handler((uws_res_t *)res, (uws_req_t *)req, user_data);
+ });
+ } else {
+ uWS::App *uwsApp = (uWS::App *)app;
+ uwsApp->patch(pattern, [handler, user_data](auto *res, auto *req) {
+ handler((uws_res_t *)res, (uws_req_t *)req, user_data);
+ });
+ }
+}
+void uws_app_put(int ssl, uws_app_t *app, const char *pattern,
+ uws_method_handler handler, void *user_data) {
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ uwsApp->put(pattern, [handler, user_data](auto *res, auto *req) {
+ handler((uws_res_t *)res, (uws_req_t *)req, user_data);
+ });
+ } else {
+ uWS::App *uwsApp = (uWS::App *)app;
+ uwsApp->put(pattern, [handler, user_data](auto *res, auto *req) {
+ handler((uws_res_t *)res, (uws_req_t *)req, user_data);
+ });
+ }
+}
+void uws_app_head(int ssl, uws_app_t *app, const char *pattern,
+ uws_method_handler handler, void *user_data) {
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ uwsApp->head(pattern, [handler, user_data](auto *res, auto *req) {
+ handler((uws_res_t *)res, (uws_req_t *)req, user_data);
+ });
+ } else {
+ uWS::App *uwsApp = (uWS::App *)app;
+ uwsApp->head(pattern, [handler, user_data](auto *res, auto *req) {
+ handler((uws_res_t *)res, (uws_req_t *)req, user_data);
+ });
+ }
+}
+void uws_app_connect(int ssl, uws_app_t *app, const char *pattern,
+ uws_method_handler handler, void *user_data) {
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ uwsApp->connect(pattern, [handler, user_data](auto *res, auto *req) {
+ handler((uws_res_t *)res, (uws_req_t *)req, user_data);
+ });
+ } else {
+ uWS::App *uwsApp = (uWS::App *)app;
+ uwsApp->connect(pattern, [handler, user_data](auto *res, auto *req) {
+ handler((uws_res_t *)res, (uws_req_t *)req, user_data);
+ });
+ }
+}
+
+void uws_app_trace(int ssl, uws_app_t *app, const char *pattern,
+ uws_method_handler handler, void *user_data) {
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ uwsApp->trace(pattern, [handler, user_data](auto *res, auto *req) {
+ handler((uws_res_t *)res, (uws_req_t *)req, user_data);
+ });
+ } else {
+ uWS::App *uwsApp = (uWS::App *)app;
+ uwsApp->trace(pattern, [handler, user_data](auto *res, auto *req) {
+ handler((uws_res_t *)res, (uws_req_t *)req, user_data);
+ });
+ }
+}
+void uws_app_any(int ssl, uws_app_t *app, const char *pattern,
+ uws_method_handler handler, void *user_data) {
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ uwsApp->any(pattern, [handler, user_data](auto *res, auto *req) {
+ handler((uws_res_t *)res, (uws_req_t *)req, user_data);
+ });
+ } else {
+ uWS::App *uwsApp = (uWS::App *)app;
+ uwsApp->any(pattern, [handler, user_data](auto *res, auto *req) {
+ handler((uws_res_t *)res, (uws_req_t *)req, user_data);
+ });
+ }
+}
+
+void uws_app_run(int ssl, uws_app_t *app) {
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ uwsApp->run();
+ } else {
+ uWS::App *uwsApp = (uWS::App *)app;
+ uwsApp->run();
+ }
+}
+
+void uws_app_listen(int ssl, uws_app_t *app, int port,
+ uws_listen_handler handler, void *user_data) {
+ uws_app_listen_config_t config;
+ config.port = port;
+ config.host = nullptr;
+ config.options = 0;
+
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ uwsApp->listen(port, [handler, config,
+ user_data](struct us_listen_socket_t *listen_socket) {
+ handler((struct us_listen_socket_t *)listen_socket, config, user_data);
+ });
+ } else {
+ uWS::App *uwsApp = (uWS::App *)app;
+
+ uwsApp->listen(port, [handler, config,
+ user_data](struct us_listen_socket_t *listen_socket) {
+ handler((struct us_listen_socket_t *)listen_socket, config, user_data);
+ });
+ }
+}
+
+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) {
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ uwsApp->listen(
+ config.host, config.port, config.options,
+ [handler, config, user_data](struct us_listen_socket_t *listen_socket) {
+ handler((struct us_listen_socket_t *)listen_socket, config,
+ user_data);
+ });
+ } else {
+ uWS::App *uwsApp = (uWS::App *)app;
+ uwsApp->listen(
+ config.host, config.port, config.options,
+ [handler, config, user_data](struct us_listen_socket_t *listen_socket) {
+ handler((struct us_listen_socket_t *)listen_socket, config,
+ user_data);
+ });
+ }
+}
+
+void uws_app_destroy(int ssl, uws_app_t *app) {
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ delete uwsApp;
+ } else {
+
+ uWS::App *uwsApp = (uWS::App *)app;
+ delete uwsApp;
+ }
+}
+
+bool uws_constructor_failed(int ssl, uws_app_t *app) {
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ if (!uwsApp)
+ return true;
+ return uwsApp->constructorFailed();
+ }
+ uWS::App *uwsApp = (uWS::App *)app;
+ if (!uwsApp)
+ return true;
+ return uwsApp->constructorFailed();
+}
+
+unsigned int uws_num_subscribers(int ssl, uws_app_t *app, const char *topic) {
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ return uwsApp->numSubscribers(topic);
+ }
+ uWS::App *uwsApp = (uWS::App *)app;
+ return uwsApp->numSubscribers(topic);
+}
+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) {
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ return uwsApp->publish(std::string_view(topic, topic_length),
+ std::string_view(message, message_length),
+ (unsigned char)opcode, compress);
+ }
+ uWS::App *uwsApp = (uWS::App *)app;
+ return uwsApp->publish(std::string_view(topic, topic_length),
+ std::string_view(message, message_length),
+ (unsigned char)opcode, compress);
+}
+void *uws_get_native_handle(int ssl, uws_app_t *app) {
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ return uwsApp->getNativeHandle();
+ }
+ uWS::App *uwsApp = (uWS::App *)app;
+ return uwsApp->getNativeHandle();
+}
+void uws_remove_server_name(int ssl, uws_app_t *app,
+ const char *hostname_pattern) {
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ uwsApp->removeServerName(hostname_pattern);
+ } else {
+ uWS::App *uwsApp = (uWS::App *)app;
+ uwsApp->removeServerName(hostname_pattern);
+ }
+}
+void uws_add_server_name(int ssl, uws_app_t *app,
+ const char *hostname_pattern) {
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ uwsApp->addServerName(hostname_pattern);
+ } else {
+ uWS::App *uwsApp = (uWS::App *)app;
+ uwsApp->addServerName(hostname_pattern);
+ }
+}
+void uws_add_server_name_with_options(
+ int ssl, uws_app_t *app, const char *hostname_pattern,
+ struct us_socket_context_options_t options) {
+ uWS::SocketContextOptions sco;
+ sco.ca_file_name = options.ca_file_name;
+ sco.cert_file_name = options.cert_file_name;
+ sco.dh_params_file_name = options.dh_params_file_name;
+ sco.key_file_name = options.key_file_name;
+ sco.passphrase = options.passphrase;
+ sco.ssl_prefer_low_memory_usage = options.ssl_prefer_low_memory_usage;
+
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ uwsApp->addServerName(hostname_pattern, sco);
+ } else {
+ uWS::App *uwsApp = (uWS::App *)app;
+ uwsApp->addServerName(hostname_pattern, sco);
+ }
+}
+
+void uws_missing_server_name(int ssl, uws_app_t *app,
+ uws_missing_server_handler handler,
+ void *user_data) {
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ uwsApp->missingServerName(
+ [handler, user_data](auto hostname) { handler(hostname, user_data); });
+ } else {
+ uWS::App *uwsApp = (uWS::App *)app;
+ uwsApp->missingServerName(
+ [handler, user_data](auto hostname) { handler(hostname, user_data); });
+ }
+}
+void uws_filter(int ssl, uws_app_t *app, uws_filter_handler handler,
+ void *user_data) {
+ if (ssl) {
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+ uwsApp->filter([handler, user_data](auto res, auto i) {
+ handler((uws_res_t *)res, i, user_data);
+ });
+ } else {
+ uWS::App *uwsApp = (uWS::App *)app;
+
+ uwsApp->filter([handler, user_data](auto res, auto i) {
+ handler((uws_res_t *)res, i, user_data);
+ });
+ }
+}
+
+void uws_ws(int ssl, uws_app_t *app, const char *pattern,
+ uws_socket_behavior_t behavior) {
+ if (ssl) {
+ auto generic_handler = uWS::SSLApp::WebSocketBehavior<void *>{
+ .compression = (uWS::CompressOptions)(uint64_t)behavior.compression,
+ .maxPayloadLength = behavior.maxPayloadLength,
+ .idleTimeout = behavior.idleTimeout,
+ .maxBackpressure = behavior.maxBackpressure,
+ .closeOnBackpressureLimit = behavior.closeOnBackpressureLimit,
+ .resetIdleTimeoutOnSend = behavior.resetIdleTimeoutOnSend,
+ .sendPingsAutomatically = behavior.sendPingsAutomatically,
+ .maxLifetime = behavior.maxLifetime,
+ };
+
+ if (behavior.upgrade)
+ generic_handler.upgrade = [behavior](auto *res, auto *req,
+ auto *context) {
+ behavior.upgrade((uws_res_t *)res, (uws_req_t *)req,
+ (uws_socket_context_t *)context);
+ };
+ if (behavior.open)
+ generic_handler.open = [behavior](auto *ws) {
+ behavior.open((uws_websocket_t *)ws);
+ };
+ if (behavior.message)
+ generic_handler.message = [behavior](auto *ws, auto message,
+ auto opcode) {
+ behavior.message((uws_websocket_t *)ws, message.data(),
+ message.length(), (uws_opcode_t)opcode);
+ };
+ if (behavior.drain)
+ generic_handler.drain = [behavior](auto *ws) {
+ behavior.drain((uws_websocket_t *)ws);
+ };
+ if (behavior.ping)
+ generic_handler.ping = [behavior](auto *ws, auto message) {
+ behavior.ping((uws_websocket_t *)ws, message.data(), message.length());
+ };
+ if (behavior.pong)
+ generic_handler.pong = [behavior](auto *ws, auto message) {
+ behavior.pong((uws_websocket_t *)ws, message.data(), message.length());
+ };
+ if (behavior.close)
+ generic_handler.close = [behavior](auto *ws, int code, auto message) {
+ behavior.close((uws_websocket_t *)ws, code, message.data(),
+ message.length());
+ };
+ uWS::SSLApp *uwsApp = (uWS::SSLApp *)app;
+
+ uwsApp->ws<void *>(pattern, std::move(generic_handler));
+ } else {
+ auto generic_handler = uWS::App::WebSocketBehavior<void *>{
+ .compression = (uWS::CompressOptions)(uint64_t)behavior.compression,
+ .maxPayloadLength = behavior.maxPayloadLength,
+ .idleTimeout = behavior.idleTimeout,
+ .maxBackpressure = behavior.maxBackpressure,
+ .closeOnBackpressureLimit = behavior.closeOnBackpressureLimit,
+ .resetIdleTimeoutOnSend = behavior.resetIdleTimeoutOnSend,
+ .sendPingsAutomatically = behavior.sendPingsAutomatically,
+ .maxLifetime = behavior.maxLifetime,
+ };
+
+ if (behavior.upgrade)
+ generic_handler.upgrade = [behavior](auto *res, auto *req,
+ auto *context) {
+ behavior.upgrade((uws_res_t *)res, (uws_req_t *)req,
+ (uws_socket_context_t *)context);
+ };
+ if (behavior.open)
+ generic_handler.open = [behavior](auto *ws) {
+ behavior.open((uws_websocket_t *)ws);
+ };
+ if (behavior.message)
+ generic_handler.message = [behavior](auto *ws, auto message,
+ auto opcode) {
+ behavior.message((uws_websocket_t *)ws, message.data(),
+ message.length(), (uws_opcode_t)opcode);
+ };
+ if (behavior.drain)
+ generic_handler.drain = [behavior](auto *ws) {
+ behavior.drain((uws_websocket_t *)ws);
+ };
+ if (behavior.ping)
+ generic_handler.ping = [behavior](auto *ws, auto message) {
+ behavior.ping((uws_websocket_t *)ws, message.data(), message.length());
+ };
+ if (behavior.pong)
+ generic_handler.pong = [behavior](auto *ws, auto message) {
+ behavior.pong((uws_websocket_t *)ws, message.data(), message.length());
+ };
+ if (behavior.close)
+ generic_handler.close = [behavior](auto *ws, int code, auto message) {
+ behavior.close((uws_websocket_t *)ws, code, message.data(),
+ message.length());
+ };
+ uWS::App *uwsApp = (uWS::App *)app;
+ uwsApp->ws<void *>(pattern, std::move(generic_handler));
+ }
+}
+
+void *uws_ws_get_user_data(int ssl, uws_websocket_t *ws) {
+ if (ssl) {
+ uWS::WebSocket<true, true, void *> *uws =
+ (uWS::WebSocket<true, true, void *> *)ws;
+ return *uws->getUserData();
+ }
+ uWS::WebSocket<false, true, void *> *uws =
+ (uWS::WebSocket<false, true, void *> *)ws;
+ return *uws->getUserData();
+}
+
+void uws_ws_close(int ssl, uws_websocket_t *ws) {
+ if (ssl) {
+ uWS::WebSocket<true, true, void *> *uws =
+ (uWS::WebSocket<true, true, void *> *)ws;
+ uws->close();
+ } else {
+ uWS::WebSocket<false, true, void *> *uws =
+ (uWS::WebSocket<false, true, void *> *)ws;
+ uws->close();
+ }
+}
+
+uws_sendstatus_t uws_ws_send(int ssl, uws_websocket_t *ws, const char *message,
+ size_t length, uws_opcode_t opcode) {
+ if (ssl) {
+ uWS::WebSocket<true, true, void *> *uws =
+ (uWS::WebSocket<true, true, void *> *)ws;
+ return (uws_sendstatus_t)uws->send(std::string_view(message, length),
+ (uWS::OpCode)(unsigned char)opcode);
+ }
+ uWS::WebSocket<false, true, void *> *uws =
+ (uWS::WebSocket<false, true, void *> *)ws;
+ return (uws_sendstatus_t)uws->send(std::string_view(message, length),
+ (uWS::OpCode)(unsigned char)opcode);
+}
+
+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) {
+ if (ssl) {
+ uWS::WebSocket<true, true, void *> *uws =
+ (uWS::WebSocket<true, true, void *> *)ws;
+ return (uws_sendstatus_t)uws->send(std::string_view(message),
+ (uWS::OpCode)(unsigned char)opcode,
+ compress, fin);
+ }
+ uWS::WebSocket<false, true, void *> *uws =
+ (uWS::WebSocket<false, true, void *> *)ws;
+ return (uws_sendstatus_t)uws->send(std::string_view(message),
+ (uWS::OpCode)(unsigned char)opcode,
+ compress, fin);
+}
+
+uws_sendstatus_t uws_ws_send_fragment(int ssl, uws_websocket_t *ws,
+ const char *message, size_t length,
+ bool compress) {
+ if (ssl) {
+ uWS::WebSocket<true, true, void *> *uws =
+ (uWS::WebSocket<true, true, void *> *)ws;
+ return (uws_sendstatus_t)uws->sendFragment(
+ std::string_view(message, length), compress);
+ }
+ uWS::WebSocket<false, true, void *> *uws =
+ (uWS::WebSocket<false, true, void *> *)ws;
+ return (uws_sendstatus_t)uws->sendFragment(std::string_view(message, length),
+ compress);
+}
+uws_sendstatus_t uws_ws_send_first_fragment(int ssl, uws_websocket_t *ws,
+ const char *message, size_t length,
+ bool compress) {
+ if (ssl) {
+ uWS::WebSocket<true, true, void *> *uws =
+ (uWS::WebSocket<true, true, void *> *)ws;
+ return (uws_sendstatus_t)uws->sendFirstFragment(
+ std::string_view(message), uWS::OpCode::BINARY, compress);
+ }
+ uWS::WebSocket<false, true, void *> *uws =
+ (uWS::WebSocket<false, true, void *> *)ws;
+ return (uws_sendstatus_t)uws->sendFirstFragment(
+ std::string_view(message), uWS::OpCode::BINARY, compress);
+}
+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) {
+ if (ssl) {
+ uWS::WebSocket<true, true, void *> *uws =
+ (uWS::WebSocket<true, true, void *> *)ws;
+ return (uws_sendstatus_t)uws->sendFirstFragment(
+ std::string_view(message, length), (uWS::OpCode)(unsigned char)opcode,
+ compress);
+ }
+ uWS::WebSocket<false, true, void *> *uws =
+ (uWS::WebSocket<false, true, void *> *)ws;
+ return (uws_sendstatus_t)uws->sendFirstFragment(
+ std::string_view(message, length), (uWS::OpCode)(unsigned char)opcode,
+ compress);
+}
+uws_sendstatus_t uws_ws_send_last_fragment(int ssl, uws_websocket_t *ws,
+ const char *message, size_t length,
+ bool compress) {
+ if (ssl) {
+ uWS::WebSocket<true, true, void *> *uws =
+ (uWS::WebSocket<true, true, void *> *)ws;
+ return (uws_sendstatus_t)uws->sendLastFragment(
+ std::string_view(message, length), compress);
+ }
+ uWS::WebSocket<false, true, void *> *uws =
+ (uWS::WebSocket<false, true, void *> *)ws;
+ return (uws_sendstatus_t)uws->sendLastFragment(
+ std::string_view(message, length), compress);
+}
+
+void uws_ws_end(int ssl, uws_websocket_t *ws, int code, const char *message,
+ size_t length) {
+ if (ssl) {
+ uWS::WebSocket<true, true, void *> *uws =
+ (uWS::WebSocket<true, true, void *> *)ws;
+ uws->end(code, std::string_view(message, length));
+ } else {
+ uWS::WebSocket<false, true, void *> *uws =
+ (uWS::WebSocket<false, true, void *> *)ws;
+ uws->end(code, std::string_view(message, length));
+ }
+}
+
+void uws_ws_cork(int ssl, uws_websocket_t *ws, void (*handler)(void *user_data),
+ void *user_data) {
+ if (ssl) {
+ uWS::WebSocket<true, true, void *> *uws =
+ (uWS::WebSocket<true, true, void *> *)ws;
+ uws->cork([handler, user_data]() { handler(user_data); });
+ } else {
+ uWS::WebSocket<false, true, void *> *uws =
+ (uWS::WebSocket<false, true, void *> *)ws;
+
+ uws->cork([handler, user_data]() { handler(user_data); });
+ }
+}
+bool uws_ws_subscribe(int ssl, uws_websocket_t *ws, const char *topic,
+ size_t length) {
+ if (ssl) {
+ uWS::WebSocket<true, true, void *> *uws =
+ (uWS::WebSocket<true, true, void *> *)ws;
+ return uws->subscribe(std::string_view(topic, length));
+ }
+ uWS::WebSocket<false, true, void *> *uws =
+ (uWS::WebSocket<false, true, void *> *)ws;
+ return uws->subscribe(std::string_view(topic, length));
+}
+bool uws_ws_unsubscribe(int ssl, uws_websocket_t *ws, const char *topic,
+ size_t length) {
+ if (ssl) {
+ uWS::WebSocket<true, true, void *> *uws =
+ (uWS::WebSocket<true, true, void *> *)ws;
+ return uws->unsubscribe(std::string_view(topic, length));
+ }
+ uWS::WebSocket<false, true, void *> *uws =
+ (uWS::WebSocket<false, true, void *> *)ws;
+ return uws->unsubscribe(std::string_view(topic, length));
+}
+
+bool uws_ws_is_subscribed(int ssl, uws_websocket_t *ws, const char *topic,
+ size_t length) {
+ if (ssl) {
+ uWS::WebSocket<true, true, void *> *uws =
+ (uWS::WebSocket<true, true, void *> *)ws;
+ return uws->isSubscribed(std::string_view(topic, length));
+ }
+ uWS::WebSocket<false, true, void *> *uws =
+ (uWS::WebSocket<false, true, void *> *)ws;
+ return uws->isSubscribed(std::string_view(topic, length));
+}
+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) {
+ if (ssl) {
+ uWS::WebSocket<true, true, void *> *uws =
+ (uWS::WebSocket<true, true, void *> *)ws;
+ uws->iterateTopics([callback, user_data](auto topic) {
+ callback(topic.data(), topic.length(), user_data);
+ });
+ } else {
+ uWS::WebSocket<false, true, void *> *uws =
+ (uWS::WebSocket<false, true, void *> *)ws;
+
+ uws->iterateTopics([callback, user_data](auto topic) {
+ callback(topic.data(), topic.length(), user_data);
+ });
+ }
+}
+
+bool uws_ws_publish(int ssl, uws_websocket_t *ws, const char *topic,
+ size_t topic_length, const char *message,
+ size_t message_length) {
+ if (ssl) {
+ uWS::WebSocket<true, true, void *> *uws =
+ (uWS::WebSocket<true, true, void *> *)ws;
+ return uws->publish(std::string_view(topic, topic_length),
+ std::string_view(message, message_length));
+ }
+ uWS::WebSocket<false, true, void *> *uws =
+ (uWS::WebSocket<false, true, void *> *)ws;
+ return uws->publish(std::string_view(topic, topic_length),
+ std::string_view(message, message_length));
+}
+
+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) {
+ if (ssl) {
+ uWS::WebSocket<true, true, void *> *uws =
+ (uWS::WebSocket<true, true, void *> *)ws;
+ return uws->publish(std::string_view(topic, topic_length),
+ std::string_view(message, message_length),
+ (uWS::OpCode)(unsigned char)opcode, compress);
+ }
+ uWS::WebSocket<false, true, void *> *uws =
+ (uWS::WebSocket<false, true, void *> *)ws;
+ return uws->publish(std::string_view(topic, topic_length),
+ std::string_view(message, message_length),
+ (uWS::OpCode)(unsigned char)opcode, compress);
+}
+
+unsigned int uws_ws_get_buffered_amount(int ssl, uws_websocket_t *ws) {
+ if (ssl) {
+ uWS::WebSocket<true, true, void *> *uws =
+ (uWS::WebSocket<true, true, void *> *)ws;
+ return uws->getBufferedAmount();
+ }
+ uWS::WebSocket<false, true, void *> *uws =
+ (uWS::WebSocket<false, true, void *> *)ws;
+ return uws->getBufferedAmount();
+}
+
+size_t uws_ws_get_remote_address(int ssl, uws_websocket_t *ws,
+ const char **dest) {
+ if (ssl) {
+ uWS::WebSocket<true, true, void *> *uws =
+ (uWS::WebSocket<true, true, void *> *)ws;
+ std::string_view value = uws->getRemoteAddress();
+ *dest = value.data();
+ return value.length();
+ }
+ uWS::WebSocket<false, true, void *> *uws =
+ (uWS::WebSocket<false, true, void *> *)ws;
+
+ std::string_view value = uws->getRemoteAddress();
+ *dest = value.data();
+ return value.length();
+}
+
+size_t uws_ws_get_remote_address_as_text(int ssl, uws_websocket_t *ws,
+ const char **dest) {
+ if (ssl) {
+ uWS::WebSocket<true, true, void *> *uws =
+ (uWS::WebSocket<true, true, void *> *)ws;
+
+ std::string_view value = uws->getRemoteAddressAsText();
+ *dest = value.data();
+ return value.length();
+ }
+ uWS::WebSocket<false, true, void *> *uws =
+ (uWS::WebSocket<false, true, void *> *)ws;
+
+ std::string_view value = uws->getRemoteAddressAsText();
+ *dest = value.data();
+ return value.length();
+}
+
+void uws_res_end(int ssl, uws_res_t *res, const char *data, size_t length,
+ bool close_connection) {
+ if (ssl) {
+ uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
+ uwsRes->end(std::string_view(data, length), close_connection);
+ } else {
+ uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
+ uwsRes->end(std::string_view(data, length), close_connection);
+ }
+}
+
+void uws_res_pause(int ssl, uws_res_t *res) {
+ if (ssl) {
+ uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
+ uwsRes->pause();
+ } else {
+ uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
+ uwsRes->pause();
+ }
+}
+
+void uws_res_resume(int ssl, uws_res_t *res) {
+ if (ssl) {
+ uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
+ uwsRes->pause();
+ } else {
+ uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
+ uwsRes->pause();
+ }
+}
+
+void uws_res_write_continue(int ssl, uws_res_t *res) {
+ if (ssl) {
+ uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
+ uwsRes->writeContinue();
+ } else {
+ uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
+ uwsRes->writeContinue();
+ }
+}
+
+void uws_res_write_status(int ssl, uws_res_t *res, const char *status,
+ size_t length) {
+ if (ssl) {
+ uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
+ uwsRes->writeStatus(std::string_view(status, length));
+ } else {
+ uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
+ uwsRes->writeStatus(std::string_view(status, length));
+ }
+}
+
+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) {
+ if (ssl) {
+ uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
+ uwsRes->writeHeader(std::string_view(key, key_length),
+ std::string_view(value, value_length));
+ } else {
+ uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
+ uwsRes->writeHeader(std::string_view(key, key_length),
+ std::string_view(value, value_length));
+ }
+}
+void uws_res_write_header_int(int ssl, uws_res_t *res, const char *key,
+ size_t key_length, uint64_t value) {
+ if (ssl) {
+ uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
+ uwsRes->writeHeader(std::string_view(key, key_length), value);
+ } else {
+
+ uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
+ uwsRes->writeHeader(std::string_view(key, key_length), value);
+ }
+}
+
+void uws_res_end_without_body(int ssl, uws_res_t *res) {
+ if (ssl) {
+ uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
+ uwsRes->endWithoutBody(0);
+ } else {
+ uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
+ uwsRes->endWithoutBody(0);
+ }
+}
+
+bool uws_res_write(int ssl, uws_res_t *res, const char *data, size_t length) {
+ if (ssl) {
+ uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
+ return uwsRes->write(std::string_view(data));
+ }
+ uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
+ return uwsRes->write(std::string_view(data));
+}
+uintmax_t uws_res_get_write_offset(int ssl, uws_res_t *res) {
+ if (ssl) {
+ uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
+ return uwsRes->getWriteOffset();
+ }
+ uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
+ return uwsRes->getWriteOffset();
+}
+
+bool uws_res_has_responded(int ssl, uws_res_t *res) {
+ if (ssl) {
+ uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
+ return uwsRes->hasResponded();
+ }
+ uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
+ return uwsRes->hasResponded();
+}
+
+void uws_res_on_writable(int ssl, uws_res_t *res,
+ bool (*handler)(uws_res_t *res, uintmax_t,
+ void *opcional_data),
+ void *opcional_data) {
+ if (ssl) {
+ uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
+ uwsRes->onWritable([handler, res, opcional_data](uintmax_t a) {
+ return handler(res, a, opcional_data);
+ });
+ } else {
+ uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
+ uwsRes->onWritable([handler, res, opcional_data](uintmax_t a) {
+ return handler(res, a, opcional_data);
+ });
+ }
+}
+
+void uws_res_on_aborted(int ssl, uws_res_t *res,
+ void (*handler)(uws_res_t *res, void *opcional_data),
+ void *opcional_data) {
+ if (ssl) {
+ uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
+ uwsRes->onAborted(
+ [handler, res, opcional_data] { handler(res, opcional_data); });
+ } else {
+ uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
+ uwsRes->onAborted(
+ [handler, res, opcional_data] { handler(res, opcional_data); });
+ }
+}
+
+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 *opcional_data),
+ void *opcional_data) {
+ if (ssl) {
+ uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
+ uwsRes->onData([handler, res, opcional_data](auto chunk, bool is_end) {
+ handler(res, chunk.data(), chunk.length(), is_end, opcional_data);
+ });
+ } else {
+ uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
+ uwsRes->onData([handler, res, opcional_data](auto chunk, bool is_end) {
+ handler(res, chunk.data(), chunk.length(), is_end, opcional_data);
+ });
+ }
+}
+
+bool uws_req_is_ancient(uws_req_t *res) {
+ uWS::HttpRequest *uwsReq = (uWS::HttpRequest *)res;
+ return uwsReq->isAncient();
+}
+
+bool uws_req_get_yield(uws_req_t *res) {
+ uWS::HttpRequest *uwsReq = (uWS::HttpRequest *)res;
+ return uwsReq->getYield();
+}
+
+void uws_req_set_field(uws_req_t *res, bool yield) {
+ uWS::HttpRequest *uwsReq = (uWS::HttpRequest *)res;
+ return uwsReq->setYield(yield);
+}
+
+size_t uws_req_get_url(uws_req_t *res, const char **dest) {
+ uWS::HttpRequest *uwsReq = (uWS::HttpRequest *)res;
+ std::string_view value = uwsReq->getUrl();
+ *dest = value.data();
+ return value.length();
+}
+
+size_t uws_req_get_method(uws_req_t *res, const char **dest) {
+ uWS::HttpRequest *uwsReq = (uWS::HttpRequest *)res;
+ std::string_view value = uwsReq->getMethod();
+ *dest = value.data();
+ return value.length();
+}
+
+size_t uws_req_get_header(uws_req_t *res, const char *lower_case_header,
+ size_t lower_case_header_length, const char **dest) {
+ uWS::HttpRequest *uwsReq = (uWS::HttpRequest *)res;
+
+ std::string_view value = uwsReq->getHeader(
+ std::string_view(lower_case_header, lower_case_header_length));
+ *dest = value.data();
+ return value.length();
+}
+
+size_t uws_req_get_query(uws_req_t *res, const char *key, size_t key_length,
+ const char **dest) {
+ uWS::HttpRequest *uwsReq = (uWS::HttpRequest *)res;
+
+ std::string_view value = uwsReq->getQuery(std::string_view(key, key_length));
+ *dest = value.data();
+ return value.length();
+}
+
+size_t uws_req_get_parameter(uws_req_t *res, unsigned short index,
+ const char **dest) {
+ uWS::HttpRequest *uwsReq = (uWS::HttpRequest *)res;
+ std::string_view value = uwsReq->getParameter(index);
+ *dest = value.data();
+ return value.length();
+}
+
+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) {
+ uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
+
+ uwsRes->template upgrade<void *>(
+ data ? std::move(data) : NULL,
+ std::string_view(sec_web_socket_key, sec_web_socket_key_length),
+ std::string_view(sec_web_socket_protocol, sec_web_socket_protocol_length),
+ std::string_view(sec_web_socket_extensions,
+ sec_web_socket_extensions_length),
+ (struct us_socket_context_t *)ws);
+}
+
+struct us_loop_t *uws_get_loop() {
+ return (struct us_loop_t *)uWS::Loop::get();
+}
+
+void uws_loop_addPostHandler(us_loop_t *loop, void *ctx_,
+ void (*cb)(void *ctx, us_loop_t *loop)) {
+ uWS::Loop *uwsLoop = (uWS::Loop *)loop;
+ uwsLoop->addPostHandler(ctx_, [ctx_, cb](uWS::Loop *uwsLoop_) {
+ cb(ctx_, (us_loop_t *)uwsLoop_);
+ });
+}
+void uws_loop_removePostHandler(us_loop_t *loop, void *key) {
+ uWS::Loop *uwsLoop = (uWS::Loop *)loop;
+ uwsLoop->removePostHandler(key);
+}
+void uws_loop_addPreHandler(us_loop_t *loop, void *ctx_,
+ void (*cb)(void *ctx, us_loop_t *loop)) {
+ uWS::Loop *uwsLoop = (uWS::Loop *)loop;
+ uwsLoop->addPreHandler(ctx_, [ctx_, cb](uWS::Loop *uwsLoop_) {
+ cb(ctx_, (us_loop_t *)uwsLoop_);
+ });
+}
+void uws_loop_removePreHandler(us_loop_t *loop, void *ctx_) {
+ uWS::Loop *uwsLoop = (uWS::Loop *)loop;
+ uwsLoop->removePreHandler(ctx_);
+}
+void uws_loop_defer(us_loop_t *loop, void *ctx, void (*cb)(void *ctx)) {
+ uWS::Loop *uwsLoop = (uWS::Loop *)loop;
+ uwsLoop->defer([ctx, cb]() { cb(ctx); });
+}
+} \ No newline at end of file
diff --git a/src/deps/uws.zig b/src/deps/uws.zig
new file mode 100644
index 000000000..fc7a32865
--- /dev/null
+++ b/src/deps/uws.zig
@@ -0,0 +1,626 @@
+pub const u_int8_t = u8;
+pub const u_int16_t = c_ushort;
+pub const u_int32_t = c_uint;
+pub const u_int64_t = c_ulonglong;
+pub const LIBUS_LISTEN_DEFAULT: c_int = 0;
+pub const LIBUS_LISTEN_EXCLUSIVE_PORT: c_int = 1;
+pub const us_socket_t = opaque {};
+pub const us_timer_t = opaque {};
+pub const us_socket_context_t = opaque {};
+pub const Loop = opaque {
+ pub fn get() ?*Loop {
+ return uws_get_loop();
+ }
+
+ pub fn wakeup(this: *Loop) void {
+ return us_wakeup_loop(this);
+ }
+
+ pub fn nextTick(this: *Loop, comptime UserType: type, user_data: UserType, comptime deferCallback: fn (ctx: UserType) void) void {
+ const Handler = struct {
+ pub fn callback(data: *anyopaque) callconv(.C) void {
+ deferCallback(@ptrCast(UserType, @alignCast(@alignOf(UserType), data)));
+ }
+ };
+ uws_loop_defer(this, user_data, Handler.callback);
+ }
+
+ extern fn uws_loop_defer(loop: *Loop, ctx: *anyopaque, cb: fn (ctx: *anyopaque) callconv(.C) void) void;
+
+ extern fn uws_get_loop() ?*Loop;
+ extern fn us_create_loop(hint: ?*anyopaque, wakeup_cb: ?fn (?*Loop) callconv(.C) void, pre_cb: ?fn (?*Loop) callconv(.C) void, post_cb: ?fn (?*Loop) callconv(.C) void, ext_size: c_uint) ?*Loop;
+ extern fn us_loop_free(loop: ?*Loop) void;
+ extern fn us_loop_ext(loop: ?*Loop) ?*anyopaque;
+ extern fn us_loop_run(loop: ?*Loop) void;
+ extern fn us_wakeup_loop(loop: ?*Loop) void;
+ extern fn us_loop_integrate(loop: ?*Loop) void;
+ extern fn us_loop_iteration_number(loop: ?*Loop) c_longlong;
+};
+const uintmax_t = c_ulong;
+
+extern fn us_create_timer(loop: ?*Loop, fallthrough: c_int, ext_size: c_uint) ?*us_timer_t;
+extern fn us_timer_ext(timer: ?*us_timer_t) ?*anyopaque;
+extern fn us_timer_close(timer: ?*us_timer_t) void;
+extern fn us_timer_set(timer: ?*us_timer_t, cb: ?fn (?*us_timer_t) callconv(.C) void, ms: c_int, repeat_ms: c_int) void;
+extern fn us_timer_loop(t: ?*us_timer_t) ?*Loop;
+pub const us_socket_context_options_t = extern struct {
+ key_file_name: [*c]const u8 = null,
+ cert_file_name: [*c]const u8 = null,
+ passphrase: [*c]const u8 = null,
+ dh_params_file_name: [*c]const u8 = null,
+ ca_file_name: [*c]const u8 = null,
+ ssl_prefer_low_memory_usage: c_int = 0,
+};
+
+extern fn us_socket_context_timestamp(ssl: c_int, context: ?*us_socket_context_t) c_ushort;
+extern fn us_socket_context_add_server_name(ssl: c_int, context: ?*us_socket_context_t, hostname_pattern: [*c]const u8, options: us_socket_context_options_t) void;
+extern fn us_socket_context_remove_server_name(ssl: c_int, context: ?*us_socket_context_t, hostname_pattern: [*c]const u8) void;
+extern fn us_socket_context_on_server_name(ssl: c_int, context: ?*us_socket_context_t, cb: ?fn (?*us_socket_context_t, [*c]const u8) callconv(.C) void) void;
+extern fn us_socket_context_get_native_handle(ssl: c_int, context: ?*us_socket_context_t) ?*anyopaque;
+extern fn us_create_socket_context(ssl: c_int, loop: ?*Loop, ext_size: c_int, options: us_socket_context_options_t) ?*us_socket_context_t;
+extern fn us_socket_context_free(ssl: c_int, context: ?*us_socket_context_t) void;
+extern fn us_socket_context_on_open(ssl: c_int, context: ?*us_socket_context_t, on_open: ?fn (?*us_socket_t, c_int, [*c]u8, c_int) callconv(.C) ?*us_socket_t) void;
+extern fn us_socket_context_on_close(ssl: c_int, context: ?*us_socket_context_t, on_close: ?fn (?*us_socket_t, c_int, ?*anyopaque) callconv(.C) ?*us_socket_t) void;
+extern fn us_socket_context_on_data(ssl: c_int, context: ?*us_socket_context_t, on_data: ?fn (?*us_socket_t, [*c]u8, c_int) callconv(.C) ?*us_socket_t) void;
+extern fn us_socket_context_on_writable(ssl: c_int, context: ?*us_socket_context_t, on_writable: ?fn (?*us_socket_t) callconv(.C) ?*us_socket_t) void;
+extern fn us_socket_context_on_timeout(ssl: c_int, context: ?*us_socket_context_t, on_timeout: ?fn (?*us_socket_t) callconv(.C) ?*us_socket_t) void;
+extern fn us_socket_context_on_connect_error(ssl: c_int, context: ?*us_socket_context_t, on_connect_error: ?fn (?*us_socket_t, c_int) callconv(.C) ?*us_socket_t) void;
+extern fn us_socket_context_on_end(ssl: c_int, context: ?*us_socket_context_t, on_end: ?fn (?*us_socket_t) callconv(.C) ?*us_socket_t) void;
+extern fn us_socket_context_ext(ssl: c_int, context: ?*us_socket_context_t) ?*anyopaque;
+
+extern fn us_socket_context_listen(ssl: c_int, context: ?*us_socket_context_t, host: [*c]const u8, port: c_int, options: c_int, socket_ext_size: c_int) ?*listen_socket_t;
+
+extern fn us_socket_context_connect(ssl: c_int, context: ?*us_socket_context_t, host: [*c]const u8, port: c_int, source_host: [*c]const u8, options: c_int, socket_ext_size: c_int) ?*us_socket_t;
+extern fn us_socket_is_established(ssl: c_int, s: ?*us_socket_t) c_int;
+extern fn us_socket_close_connecting(ssl: c_int, s: ?*us_socket_t) ?*us_socket_t;
+extern fn us_socket_context_loop(ssl: c_int, context: ?*us_socket_context_t) ?*Loop;
+extern fn us_socket_context_adopt_socket(ssl: c_int, context: ?*us_socket_context_t, s: ?*us_socket_t, ext_size: c_int) ?*us_socket_t;
+extern fn us_create_child_socket_context(ssl: c_int, context: ?*us_socket_context_t, context_ext_size: c_int) ?*us_socket_context_t;
+
+pub const Poll = opaque {
+ extern fn us_create_poll(loop: ?*Loop, fallthrough: c_int, ext_size: c_uint) ?*Poll;
+ extern fn us_poll_free(p: ?*Poll, loop: ?*Loop) void;
+ extern fn us_poll_init(p: ?*Poll, fd: c_int, poll_type: c_int) void;
+ extern fn us_poll_start(p: ?*Poll, loop: ?*Loop, events: c_int) void;
+ extern fn us_poll_change(p: ?*Poll, loop: ?*Loop, events: c_int) void;
+ extern fn us_poll_stop(p: ?*Poll, loop: ?*Loop) void;
+ extern fn us_poll_events(p: ?*Poll) c_int;
+ extern fn us_poll_ext(p: ?*Poll) ?*anyopaque;
+ extern fn us_poll_fd(p: ?*Poll) c_int;
+ extern fn us_poll_resize(p: ?*Poll, loop: ?*Loop, ext_size: c_uint) ?*Poll;
+};
+
+extern fn us_socket_get_native_handle(ssl: c_int, s: ?*us_socket_t) ?*anyopaque;
+extern fn us_socket_write(ssl: c_int, s: ?*us_socket_t, data: [*c]const u8, length: c_int, msg_more: c_int) c_int;
+extern fn us_socket_timeout(ssl: c_int, s: ?*us_socket_t, seconds: c_uint) void;
+extern fn us_socket_ext(ssl: c_int, s: ?*us_socket_t) ?*anyopaque;
+extern fn us_socket_context(ssl: c_int, s: ?*us_socket_t) ?*us_socket_context_t;
+extern fn us_socket_flush(ssl: c_int, s: ?*us_socket_t) void;
+extern fn us_socket_shutdown(ssl: c_int, s: ?*us_socket_t) void;
+extern fn us_socket_shutdown_read(ssl: c_int, s: ?*us_socket_t) void;
+extern fn us_socket_is_shut_down(ssl: c_int, s: ?*us_socket_t) c_int;
+extern fn us_socket_is_closed(ssl: c_int, s: ?*us_socket_t) c_int;
+extern fn us_socket_close(ssl: c_int, s: ?*us_socket_t, code: c_int, reason: ?*anyopaque) ?*us_socket_t;
+extern fn us_socket_local_port(ssl: c_int, s: ?*us_socket_t) c_int;
+extern fn us_socket_remote_address(ssl: c_int, s: ?*us_socket_t, buf: [*c]u8, length: [*c]c_int) void;
+pub const uws_app_s = opaque {};
+pub const uws_req_s = opaque {};
+pub const uws_websocket_s = opaque {};
+pub const uws_header_iterator_s = opaque {};
+pub const uws_app_t = uws_app_s;
+
+pub const uws_socket_context_s = opaque {};
+pub const uws_socket_context_t = uws_socket_context_s;
+pub const uws_websocket_t = uws_websocket_s;
+pub const uws_websocket_handler = ?fn (?*uws_websocket_t) callconv(.C) void;
+pub const uws_websocket_message_handler = ?fn (?*uws_websocket_t, [*c]const u8, usize, uws_opcode_t) callconv(.C) void;
+pub const uws_websocket_ping_pong_handler = ?fn (?*uws_websocket_t, [*c]const u8, usize) callconv(.C) void;
+pub const uws_websocket_close_handler = ?fn (?*uws_websocket_t, c_int, [*c]const u8, usize) callconv(.C) void;
+pub const uws_websocket_upgrade_handler = ?fn (*uws_res, ?*Request, ?*uws_socket_context_t) callconv(.C) void;
+pub const uws_socket_behavior_t = extern struct {
+ compression: uws_compress_options_t,
+ maxPayloadLength: c_uint,
+ idleTimeout: c_ushort,
+ maxBackpressure: c_uint,
+ closeOnBackpressureLimit: bool,
+ resetIdleTimeoutOnSend: bool,
+ sendPingsAutomatically: bool,
+ maxLifetime: c_ushort,
+ upgrade: uws_websocket_upgrade_handler,
+ open: uws_websocket_handler,
+ message: uws_websocket_message_handler,
+ drain: uws_websocket_handler,
+ ping: uws_websocket_ping_pong_handler,
+ pong: uws_websocket_ping_pong_handler,
+ close: uws_websocket_close_handler,
+};
+pub const uws_listen_handler = ?fn (?*listen_socket_t, uws_app_listen_config_t, ?*anyopaque) callconv(.C) void;
+pub const uws_method_handler = ?fn (*uws_res, *Request, ?*anyopaque) callconv(.C) void;
+pub const uws_filter_handler = ?fn (*uws_res, c_int, ?*anyopaque) callconv(.C) void;
+pub const uws_missing_server_handler = ?fn ([*c]const u8, ?*anyopaque) callconv(.C) void;
+
+pub const Request = opaque {
+ pub fn isAncient(req: *Request) bool {
+ return uws_req_is_ancient(req);
+ }
+ pub fn getYield(req: *Request) bool {
+ return uws_req_get_yield(req);
+ }
+ pub fn setYield(req: *Request, yield: bool) void {
+ uws_req_set_field(req, yield);
+ }
+ pub fn url(req: *Request) []const u8 {
+ var ptr: [*]const u8 = undefined;
+ return ptr[0..req.uws_req_get_url(&ptr)];
+ }
+ pub fn method(req: *Request) []const u8 {
+ var ptr: [*]const u8 = undefined;
+ return ptr[0..req.uws_req_get_method(&ptr)];
+ }
+ pub fn header(req: *Request, name: []const u8) []const u8 {
+ var ptr: [*]const u8 = undefined;
+ return ptr[0..req.uws_req_get_header(req, name.ptr, name.len, &ptr)];
+ }
+ pub fn query(req: *Request, name: []const u8) []const u8 {
+ var ptr: [*]const u8 = undefined;
+ return ptr[0..req.uws_req_get_query(req, name.ptr, name.len, &ptr)];
+ }
+ pub fn parameter(req: *Request, index: u16) []const u8 {
+ var ptr: [*]const u8 = undefined;
+ return ptr[0..req.uws_req_get_parameter(@intCast(c_ushort, index), &ptr)];
+ }
+ extern fn uws_req_is_ancient(res: *Request) bool;
+ extern fn uws_req_get_yield(res: *Request) bool;
+ extern fn uws_req_set_field(res: *Request, yield: bool) void;
+ extern fn uws_req_get_url(res: *Request, dest: *[*]const u8) usize;
+ extern fn uws_req_get_method(res: *Request, dest: *[*]const u8) usize;
+ extern fn uws_req_get_header(res: *Request, lower_case_header: *[*]const u8, lower_case_header_length: usize, dest: *[*]const u8) usize;
+ extern fn uws_req_get_query(res: *Request, key: [*c]const u8, key_length: usize, dest: *[*]const u8) usize;
+ extern fn uws_req_get_parameter(res: *Request, index: c_ushort, dest: *[*]const u8) usize;
+};
+
+const listen_socket_t = opaque {};
+extern fn us_listen_socket_close(ssl: c_int, ls: *listen_socket_t) void;
+
+pub fn NewApp(comptime ssl: bool) type {
+ return opaque {
+ const ssl_flag = @as(c_int, @boolToInt(ssl));
+ const ThisApp = @This();
+
+ pub fn create(opts: us_socket_context_options_t) *ThisApp {
+ return @ptrCast(*ThisApp, uws_create_app(ssl_flag, opts));
+ }
+ pub fn destroy(app: *ThisApp) void {
+ return uws_app_destroy(ssl_flag, @ptrCast(*uws_app_s, app));
+ }
+
+ fn RouteHandler(comptime UserDataType: type, comptime handler: fn (UserDataType, *Request, *Response) void) type {
+ return struct {
+ pub fn handle(res: *uws_res, req: *Request, user_data: ?*anyopaque) callconv(.C) void {
+ if (comptime UserDataType == void) {
+ return @call(
+ .{ .modifier = .always_inline },
+ handler,
+ .{
+ void{},
+ req,
+ @ptrCast(*Response, @alignCast(@alignOf(*Response), res)),
+ },
+ );
+ } else {
+ return @call(
+ .{ .modifier = .always_inline },
+ handler,
+ .{
+ @ptrCast(UserDataType, @alignCast(@alignOf(UserDataType), user_data.?)),
+ req,
+ @ptrCast(*Response, @alignCast(@alignOf(*Response), res)),
+ },
+ );
+ }
+ }
+ };
+ }
+
+ pub const ListenSocket = opaque {
+ pub inline fn close(this: *ListenSocket) void {
+ return us_listen_socket_close(ssl_flag, @ptrCast(*listen_socket_t, this));
+ }
+ };
+
+ pub fn get(
+ app: *ThisApp,
+ pattern: [:0]const u8,
+ comptime UserDataType: type,
+ user_data: UserDataType,
+ comptime handler: (fn (UserDataType, *Request, *Response) void),
+ ) void {
+ uws_app_get(ssl_flag, @ptrCast(*uws_app_t, app), pattern, RouteHandler(UserDataType, handler).handle, user_data);
+ }
+ pub fn post(
+ app: *ThisApp,
+ pattern: [:0]const u8,
+ comptime UserDataType: type,
+ user_data: UserDataType,
+ comptime handler: (fn (UserDataType, *Request, *Response) void),
+ ) void {
+ uws_app_post(ssl_flag, @ptrCast(*uws_app_t, app), pattern, RouteHandler(UserDataType, handler).handle, user_data);
+ }
+ pub fn options(
+ app: *ThisApp,
+ pattern: [:0]const u8,
+ comptime UserDataType: type,
+ user_data: UserDataType,
+ comptime handler: (fn (UserDataType, *Request, *Response) void),
+ ) void {
+ uws_app_options(ssl_flag, @ptrCast(*uws_app_t, app), pattern, RouteHandler(UserDataType, handler).handle, user_data);
+ }
+ pub fn delete(
+ app: *ThisApp,
+ pattern: [:0]const u8,
+ comptime UserDataType: type,
+ user_data: UserDataType,
+ comptime handler: (fn (UserDataType, *Request, *Response) void),
+ ) void {
+ uws_app_delete(ssl_flag, @ptrCast(*uws_app_t, app), pattern, RouteHandler(UserDataType, handler).handle, user_data);
+ }
+ pub fn patch(
+ app: *ThisApp,
+ pattern: [:0]const u8,
+ comptime UserDataType: type,
+ user_data: UserDataType,
+ comptime handler: (fn (UserDataType, *Request, *Response) void),
+ ) void {
+ uws_app_patch(ssl_flag, @ptrCast(*uws_app_t, app), pattern, RouteHandler(UserDataType, handler).handle, user_data);
+ }
+ pub fn put(
+ app: *ThisApp,
+ pattern: [:0]const u8,
+ comptime UserDataType: type,
+ user_data: UserDataType,
+ comptime handler: (fn (UserDataType, *Request, *Response) void),
+ ) void {
+ uws_app_put(ssl_flag, @ptrCast(*uws_app_t, app), pattern, RouteHandler(UserDataType, handler).handle, user_data);
+ }
+ pub fn head(
+ app: *ThisApp,
+ pattern: [:0]const u8,
+ comptime UserDataType: type,
+ user_data: UserDataType,
+ comptime handler: (fn (UserDataType, *Request, *Response) void),
+ ) void {
+ uws_app_head(ssl_flag, @ptrCast(*uws_app_t, app), pattern, RouteHandler(UserDataType, handler).handle, user_data);
+ }
+ pub fn connect(
+ app: *ThisApp,
+ pattern: [:0]const u8,
+ comptime UserDataType: type,
+ user_data: UserDataType,
+ comptime handler: (fn (UserDataType, *Request, *Response) void),
+ ) void {
+ uws_app_connect(ssl_flag, @ptrCast(*uws_app_t, app), pattern, RouteHandler(UserDataType, handler).handle, user_data);
+ }
+ pub fn trace(
+ app: *ThisApp,
+ pattern: [:0]const u8,
+ comptime UserDataType: type,
+ user_data: UserDataType,
+ comptime handler: (fn (UserDataType, *Request, *Response) void),
+ ) void {
+ uws_app_trace(ssl_flag, @ptrCast(*uws_app_t, app), pattern, RouteHandler(UserDataType, handler).handle, user_data);
+ }
+ pub fn any(
+ app: *ThisApp,
+ pattern: [:0]const u8,
+ comptime UserDataType: type,
+ user_data: UserDataType,
+ comptime handler: (fn (UserDataType, *Request, *Response) void),
+ ) void {
+ uws_app_any(ssl_flag, @ptrCast(*uws_app_t, app), pattern, RouteHandler(UserDataType, handler).handle, user_data);
+ }
+ pub fn run(app: *ThisApp) void {
+ return uws_app_run(ssl_flag, @ptrCast(*uws_app_t, app));
+ }
+ pub fn listen(
+ app: *ThisApp,
+ port: c_int,
+ comptime UserData: type,
+ user_data: UserData,
+ comptime handler: fn (UserData, ?*ListenSocket, uws_app_listen_config_t) void,
+ ) void {
+ const Wrapper = struct {
+ pub fn handle(socket: ?*listen_socket_t, conf: uws_app_listen_config_t, data: ?*anyopaque) callconv(.C) void {
+ if (comptime UserData == void) {
+ @call(.{ .modifier = .always_inline }, handler, .{ void{}, @ptrCast(?*ListenSocket, socket), conf });
+ } else {
+ @call(.{ .modifier = .always_inline }, handler, .{
+ @ptrCast(UserData, @alignCast(@alignOf(UserData), data.?)),
+ @ptrCast(?*ListenSocket, socket),
+ conf,
+ });
+ }
+ }
+ };
+ return uws_app_listen(ssl_flag, @ptrCast(*uws_app_t, app), port, Wrapper.handle, user_data);
+ }
+
+ pub fn listenWithConfig(
+ app: *ThisApp,
+ comptime UserData: type,
+ user_data: UserData,
+ comptime handler: fn (UserData, ?*ListenSocket, uws_app_listen_config_t) void,
+ config: uws_app_listen_config_t,
+ ) void {
+ const Wrapper = struct {
+ pub fn handle(socket: ?*listen_socket_t, conf: uws_app_listen_config_t, data: ?*anyopaque) callconv(.C) void {
+ if (comptime UserData == void) {
+ @call(.{ .modifier = .always_inline }, handler, .{ void{}, @ptrCast(?*ListenSocket, socket), conf });
+ } else {
+ @call(.{ .modifier = .always_inline }, handler, .{
+ @ptrCast(UserData, @alignCast(@alignOf(UserData), data.?)),
+ @ptrCast(?*ListenSocket, socket),
+ conf,
+ });
+ }
+ }
+ };
+ return uws_app_listen_with_config(ssl_flag, @ptrCast(*uws_app_t, app), config, Wrapper.handle, user_data);
+ }
+ pub fn constructorFailed(app: *ThisApp) bool {
+ return uws_constructor_failed(ssl_flag, app);
+ }
+ pub fn num_subscribers(app: *ThisApp, topic: [:0]const u8) c_uint {
+ return uws_num_subscribers(ssl_flag, @ptrCast(*uws_app_t, app), topic);
+ }
+ pub fn publish(app: *ThisApp, topic: []const u8, message: []const u8, opcode: uws_opcode_t, compress: bool) bool {
+ return uws_publish(ssl_flag, @ptrCast(*uws_app_t, app), topic.ptr, topic.len, message.ptr, message.len, opcode, compress);
+ }
+ pub fn getNativeHandle(app: *ThisApp) ?*anyopaque {
+ return uws_get_native_handle(ssl_flag, app);
+ }
+ pub fn removeServerName(app: *ThisApp, hostname_pattern: [:0]const u8) void {
+ return uws_remove_server_name(ssl_flag, @ptrCast(*uws_app_t, app), hostname_pattern);
+ }
+ pub fn addServerName(app: *ThisApp, hostname_pattern: [:0]const u8) void {
+ return uws_add_server_name(ssl_flag, @ptrCast(*uws_app_t, app), hostname_pattern);
+ }
+ pub fn addServerNameWithOptions(app: *ThisApp, hostname_pattern: [:0]const u8, opts: us_socket_context_options_t) void {
+ return uws_add_server_name_with_options(ssl_flag, @ptrCast(*uws_app_t, app), hostname_pattern, opts);
+ }
+ pub fn missingServerName(app: *ThisApp, handler: uws_missing_server_handler, user_data: ?*anyopaque) void {
+ return uws_missing_server_name(ssl_flag, @ptrCast(*uws_app_t, app), handler, user_data);
+ }
+ pub fn filter(app: *ThisApp, handler: uws_filter_handler, user_data: ?*anyopaque) void {
+ return uws_filter(ssl_flag, @ptrCast(*uws_app_t, app), handler, user_data);
+ }
+ pub fn ws(app: *ThisApp, pattern: [:0]const u8, behavior: uws_socket_behavior_t) void {
+ return uws_ws(ssl_flag, @ptrCast(*uws_app_t, app), pattern, behavior);
+ }
+
+ pub const Response = opaque {
+ inline fn castRes(res: *uws_res) *Response {
+ return @ptrCast(*Response, @alignCast(@alignOf(*Response), res));
+ }
+
+ pub inline fn downcast(res: *Response) *uws_res {
+ return @ptrCast(*uws_res, @alignCast(@alignOf(*uws_res), res));
+ }
+
+ pub fn end(res: *Response, data: []const u8, close_connection: bool) void {
+ uws_res_end(ssl_flag, res.downcast(), data.ptr, data.len, close_connection);
+ }
+ pub fn pause(res: *Response) void {
+ uws_res_pause(ssl_flag, res.downcast());
+ }
+ pub fn @"resume"(res: *Response) void {
+ uws_res_resume(ssl_flag, res.downcast());
+ }
+ pub fn writeContinue(res: *Response) void {
+ uws_res_write_continue(ssl_flag, res.downcast());
+ }
+ pub fn writeStatus(res: *Response, status: []const u8) void {
+ uws_res_write_status(ssl_flag, res.downcast(), status.ptr, status.len);
+ }
+ pub fn writeHeader(res: *Response, key: []const u8, value: []const u8) void {
+ uws_res_write_header(ssl_flag, res.downcast(), key.ptr, key.len, value.ptr, value.len);
+ }
+ pub fn writeHeaderInt(res: *Response, key: []const u8, value: u64) void {
+ uws_res_write_header(ssl_flag, res.downcast(), key.ptr, key.len, value);
+ }
+ pub fn endWithoutBody(res: *Response) void {
+ uws_res_end_without_body(ssl_flag, res.downcast());
+ }
+ pub fn write(res: *Response, data: []const u8) bool {
+ return uws_res_write(ssl_flag, res.downcast(), data.ptr, data.len);
+ }
+ pub fn getWriteOffset(res: *Response) uintmax_t {
+ return uws_res_get_write_offset(ssl_flag, res.downcast());
+ }
+ pub fn hasResponded(res: *Response) bool {
+ return uws_res_has_responded(ssl_flag, res.downcast());
+ }
+ pub fn onWritable(
+ res: *Response,
+ comptime UserDataType: type,
+ comptime handler: fn (*Response, uintmax_t, UserDataType) callconv(.C) bool,
+ user_data: UserDataType,
+ ) void {
+ const Wrapper = struct {
+ pub fn handle(this: *uws_res, amount: uintmax_t, data: ?*anyopaque) callconv(.C) void {
+ if (comptime UserDataType == void) {
+ @call(.{ .modifier = .always_inline }, handler, .{ void{}, castRes(this), amount });
+ } else {
+ @call(.{ .modifier = .always_inline }, handler, .{ @ptrCast(UserDataType, @alignCast(@alignOf(UserDataType), data.?)), castRes(this), amount });
+ }
+ }
+ };
+ uws_res_on_writable(ssl_flag, res.downcast(), Wrapper.handle, user_data);
+ }
+ pub fn onAborted(res: *Response, comptime UserDataType: type, comptime handler: fn (UserDataType, *Response) void, opcional_data: UserDataType) void {
+ const Wrapper = struct {
+ pub fn handle(this: *uws_res, user_data: ?*anyopaque) callconv(.C) void {
+ if (comptime UserDataType == void) {
+ @call(.{ .modifier = .always_inline }, handler, .{ void{}, castRes(this), void{} });
+ } else {
+ @call(.{ .modifier = .always_inline }, handler, .{ @ptrCast(UserDataType, @alignCast(@alignOf(UserDataType), user_data.?)), castRes(this) });
+ }
+ }
+ };
+ uws_res_on_aborted(ssl_flag, res.downcast(), Wrapper.handle, opcional_data);
+ }
+
+ pub fn onData(
+ res: *Response,
+ comptime UserDataType: type,
+ comptime handler: fn (*Response, chunk: []const u8, last: bool, UserDataType) void,
+ opcional_data: UserDataType,
+ ) void {
+ const Wrapper = struct {
+ pub fn handle(this: *uws_res, chunk_ptr: [*c]const u8, len: usize, last: bool, user_data: ?*anyopaque) callconv(.C) void {
+ if (comptime UserDataType == void) {
+ @call(.{ .modifier = .always_inline }, handler, .{
+ void{},
+ castRes(this),
+ chunk_ptr[0..len],
+ last,
+ });
+ } else {
+ @call(.{ .modifier = .always_inline }, handler, .{
+ @ptrCast(UserDataType, @alignCast(@alignOf(UserDataType), user_data.?)),
+ castRes(this),
+ chunk_ptr[0..len],
+ last,
+ });
+ }
+ }
+ };
+
+ uws_res_on_data(ssl_flag, res.downcast(), Wrapper.handle, opcional_data);
+ }
+ };
+ };
+}
+
+extern fn uws_create_app(ssl: c_int, options: us_socket_context_options_t) *uws_app_t;
+extern fn uws_app_destroy(ssl: c_int, app: *uws_app_t) void;
+extern fn uws_app_get(ssl: c_int, app: *uws_app_t, pattern: [*c]const u8, handler: uws_method_handler, user_data: ?*anyopaque) void;
+extern fn uws_app_post(ssl: c_int, app: *uws_app_t, pattern: [*c]const u8, handler: uws_method_handler, user_data: ?*anyopaque) void;
+extern fn uws_app_options(ssl: c_int, app: *uws_app_t, pattern: [*c]const u8, handler: uws_method_handler, user_data: ?*anyopaque) void;
+extern fn uws_app_delete(ssl: c_int, app: *uws_app_t, pattern: [*c]const u8, handler: uws_method_handler, user_data: ?*anyopaque) void;
+extern fn uws_app_patch(ssl: c_int, app: *uws_app_t, pattern: [*c]const u8, handler: uws_method_handler, user_data: ?*anyopaque) void;
+extern fn uws_app_put(ssl: c_int, app: *uws_app_t, pattern: [*c]const u8, handler: uws_method_handler, user_data: ?*anyopaque) void;
+extern fn uws_app_head(ssl: c_int, app: *uws_app_t, pattern: [*c]const u8, handler: uws_method_handler, user_data: ?*anyopaque) void;
+extern fn uws_app_connect(ssl: c_int, app: *uws_app_t, pattern: [*c]const u8, handler: uws_method_handler, user_data: ?*anyopaque) void;
+extern fn uws_app_trace(ssl: c_int, app: *uws_app_t, pattern: [*c]const u8, handler: uws_method_handler, user_data: ?*anyopaque) void;
+extern fn uws_app_any(ssl: c_int, app: *uws_app_t, pattern: [*c]const u8, handler: uws_method_handler, user_data: ?*anyopaque) void;
+extern fn uws_app_run(ssl: c_int, *uws_app_t) void;
+extern fn uws_app_listen(ssl: c_int, app: *uws_app_t, port: c_int, handler: uws_listen_handler, user_data: ?*anyopaque) void;
+extern fn uws_app_listen_with_config(ssl: c_int, app: *uws_app_t, config: uws_app_listen_config_t, handler: uws_listen_handler, user_data: ?*anyopaque) void;
+extern fn uws_constructor_failed(ssl: c_int, app: *uws_app_t) bool;
+extern fn uws_num_subscribers(ssl: c_int, app: *uws_app_t, topic: [*c]const u8) c_uint;
+extern fn uws_publish(ssl: c_int, app: *uws_app_t, topic: [*c]const u8, topic_length: usize, message: [*c]const u8, message_length: usize, opcode: uws_opcode_t, compress: bool) bool;
+extern fn uws_get_native_handle(ssl: c_int, app: *uws_app_t) ?*anyopaque;
+extern fn uws_remove_server_name(ssl: c_int, app: *uws_app_t, hostname_pattern: [*c]const u8) void;
+extern fn uws_add_server_name(ssl: c_int, app: *uws_app_t, hostname_pattern: [*c]const u8) void;
+extern fn uws_add_server_name_with_options(ssl: c_int, app: *uws_app_t, hostname_pattern: [*c]const u8, options: us_socket_context_options_t) void;
+extern fn uws_missing_server_name(ssl: c_int, app: *uws_app_t, handler: uws_missing_server_handler, user_data: ?*anyopaque) void;
+extern fn uws_filter(ssl: c_int, app: *uws_app_t, handler: uws_filter_handler, user_data: ?*anyopaque) void;
+extern fn uws_ws(ssl: c_int, app: *uws_app_t, pattern: [*c]const u8, behavior: uws_socket_behavior_t) void;
+
+extern fn uws_ws_get_user_data(ssl: c_int, ws: ?*uws_websocket_t) ?*anyopaque;
+extern fn uws_ws_close(ssl: c_int, ws: ?*uws_websocket_t) void;
+extern fn uws_ws_send(ssl: c_int, ws: ?*uws_websocket_t, message: [*c]const u8, length: usize, opcode: uws_opcode_t) uws_sendstatus_t;
+extern fn uws_ws_send_with_options(ssl: c_int, ws: ?*uws_websocket_t, message: [*c]const u8, length: usize, opcode: uws_opcode_t, compress: bool, fin: bool) uws_sendstatus_t;
+extern fn uws_ws_send_fragment(ssl: c_int, ws: ?*uws_websocket_t, message: [*c]const u8, length: usize, compress: bool) uws_sendstatus_t;
+extern fn uws_ws_send_first_fragment(ssl: c_int, ws: ?*uws_websocket_t, message: [*c]const u8, length: usize, compress: bool) uws_sendstatus_t;
+extern fn uws_ws_send_first_fragment_with_opcode(ssl: c_int, ws: ?*uws_websocket_t, message: [*c]const u8, length: usize, opcode: uws_opcode_t, compress: bool) uws_sendstatus_t;
+extern fn uws_ws_send_last_fragment(ssl: c_int, ws: ?*uws_websocket_t, message: [*c]const u8, length: usize, compress: bool) uws_sendstatus_t;
+extern fn uws_ws_end(ssl: c_int, ws: ?*uws_websocket_t, code: c_int, message: [*c]const u8, length: usize) void;
+extern fn uws_ws_cork(ssl: c_int, ws: ?*uws_websocket_t, handler: ?fn (?*anyopaque) callconv(.C) void, user_data: ?*anyopaque) void;
+extern fn uws_ws_subscribe(ssl: c_int, ws: ?*uws_websocket_t, topic: [*c]const u8, length: usize) bool;
+extern fn uws_ws_unsubscribe(ssl: c_int, ws: ?*uws_websocket_t, topic: [*c]const u8, length: usize) bool;
+extern fn uws_ws_is_subscribed(ssl: c_int, ws: ?*uws_websocket_t, topic: [*c]const u8, length: usize) bool;
+extern fn uws_ws_iterate_topics(ssl: c_int, ws: ?*uws_websocket_t, callback: ?fn ([*c]const u8, usize, ?*anyopaque) callconv(.C) void, user_data: ?*anyopaque) void;
+extern fn uws_ws_publish(ssl: c_int, ws: ?*uws_websocket_t, topic: [*c]const u8, topic_length: usize, message: [*c]const u8, message_length: usize) bool;
+extern fn uws_ws_publish_with_options(ssl: c_int, ws: ?*uws_websocket_t, topic: [*c]const u8, topic_length: usize, message: [*c]const u8, message_length: usize, opcode: uws_opcode_t, compress: bool) bool;
+extern fn uws_ws_get_buffered_amount(ssl: c_int, ws: ?*uws_websocket_t) c_uint;
+extern fn uws_ws_get_remote_address(ssl: c_int, ws: ?*uws_websocket_t, dest: [*c][*c]const u8) usize;
+extern fn uws_ws_get_remote_address_as_text(ssl: c_int, ws: ?*uws_websocket_t, dest: [*c][*c]const u8) usize;
+const uws_res = opaque {};
+extern fn uws_res_end(ssl: c_int, res: *uws_res, data: [*c]const u8, length: usize, close_connection: bool) void;
+extern fn uws_res_pause(ssl: c_int, res: *uws_res) void;
+extern fn uws_res_resume(ssl: c_int, res: *uws_res) void;
+extern fn uws_res_write_continue(ssl: c_int, res: *uws_res) void;
+extern fn uws_res_write_status(ssl: c_int, res: *uws_res, status: [*c]const u8, length: usize) void;
+extern fn uws_res_write_header(ssl: c_int, res: *uws_res, key: [*c]const u8, key_length: usize, value: [*c]const u8, value_length: usize) void;
+extern fn uws_res_write_header_int(ssl: c_int, res: *uws_res, key: [*c]const u8, key_length: usize, value: u64) void;
+extern fn uws_res_end_without_body(ssl: c_int, res: *uws_res) void;
+extern fn uws_res_write(ssl: c_int, res: *uws_res, data: [*c]const u8, length: usize) bool;
+extern fn uws_res_get_write_offset(ssl: c_int, res: *uws_res) uintmax_t;
+extern fn uws_res_has_responded(ssl: c_int, res: *uws_res) bool;
+extern fn uws_res_on_writable(ssl: c_int, res: *uws_res, handler: ?fn (*uws_res, uintmax_t, ?*anyopaque) callconv(.C) bool, user_data: ?*anyopaque) void;
+extern fn uws_res_on_aborted(ssl: c_int, res: *uws_res, handler: ?fn (*uws_res, ?*anyopaque) callconv(.C) void, opcional_data: ?*anyopaque) void;
+extern fn uws_res_on_data(
+ ssl: c_int,
+ res: *uws_res,
+ handler: ?fn (*uws_res, [*c]const u8, usize, bool, ?*anyopaque) callconv(.C) void,
+ opcional_data: ?*anyopaque,
+) void;
+extern fn uws_res_upgrade(
+ ssl: c_int,
+ res: *uws_res,
+ data: ?*anyopaque,
+ sec_web_socket_key: [*c]const u8,
+ sec_web_socket_key_length: usize,
+ sec_web_socket_protocol: [*c]const u8,
+ sec_web_socket_protocol_length: usize,
+ sec_web_socket_extensions: [*c]const u8,
+ sec_web_socket_extensions_length: usize,
+ ws: ?*uws_socket_context_t,
+) void;
+
+pub const LIBUS_RECV_BUFFER_LENGTH = @import("std").zig.c_translation.promoteIntLiteral(c_int, 524288, .decimal);
+pub const LIBUS_TIMEOUT_GRANULARITY = @as(c_int, 4);
+pub const LIBUS_RECV_BUFFER_PADDING = @as(c_int, 32);
+pub const LIBUS_EXT_ALIGNMENT = @as(c_int, 16);
+pub const LIBUS_SOCKET_DESCRIPTOR = c_int;
+
+pub const _COMPRESSOR_MASK: c_int = 255;
+pub const _DECOMPRESSOR_MASK: c_int = 3840;
+pub const DISABLED: c_int = 0;
+pub const SHARED_COMPRESSOR: c_int = 1;
+pub const SHARED_DECOMPRESSOR: c_int = 256;
+pub const DEDICATED_DECOMPRESSOR_32KB: c_int = 3840;
+pub const DEDICATED_DECOMPRESSOR_16KB: c_int = 3584;
+pub const DEDICATED_DECOMPRESSOR_8KB: c_int = 3328;
+pub const DEDICATED_DECOMPRESSOR_4KB: c_int = 3072;
+pub const DEDICATED_DECOMPRESSOR_2KB: c_int = 2816;
+pub const DEDICATED_DECOMPRESSOR_1KB: c_int = 2560;
+pub const DEDICATED_DECOMPRESSOR_512B: c_int = 2304;
+pub const DEDICATED_DECOMPRESSOR: c_int = 3840;
+pub const DEDICATED_COMPRESSOR_3KB: c_int = 145;
+pub const DEDICATED_COMPRESSOR_4KB: c_int = 146;
+pub const DEDICATED_COMPRESSOR_8KB: c_int = 163;
+pub const DEDICATED_COMPRESSOR_16KB: c_int = 180;
+pub const DEDICATED_COMPRESSOR_32KB: c_int = 197;
+pub const DEDICATED_COMPRESSOR_64KB: c_int = 214;
+pub const DEDICATED_COMPRESSOR_128KB: c_int = 231;
+pub const DEDICATED_COMPRESSOR_256KB: c_int = 248;
+pub const DEDICATED_COMPRESSOR: c_int = 248;
+pub const uws_compress_options_t = c_uint;
+pub const CONTINUATION: c_int = 0;
+pub const TEXT: c_int = 1;
+pub const BINARY: c_int = 2;
+pub const CLOSE: c_int = 8;
+pub const PING: c_int = 9;
+pub const PONG: c_int = 10;
+pub const uws_opcode_t = c_uint;
+pub const BACKPRESSURE: c_int = 0;
+pub const SUCCESS: c_int = 1;
+pub const DROPPED: c_int = 2;
+pub const uws_sendstatus_t = c_uint;
+pub const uws_app_listen_config_t = extern struct {
+ port: c_int,
+ host: [*c]const u8 = null,
+ options: c_int,
+};
generated by cgit v1.2.3 (git 2.46.0) at 2025-10-23 02:57:13 +0000