opal-up 0.0.2 → 0.0.4

data/ext/up_ext/bsd.h

@@ -0,0 +1,109 @@
+/*
+ * Authored by Alex Hultman, 2018-2019.
+ * 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 BSD_H
+#define BSD_H
+
+// top-most wrapper of bsd-like syscalls
+
+// holds everything you need from the bsd/winsock interfaces, only included by internal libusockets.h
+// here everything about the syscalls are inline-wrapped and included
+
+#include "libusockets.h"
+
+#ifdef _WIN32
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#pragma comment(lib, "ws2_32.lib")
+#define SETSOCKOPT_PTR_TYPE const char *
+#define LIBUS_SOCKET_ERROR INVALID_SOCKET
+#else
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+/* For socklen_t */
+#include <sys/socket.h>
+#define SETSOCKOPT_PTR_TYPE int *
+#define LIBUS_SOCKET_ERROR -1
+#endif
+
+#define LIBUS_UDP_MAX_SIZE (64 * 1024)
+#define LIBUS_UDP_MAX_NUM 1024
+
+struct bsd_addr_t {
+    struct sockaddr_storage mem;
+    socklen_t len;
+    char *ip;
+    int ip_length;
+    int port;
+};
+
+int bsd_sendmmsg(LIBUS_SOCKET_DESCRIPTOR fd, void *msgvec, unsigned int vlen, int flags);
+int bsd_recvmmsg(LIBUS_SOCKET_DESCRIPTOR fd, void *msgvec, unsigned int vlen, int flags, void *timeout);
+int bsd_udp_packet_buffer_payload_length(void *msgvec, int index);
+char *bsd_udp_packet_buffer_payload(void *msgvec, int index);
+char *bsd_udp_packet_buffer_peer(void *msgvec, int index);
+int bsd_udp_packet_buffer_local_ip(void *msgvec, int index, char *ip);
+int bsd_udp_packet_buffer_ecn(void *msgvec, int index);
+void *bsd_create_udp_packet_buffer();
+void bsd_udp_buffer_set_packet_payload(struct us_udp_packet_buffer_t *send_buf, int index, int offset, void *payload, int length, void *peer_addr);
+
+LIBUS_SOCKET_DESCRIPTOR apple_no_sigpipe(LIBUS_SOCKET_DESCRIPTOR fd);
+LIBUS_SOCKET_DESCRIPTOR bsd_set_nonblocking(LIBUS_SOCKET_DESCRIPTOR fd);
+void bsd_socket_nodelay(LIBUS_SOCKET_DESCRIPTOR fd, int enabled);
+void bsd_socket_flush(LIBUS_SOCKET_DESCRIPTOR fd);
+LIBUS_SOCKET_DESCRIPTOR bsd_create_socket(int domain, int type, int protocol);
+
+void bsd_close_socket(LIBUS_SOCKET_DESCRIPTOR fd);
+void bsd_shutdown_socket(LIBUS_SOCKET_DESCRIPTOR fd);
+void bsd_shutdown_socket_read(LIBUS_SOCKET_DESCRIPTOR fd);
+
+void internal_finalize_bsd_addr(struct bsd_addr_t *addr);
+
+int bsd_local_addr(LIBUS_SOCKET_DESCRIPTOR fd, struct bsd_addr_t *addr);
+int bsd_remote_addr(LIBUS_SOCKET_DESCRIPTOR fd, struct bsd_addr_t *addr);
+
+char *bsd_addr_get_ip(struct bsd_addr_t *addr);
+int bsd_addr_get_ip_length(struct bsd_addr_t *addr);
+
+int bsd_addr_get_port(struct bsd_addr_t *addr);
+
+// called by dispatch_ready_poll
+LIBUS_SOCKET_DESCRIPTOR bsd_accept_socket(LIBUS_SOCKET_DESCRIPTOR fd, struct bsd_addr_t *addr);
+
+int bsd_recv(LIBUS_SOCKET_DESCRIPTOR fd, void *buf, int length, int flags);
+int bsd_send(LIBUS_SOCKET_DESCRIPTOR fd, const char *buf, int length, int msg_more);
+int bsd_write2(LIBUS_SOCKET_DESCRIPTOR fd, const char *header, int header_length, const char *payload, int payload_length);
+int bsd_would_block();
+
+// return LIBUS_SOCKET_ERROR or the fd that represents listen socket
+// listen both on ipv6 and ipv4
+LIBUS_SOCKET_DESCRIPTOR bsd_create_listen_socket(const char *host, int port, int options);
+
+LIBUS_SOCKET_DESCRIPTOR bsd_create_listen_socket_unix(const char *path, int options);
+
+/* Creates an UDP socket bound to the hostname and port */
+LIBUS_SOCKET_DESCRIPTOR bsd_create_udp_socket(const char *host, int port);
+
+LIBUS_SOCKET_DESCRIPTOR bsd_create_connect_socket(const char *host, int port, const char *source_host, int options);
+
+LIBUS_SOCKET_DESCRIPTOR bsd_create_connect_socket_unix(const char *server_path, int options);
+
+#endif // BSD_H

data/ext/up_ext/context.c

@@ -0,0 +1,524 @@
+/*
+ * Authored by Alex Hultman, 2018-2019.
+ * 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>
+#include <string.h>
+
+int default_is_low_prio_handler(struct us_socket_t *s) {
+    return 0;
+}
+
+/* Shared with SSL */
+
+unsigned short us_socket_context_timestamp(int ssl, struct us_socket_context_t *context) {
+    return context->timestamp;
+}
+
+void us_listen_socket_close(int ssl, struct us_listen_socket_t *ls) {
+    /* us_listen_socket_t extends us_socket_t so we close in similar ways */
+    if (!us_socket_is_closed(0, &ls->s)) {
+        us_internal_socket_context_unlink_listen_socket(ls->s.context, ls);
+        us_poll_stop((struct us_poll_t *) &ls->s, ls->s.context->loop);
+        bsd_close_socket(us_poll_fd((struct us_poll_t *) &ls->s));
+
+        /* Link this socket to the close-list and let it be deleted after this iteration */
+        ls->s.next = ls->s.context->loop->data.closed_head;
+        ls->s.context->loop->data.closed_head = &ls->s;
+
+        /* Any socket with prev = context is marked as closed */
+        ls->s.prev = (struct us_socket_t *) ls->s.context;
+    }
+
+    /* We cannot immediately free a listen socket as we can be inside an accept loop */
+}
+
+void us_socket_context_close(int ssl, struct us_socket_context_t *context) {
+    /* Begin by closing all listen sockets */
+    struct us_listen_socket_t *ls = context->head_listen_sockets;
+    while (ls) {
+        struct us_listen_socket_t *nextLS = (struct us_listen_socket_t *) ls->s.next;
+        us_listen_socket_close(ssl, ls);
+        ls = nextLS;
+    }
+
+    /* Then close all regular sockets */
+    struct us_socket_t *s = context->head_sockets;
+    while (s) {
+        struct us_socket_t *nextS = s->next;
+        us_socket_close(ssl, s, 0, 0);
+        s = nextS;
+    }
+}
+
+void us_internal_socket_context_unlink_listen_socket(struct us_socket_context_t *context, struct us_listen_socket_t *ls) {
+    /* We have to properly update the iterator used to sweep sockets for timeouts */
+    if (ls == (struct us_listen_socket_t *) context->iterator) {
+        context->iterator = ls->s.next;
+    }
+
+    if (ls->s.prev == ls->s.next) {
+        context->head_listen_sockets = 0;
+    } else {
+        if (ls->s.prev) {
+            ls->s.prev->next = ls->s.next;
+        } else {
+            context->head_listen_sockets = (struct us_listen_socket_t *) ls->s.next;
+        }
+        if (ls->s.next) {
+            ls->s.next->prev = ls->s.prev;
+        }
+    }
+}
+
+void us_internal_socket_context_unlink_socket(struct us_socket_context_t *context, struct us_socket_t *s) {
+    /* We have to properly update the iterator used to sweep sockets for timeouts */
+    if (s == context->iterator) {
+        context->iterator = s->next;
+    }
+
+    if (s->prev == s->next) {
+        context->head_sockets = 0;
+    } else {
+        if (s->prev) {
+            s->prev->next = s->next;
+        } else {
+            context->head_sockets = s->next;
+        }
+        if (s->next) {
+            s->next->prev = s->prev;
+        }
+    }
+}
+
+/* We always add in the top, so we don't modify any s.next */
+void us_internal_socket_context_link_listen_socket(struct us_socket_context_t *context, struct us_listen_socket_t *ls) {
+    ls->s.context = context;
+    ls->s.next = (struct us_socket_t *) context->head_listen_sockets;
+    ls->s.prev = 0;
+    if (context->head_listen_sockets) {
+        context->head_listen_sockets->s.prev = &ls->s;
+    }
+    context->head_listen_sockets = ls;
+}
+
+/* We always add in the top, so we don't modify any s.next */
+void us_internal_socket_context_link_socket(struct us_socket_context_t *context, struct us_socket_t *s) {
+    s->context = context;
+    s->next = context->head_sockets;
+    s->prev = 0;
+    if (context->head_sockets) {
+        context->head_sockets->prev = s;
+    }
+    context->head_sockets = s;
+}
+
+struct us_loop_t *us_socket_context_loop(int ssl, struct us_socket_context_t *context) {
+    return context->loop;
+}
+
+/* Not shared with SSL */
+
+/* Lookup userdata by server name pattern */
+void *us_socket_context_find_server_name_userdata(int ssl, struct us_socket_context_t *context, const char *hostname_pattern) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        return us_internal_ssl_socket_context_find_server_name_userdata((struct us_internal_ssl_socket_context_t *) context, hostname_pattern);
+    }
+#endif
+    return NULL;
+}
+
+/* Get userdata attached to this SNI-routed socket, or nullptr if default */
+void *us_socket_server_name_userdata(int ssl, struct us_socket_t *s) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        return us_internal_ssl_socket_get_sni_userdata((struct us_internal_ssl_socket_t *) s);
+    }
+#endif
+    return NULL;
+}
+
+/* Add SNI context */
+void us_socket_context_add_server_name(int ssl, struct us_socket_context_t *context, const char *hostname_pattern, struct us_socket_context_options_t options, void *user) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        us_internal_ssl_socket_context_add_server_name((struct us_internal_ssl_socket_context_t *) context, hostname_pattern, options, user);
+    }
+#endif
+}
+
+/* Remove SNI context */
+void us_socket_context_remove_server_name(int ssl, struct us_socket_context_t *context, const char *hostname_pattern) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        us_internal_ssl_socket_context_remove_server_name((struct us_internal_ssl_socket_context_t *) context, hostname_pattern);
+    }
+#endif
+}
+
+/* I don't like this one - maybe rename it to on_missing_server_name? */
+
+/* Called when SNI matching fails - not if a match could be made.
+ * You may modify the context by adding/removing names in this callback.
+ * If the correct name is added immediately in the callback, it will be used */
+void us_socket_context_on_server_name(int ssl, struct us_socket_context_t *context, void (*cb)(struct us_socket_context_t *, const char *hostname)) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        us_internal_ssl_socket_context_on_server_name((struct us_internal_ssl_socket_context_t *) context, (void (*)(struct us_internal_ssl_socket_context_t *, const char *hostname)) cb);
+    }
+#endif
+}
+
+/* Todo: get native context from SNI pattern */
+
+void *us_socket_context_get_native_handle(int ssl, struct us_socket_context_t *context) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        return us_internal_ssl_socket_context_get_native_handle((struct us_internal_ssl_socket_context_t *) context);
+    }
+#endif
+
+    /* There is no native handle for a non-SSL socket context */
+    return 0;
+}
+
+/* Options is currently only applicable for SSL - this will change with time (prefer_low_memory is one example) */
+struct us_socket_context_t *us_create_socket_context(int ssl, struct us_loop_t *loop, int context_ext_size, struct us_socket_context_options_t options) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        /* This function will call us, again, with SSL = false and a bigger ext_size */
+        return (struct us_socket_context_t *) us_internal_create_ssl_socket_context(loop, context_ext_size, options);
+    }
+#endif
+
+    /* This path is taken once either way - always BEFORE whatever SSL may do LATER.
+     * context_ext_size will however be modified larger in case of SSL, to hold SSL extensions */
+
+    struct us_socket_context_t *context = malloc(sizeof(struct us_socket_context_t) + context_ext_size);
+    context->loop = loop;
+    context->head_sockets = 0;
+    context->head_listen_sockets = 0;
+    context->iterator = 0;
+    context->next = 0;
+    context->is_low_prio = default_is_low_prio_handler;
+
+    /* Begin at 0 */
+    context->timestamp = 0;
+    context->long_timestamp = 0;
+    context->global_tick = 0;
+
+    /* Some new events must be set to null for backwards compatibility */
+    context->on_pre_open = 0;
+
+    us_internal_loop_link(loop, context);
+
+    /* If we are called from within SSL code, SSL code will make further changes to us */
+    return context;
+}
+
+void us_socket_context_free(int ssl, struct us_socket_context_t *context) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        /* This function will call us again with SSL=false */
+        us_internal_ssl_socket_context_free((struct us_internal_ssl_socket_context_t *) context);
+        return;
+    }
+#endif
+
+    /* This path is taken once either way - always AFTER whatever SSL may do BEFORE.
+     * This is the opposite order compared to when creating the context - SSL code is cleaning up before non-SSL */
+
+    us_internal_loop_unlink(context->loop, context);
+    free(context);
+}
+
+struct us_listen_socket_t *us_socket_context_listen(int ssl, struct us_socket_context_t *context, const char *host, int port, int options, int socket_ext_size) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        return us_internal_ssl_socket_context_listen((struct us_internal_ssl_socket_context_t *) context, host, port, options, socket_ext_size);
+    }
+#endif
+
+    LIBUS_SOCKET_DESCRIPTOR listen_socket_fd = bsd_create_listen_socket(host, port, options);
+
+    if (listen_socket_fd == LIBUS_SOCKET_ERROR) {
+        return 0;
+    }
+
+    struct us_poll_t *p = us_create_poll(context->loop, 0, sizeof(struct us_listen_socket_t));
+    us_poll_init(p, listen_socket_fd, POLL_TYPE_SEMI_SOCKET);
+    us_poll_start(p, context->loop, LIBUS_SOCKET_READABLE);
+
+    struct us_listen_socket_t *ls = (struct us_listen_socket_t *) p;
+
+    ls->s.context = context;
+    ls->s.timeout = 255;
+    ls->s.long_timeout = 255;
+    ls->s.low_prio_state = 0;
+    ls->s.next = 0;
+    us_internal_socket_context_link_listen_socket(context, ls);
+
+    ls->socket_ext_size = socket_ext_size;
+
+    return ls;
+}
+
+struct us_listen_socket_t *us_socket_context_listen_unix(int ssl, struct us_socket_context_t *context, const char *path, int options, int socket_ext_size) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        return us_internal_ssl_socket_context_listen_unix((struct us_internal_ssl_socket_context_t *) context, path, options, socket_ext_size);
+    }
+#endif
+
+    LIBUS_SOCKET_DESCRIPTOR listen_socket_fd = bsd_create_listen_socket_unix(path, options);
+
+    if (listen_socket_fd == LIBUS_SOCKET_ERROR) {
+        return 0;
+    }
+
+    struct us_poll_t *p = us_create_poll(context->loop, 0, sizeof(struct us_listen_socket_t));
+    us_poll_init(p, listen_socket_fd, POLL_TYPE_SEMI_SOCKET);
+    us_poll_start(p, context->loop, LIBUS_SOCKET_READABLE);
+
+    struct us_listen_socket_t *ls = (struct us_listen_socket_t *) p;
+
+    ls->s.context = context;
+    ls->s.timeout = 255;
+    ls->s.long_timeout = 255;
+    ls->s.low_prio_state = 0;
+    ls->s.next = 0;
+    us_internal_socket_context_link_listen_socket(context, ls);
+
+    ls->socket_ext_size = socket_ext_size;
+
+    return ls;
+}
+
+struct us_socket_t *us_socket_context_connect(int ssl, struct us_socket_context_t *context, const char *host, int port, const char *source_host, int options, int socket_ext_size) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        return (struct us_socket_t *) us_internal_ssl_socket_context_connect((struct us_internal_ssl_socket_context_t *) context, host, port, source_host, options, socket_ext_size);
+    }
+#endif
+
+    LIBUS_SOCKET_DESCRIPTOR connect_socket_fd = bsd_create_connect_socket(host, port, source_host, options);
+    if (connect_socket_fd == LIBUS_SOCKET_ERROR) {
+        return 0;
+    }
+
+    /* Connect sockets are semi-sockets just like listen sockets */
+    struct us_poll_t *p = us_create_poll(context->loop, 0, sizeof(struct us_socket_t) + socket_ext_size);
+    us_poll_init(p, connect_socket_fd, POLL_TYPE_SEMI_SOCKET);
+    us_poll_start(p, context->loop, LIBUS_SOCKET_WRITABLE);
+
+    struct us_socket_t *connect_socket = (struct us_socket_t *) p;
+
+    /* Link it into context so that timeout fires properly */
+    connect_socket->context = context;
+    connect_socket->timeout = 255;
+    connect_socket->long_timeout = 255;
+    connect_socket->low_prio_state = 0;
+    us_internal_socket_context_link_socket(context, connect_socket);
+
+    return connect_socket;
+}
+
+struct us_socket_t *us_socket_context_connect_unix(int ssl, struct us_socket_context_t *context, const char *server_path, int options, int socket_ext_size) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        return (struct us_socket_t *) us_internal_ssl_socket_context_connect_unix((struct us_internal_ssl_socket_context_t *) context, server_path, options, socket_ext_size);
+    }
+#endif
+
+    LIBUS_SOCKET_DESCRIPTOR connect_socket_fd = bsd_create_connect_socket_unix(server_path, options);
+    if (connect_socket_fd == LIBUS_SOCKET_ERROR) {
+        return 0;
+    }
+
+    /* Connect sockets are semi-sockets just like listen sockets */
+    struct us_poll_t *p = us_create_poll(context->loop, 0, sizeof(struct us_socket_t) + socket_ext_size);
+    us_poll_init(p, connect_socket_fd, POLL_TYPE_SEMI_SOCKET);
+    us_poll_start(p, context->loop, LIBUS_SOCKET_WRITABLE);
+
+    struct us_socket_t *connect_socket = (struct us_socket_t *) p;
+
+    /* Link it into context so that timeout fires properly */
+    connect_socket->context = context;
+    connect_socket->timeout = 255;
+    connect_socket->long_timeout = 255;
+    connect_socket->low_prio_state = 0;
+    us_internal_socket_context_link_socket(context, connect_socket);
+
+    return connect_socket;
+}
+
+struct us_socket_context_t *us_create_child_socket_context(int ssl, struct us_socket_context_t *context, int context_ext_size) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        return (struct us_socket_context_t *) us_internal_create_child_ssl_socket_context((struct us_internal_ssl_socket_context_t *) context, context_ext_size);
+    }
+#endif
+
+    /* For TCP we simply create a new context as nothing is shared */
+    struct us_socket_context_options_t options = {0};
+    return us_create_socket_context(ssl, context->loop, context_ext_size, options);
+}
+
+/* Note: This will set timeout to 0 */
+struct us_socket_t *us_socket_context_adopt_socket(int ssl, struct us_socket_context_t *context, struct us_socket_t *s, int ext_size) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        return (struct us_socket_t *) us_internal_ssl_socket_context_adopt_socket((struct us_internal_ssl_socket_context_t *) context, (struct us_internal_ssl_socket_t *) s, ext_size);
+    }
+#endif
+
+    /* Cannot adopt a closed socket */
+    if (us_socket_is_closed(ssl, s)) {
+        return s;
+    }
+
+    if (s->low_prio_state != 1) {
+        /* This properly updates the iterator if in on_timeout */
+        us_internal_socket_context_unlink_socket(s->context, s);
+    }
+
+    struct us_socket_t *new_s = (struct us_socket_t *) us_poll_resize(&s->p, s->context->loop, sizeof(struct us_socket_t) + ext_size);
+    new_s->timeout = 255;
+    new_s->long_timeout = 255;
+
+    if (new_s->low_prio_state == 1) {
+        /* update pointers in low-priority queue */
+        if (!new_s->prev) new_s->context->loop->data.low_prio_head = new_s;
+        else new_s->prev->next = new_s;
+
+        if (new_s->next) new_s->next->prev = new_s;
+    } else {
+        us_internal_socket_context_link_socket(context, new_s);
+    }
+
+    return new_s;
+}
+
+/* For backwards compatibility, this function will be set to nullptr by default. */
+void us_socket_context_on_pre_open(int ssl, struct us_socket_context_t *context, LIBUS_SOCKET_DESCRIPTOR (*on_pre_open)(LIBUS_SOCKET_DESCRIPTOR fd)) {
+    /* For this event, there is no difference between SSL and non-SSL */
+    context->on_pre_open = on_pre_open;
+}
+
+void us_socket_context_on_open(int ssl, struct us_socket_context_t *context, struct us_socket_t *(*on_open)(struct us_socket_t *s, int is_client, char *ip, int ip_length)) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        us_internal_ssl_socket_context_on_open((struct us_internal_ssl_socket_context_t *) context, (struct us_internal_ssl_socket_t * (*)(struct us_internal_ssl_socket_t *, int,  char *, int)) on_open);
+        return;
+    }
+#endif
+
+    context->on_open = on_open;
+}
+
+void us_socket_context_on_close(int ssl, struct us_socket_context_t *context, struct us_socket_t *(*on_close)(struct us_socket_t *s, int code, void *reason)) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        us_internal_ssl_socket_context_on_close((struct us_internal_ssl_socket_context_t *) context, (struct us_internal_ssl_socket_t * (*)(struct us_internal_ssl_socket_t *, int code, void *reason)) on_close);
+        return;
+    }
+#endif
+
+    context->on_close = on_close;
+}
+
+void us_socket_context_on_data(int ssl, struct us_socket_context_t *context, struct us_socket_t *(*on_data)(struct us_socket_t *s, char *data, int length)) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        us_internal_ssl_socket_context_on_data((struct us_internal_ssl_socket_context_t *) context, (struct us_internal_ssl_socket_t * (*)(struct us_internal_ssl_socket_t *, char *, int)) on_data);
+        return;
+    }
+#endif
+
+    context->on_data = on_data;
+}
+
+void us_socket_context_on_writable(int ssl, struct us_socket_context_t *context, struct us_socket_t *(*on_writable)(struct us_socket_t *s)) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        us_internal_ssl_socket_context_on_writable((struct us_internal_ssl_socket_context_t *) context, (struct us_internal_ssl_socket_t * (*)(struct us_internal_ssl_socket_t *)) on_writable);
+        return;
+    }
+#endif
+
+    context->on_writable = on_writable;
+}
+
+void us_socket_context_on_long_timeout(int ssl, struct us_socket_context_t *context, struct us_socket_t *(*on_long_timeout)(struct us_socket_t *)) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        us_internal_ssl_socket_context_on_long_timeout((struct us_internal_ssl_socket_context_t *) context, (struct us_internal_ssl_socket_t * (*)(struct us_internal_ssl_socket_t *)) on_long_timeout);
+        return;
+    }
+#endif
+
+    context->on_socket_long_timeout = on_long_timeout;
+}
+
+void us_socket_context_on_timeout(int ssl, struct us_socket_context_t *context, struct us_socket_t *(*on_timeout)(struct us_socket_t *)) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        us_internal_ssl_socket_context_on_timeout((struct us_internal_ssl_socket_context_t *) context, (struct us_internal_ssl_socket_t * (*)(struct us_internal_ssl_socket_t *)) on_timeout);
+        return;
+    }
+#endif
+
+    context->on_socket_timeout = on_timeout;
+}
+
+void us_socket_context_on_end(int ssl, struct us_socket_context_t *context, struct us_socket_t *(*on_end)(struct us_socket_t *)) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        us_internal_ssl_socket_context_on_end((struct us_internal_ssl_socket_context_t *) context, (struct us_internal_ssl_socket_t * (*)(struct us_internal_ssl_socket_t *)) on_end);
+        return;
+    }
+#endif
+
+    context->on_end = on_end;
+}
+
+void us_socket_context_on_connect_error(int ssl, struct us_socket_context_t *context, struct us_socket_t *(*on_connect_error)(struct us_socket_t *s, int code)) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        us_internal_ssl_socket_context_on_connect_error((struct us_internal_ssl_socket_context_t *) context, (struct us_internal_ssl_socket_t * (*)(struct us_internal_ssl_socket_t *, int)) on_connect_error);
+        return;
+    }
+#endif
+    
+    context->on_connect_error = on_connect_error;
+}
+
+void *us_socket_context_ext(int ssl, struct us_socket_context_t *context) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        return us_internal_ssl_socket_context_ext((struct us_internal_ssl_socket_context_t *) context);
+    }
+#endif
+
+    return context + 1;
+}
+
+#endif