uws-react-native 0.0.1-alpha.1

package/cpp/uSockets/quic.h

@@ -0,0 +1,68 @@
+#ifdef LIBUS_USE_QUIC
+
+#ifndef LIBUS_QUIC_H
+#define LIBUS_QUIC_H
+
+/* Experimental QUIC functions */
+
+#include "libusockets.h"
+
+typedef struct {
+    const char *cert_file_name;
+    const char *key_file_name;
+    const char *passphrase;
+} us_quic_socket_context_options_t;
+
+
+typedef struct {
+    /* Refers to either the shared listen socket or the client UDP socket */
+    void *udp_socket;
+} us_quic_socket_t;
+
+struct us_quic_socket_context_s;
+struct us_quic_listen_socket_s;
+struct us_quic_stream_s;
+
+typedef struct us_quic_socket_context_s us_quic_socket_context_t;
+typedef struct us_quic_listen_socket_s us_quic_listen_socket_t;
+typedef struct us_quic_stream_s us_quic_stream_t;
+
+
+void *us_quic_stream_ext(us_quic_stream_t *s);
+int us_quic_stream_write(us_quic_stream_t *s, char *data, int length);
+int us_quic_stream_shutdown(us_quic_stream_t *s);
+int us_quic_stream_shutdown_read(us_quic_stream_t *s);
+void us_quic_stream_close(us_quic_stream_t *s);
+
+int us_quic_socket_context_get_header(us_quic_socket_context_t *context, int index, char **name, int *name_length, char **value, int *value_length);
+
+
+void us_quic_socket_context_set_header(us_quic_socket_context_t *context, int index, const char *key, int key_length, const char *value, int value_length);
+void us_quic_socket_context_send_headers(us_quic_socket_context_t *context, us_quic_stream_t *s, int num, int has_body);
+
+us_quic_socket_context_t *us_create_quic_socket_context(struct us_loop_t *loop, us_quic_socket_context_options_t options, int ext_size);
+us_quic_listen_socket_t *us_quic_socket_context_listen(us_quic_socket_context_t *context, const char *host, int port, int ext_size);
+us_quic_socket_t *us_quic_socket_context_connect(us_quic_socket_context_t *context, const char *host, int port, int ext_size);
+
+void us_quic_socket_create_stream(us_quic_socket_t *s, int ext_size);
+us_quic_socket_t *us_quic_stream_socket(us_quic_stream_t *s);
+
+/* This one is ugly and is only used to make clean examples */
+int us_quic_stream_is_client(us_quic_stream_t *s);
+
+void us_quic_socket_context_on_stream_data(us_quic_socket_context_t *context, void(*on_stream_data)(us_quic_stream_t *s, char *data, int length));
+void us_quic_socket_context_on_stream_end(us_quic_socket_context_t *context, void(*on_stream_data)(us_quic_stream_t *s));
+void us_quic_socket_context_on_stream_headers(us_quic_socket_context_t *context, void(*on_stream_headers)(us_quic_stream_t *s));
+void us_quic_socket_context_on_stream_open(us_quic_socket_context_t *context, void(*on_stream_open)(us_quic_stream_t *s, int is_client));
+void us_quic_socket_context_on_stream_close(us_quic_socket_context_t *context, void(*on_stream_close)(us_quic_stream_t *s));
+void us_quic_socket_context_on_open(us_quic_socket_context_t *context, void(*on_open)(us_quic_socket_t *s, int is_client));
+void us_quic_socket_context_on_close(us_quic_socket_context_t *context, void(*on_close)(us_quic_socket_t *s));
+void us_quic_socket_context_on_stream_writable(us_quic_socket_context_t *context, void(*on_stream_writable)(us_quic_stream_t *s));
+
+
+
+void *us_quic_socket_context_ext(us_quic_socket_context_t *context);
+us_quic_socket_context_t *us_quic_socket_context(us_quic_socket_t *s);
+
+#endif
+#endif

package/cpp/uSockets/socket.c

@@ -0,0 +1,231 @@
+/*
+ * Authored by Alex Hultman, 2018-2021.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef LIBUS_USE_IO_URING
+
+#include "libusockets.h"
+#include "internal/internal.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+/* Shared with SSL */
+
+int us_socket_local_port(int ssl, struct us_socket_t *s) {
+    struct bsd_addr_t addr;
+    if (bsd_local_addr(us_poll_fd(&s->p), &addr)) {
+        return -1;
+    } else {
+        return bsd_addr_get_port(&addr);
+    }
+}
+
+int us_socket_remote_port(int ssl, struct us_socket_t *s) {
+    struct bsd_addr_t addr;
+    if (bsd_remote_addr(us_poll_fd(&s->p), &addr)) {
+        return -1;
+    } else {
+        return bsd_addr_get_port(&addr);
+    }
+}
+
+void us_socket_shutdown_read(int ssl, struct us_socket_t *s) {
+    /* This syscall is idempotent so no extra check is needed */
+    bsd_shutdown_socket_read(us_poll_fd((struct us_poll_t *) s));
+}
+
+void us_socket_remote_address(int ssl, struct us_socket_t *s, char *buf, int *length) {
+    struct bsd_addr_t addr;
+    if (bsd_remote_addr(us_poll_fd(&s->p), &addr) || *length < bsd_addr_get_ip_length(&addr)) {
+        *length = 0;
+    } else {
+        *length = bsd_addr_get_ip_length(&addr);
+        memcpy(buf, bsd_addr_get_ip(&addr), *length);
+    }
+}
+
+struct us_socket_context_t *us_socket_context(int ssl, struct us_socket_t *s) {
+    return s->context;
+}
+
+void us_socket_timeout(int ssl, struct us_socket_t *s, unsigned int seconds) {
+    if (seconds) {
+        s->timeout = ((unsigned int)s->context->timestamp + ((seconds + 3) >> 2)) % 240;
+    } else {
+        s->timeout = 255;
+    }
+}
+
+void us_socket_long_timeout(int ssl, struct us_socket_t *s, unsigned int minutes) {
+    if (minutes) {
+        s->long_timeout = ((unsigned int)s->context->long_timestamp + minutes) % 240;
+    } else {
+        s->long_timeout = 255;
+    }
+}
+
+void us_socket_flush(int ssl, struct us_socket_t *s) {
+    if (!us_socket_is_shut_down(0, s)) {
+        bsd_socket_flush(us_poll_fd((struct us_poll_t *) s));
+    }
+}
+
+int us_socket_is_closed(int ssl, struct us_socket_t *s) {
+    return s->prev == (struct us_socket_t *) s->context;
+}
+
+int us_socket_is_established(int ssl, struct us_socket_t *s) {
+    /* Everything that is not POLL_TYPE_SEMI_SOCKET is established */
+    return us_internal_poll_type((struct us_poll_t *) s) != POLL_TYPE_SEMI_SOCKET;
+}
+
+/* Exactly the same as us_socket_close but does not emit on_close event */
+struct us_socket_t *us_socket_close_connecting(int ssl, struct us_socket_t *s) {
+    if (!us_socket_is_closed(0, s)) {
+        us_internal_socket_context_unlink_socket(s->context, s);
+        us_poll_stop((struct us_poll_t *) s, s->context->loop);
+        bsd_close_socket(us_poll_fd((struct us_poll_t *) s));
+
+        /* Link this socket to the close-list and let it be deleted after this iteration */
+        s->next = s->context->loop->data.closed_head;
+        s->context->loop->data.closed_head = s;
+
+        /* Any socket with prev = context is marked as closed */
+        s->prev = (struct us_socket_t *) s->context;
+
+        //return s->context->on_close(s, code, reason);
+    }
+    return s;
+}
+
+/* Same as above but emits on_close */
+struct us_socket_t *us_socket_close(int ssl, struct us_socket_t *s, int code, void *reason) {
+    if (!us_socket_is_closed(0, s)) {
+        if (s->low_prio_state == 1) {
+            /* Unlink this socket from the low-priority queue */
+            if (!s->prev) s->context->loop->data.low_prio_head = s->next;
+            else s->prev->next = s->next;
+
+            if (s->next) s->next->prev = s->prev;
+
+            s->prev = 0;
+            s->next = 0;
+            s->low_prio_state = 0;
+        } else {
+            us_internal_socket_context_unlink_socket(s->context, s);
+        }
+        us_poll_stop((struct us_poll_t *) s, s->context->loop);
+        bsd_close_socket(us_poll_fd((struct us_poll_t *) s));
+
+        /* Link this socket to the close-list and let it be deleted after this iteration */
+        s->next = s->context->loop->data.closed_head;
+        s->context->loop->data.closed_head = s;
+
+        /* Any socket with prev = context is marked as closed */
+        s->prev = (struct us_socket_t *) s->context;
+
+        return s->context->on_close(s, code, reason);
+    }
+    return s;
+}
+
+/* Not shared with SSL */
+
+void *us_socket_get_native_handle(int ssl, struct us_socket_t *s) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        return us_internal_ssl_socket_get_native_handle((struct us_internal_ssl_socket_t *) s);
+    }
+#endif
+
+    return (void *) (uintptr_t) us_poll_fd((struct us_poll_t *) s);
+}
+
+/* This is not available for SSL sockets as it makes no sense. */
+int us_socket_write2(int ssl, struct us_socket_t *s, const char *header, int header_length, const char *payload, int payload_length) {
+
+    if (us_socket_is_closed(ssl, s) || us_socket_is_shut_down(ssl, s)) {
+        return 0;
+    }
+
+    int written = bsd_write2(us_poll_fd(&s->p), header, header_length, payload, payload_length);
+    if (written != header_length + payload_length) {
+        us_poll_change(&s->p, s->context->loop, LIBUS_SOCKET_READABLE | LIBUS_SOCKET_WRITABLE);
+    }
+
+    return written < 0 ? 0 : written;
+}
+
+int us_socket_write(int ssl, struct us_socket_t *s, const char *data, int length, int msg_more) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        return us_internal_ssl_socket_write((struct us_internal_ssl_socket_t *) s, data, length, msg_more);
+    }
+#endif
+
+    if (us_socket_is_closed(ssl, s) || us_socket_is_shut_down(ssl, s)) {
+        return 0;
+    }
+
+    int written = bsd_send(us_poll_fd(&s->p), data, length, msg_more);
+    if (written != length) {
+        s->context->loop->data.last_write_failed = 1;
+        us_poll_change(&s->p, s->context->loop, LIBUS_SOCKET_READABLE | LIBUS_SOCKET_WRITABLE);
+    }
+
+    return written < 0 ? 0 : written;
+}
+
+void *us_socket_ext(int ssl, struct us_socket_t *s) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        return us_internal_ssl_socket_ext((struct us_internal_ssl_socket_t *) s);
+    }
+#endif
+
+    return s + 1;
+}
+
+int us_socket_is_shut_down(int ssl, struct us_socket_t *s) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        return us_internal_ssl_socket_is_shut_down((struct us_internal_ssl_socket_t *) s);
+    }
+#endif
+
+    return us_internal_poll_type(&s->p) == POLL_TYPE_SOCKET_SHUT_DOWN;
+}
+
+void us_socket_shutdown(int ssl, struct us_socket_t *s) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        us_internal_ssl_socket_shutdown((struct us_internal_ssl_socket_t *) s);
+        return;
+    }
+#endif
+
+    /* Todo: should we emit on_close if calling shutdown on an already half-closed socket?
+     * We need more states in that case, we need to track RECEIVED_FIN
+     * so far, the app has to track this and call close as needed */
+    if (!us_socket_is_closed(ssl, s) && !us_socket_is_shut_down(ssl, s)) {
+        us_internal_poll_set_type(&s->p, POLL_TYPE_SOCKET_SHUT_DOWN);
+        us_poll_change(&s->p, s->context->loop, us_poll_events(&s->p) & LIBUS_SOCKET_READABLE);
+        bsd_shutdown_socket(us_poll_fd((struct us_poll_t *) s));
+    }
+}
+
+#endif

package/cpp/uSockets/udp.c

@@ -0,0 +1,151 @@
+/*
+ * Authored by Alex Hultman, 2018-2021.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef LIBUS_USE_IO_URING
+
+#include "libusockets.h"
+#include "internal/internal.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int us_udp_packet_buffer_ecn(struct us_udp_packet_buffer_t *buf, int index) {
+    return bsd_udp_packet_buffer_ecn(buf, index);
+}
+
+int us_udp_packet_buffer_local_ip(struct us_udp_packet_buffer_t *buf, int index, char *ip) {
+    return bsd_udp_packet_buffer_local_ip(buf, index, ip);
+}
+
+char *us_udp_packet_buffer_peer(struct us_udp_packet_buffer_t *buf, int index) {
+    return bsd_udp_packet_buffer_peer(buf, index);
+}
+
+char *us_udp_packet_buffer_payload(struct us_udp_packet_buffer_t *buf, int index) {
+    return bsd_udp_packet_buffer_payload(buf, index);
+}
+
+int us_udp_packet_buffer_payload_length(struct us_udp_packet_buffer_t *buf, int index) {
+    return bsd_udp_packet_buffer_payload_length(buf, index);
+}
+
+// what should we return? number of sent datagrams?
+int us_udp_socket_send(struct us_udp_socket_t *s, struct us_udp_packet_buffer_t *buf, int num) {
+    int fd = us_poll_fd((struct us_poll_t *) s);
+
+    // we need to poll out if we failed
+
+    return bsd_sendmmsg(fd, buf, num, 0);
+}
+
+int us_udp_socket_receive(struct us_udp_socket_t *s, struct us_udp_packet_buffer_t *buf) {
+    int fd = us_poll_fd((struct us_poll_t *) s);
+    return bsd_recvmmsg(fd, buf, LIBUS_UDP_MAX_NUM, 0, 0);
+}
+
+void us_udp_buffer_set_packet_payload(struct us_udp_packet_buffer_t *send_buf, int index, int offset, void *payload, int length, void *peer_addr) {
+    bsd_udp_buffer_set_packet_payload(send_buf, index, offset, payload, length, peer_addr);
+}
+
+struct us_udp_packet_buffer_t *us_create_udp_packet_buffer() {
+    return (struct us_udp_packet_buffer_t *) bsd_create_udp_packet_buffer();
+}
+
+struct us_internal_udp_t {
+    struct us_internal_callback_t cb;
+    struct us_udp_packet_buffer_t *receive_buf;
+    void (*data_cb)(struct us_udp_socket_t *, struct us_udp_packet_buffer_t *, int);
+    void (*drain_cb)(struct us_udp_socket_t *);
+    void *user;
+    /* An UDP socket can only ever be bound to one single port regardless of how
+     * many interfaces it may listen to. Therefore we cache the port after creation
+     * and use it to build a proper and full sockaddr_in or sockaddr_in6 for every received packet */
+    int port;
+};
+
+int us_udp_socket_bound_port(struct us_udp_socket_t *s) {
+    return ((struct us_internal_udp_t *) s)->port;
+}
+
+/* Internal wrapper, move from here */
+void internal_on_udp_read(struct us_udp_socket_t *s) {
+
+    // lookup receive buffer and callback here
+    struct us_internal_udp_t *udp = (struct us_internal_udp_t *) s;
+
+    int packets = us_udp_socket_receive(s, udp->receive_buf);
+    //printf("Packets: %d\n", packets);
+
+    // we need to get the socket data and lookup its callback here
+
+
+    udp->data_cb(s, udp->receive_buf, packets);
+}
+
+void *us_udp_socket_user(struct us_udp_socket_t *s) {
+    struct us_internal_udp_t *udp = (struct us_internal_udp_t *) s;
+
+    return udp->user;
+}
+
+struct us_udp_socket_t *us_create_udp_socket(struct us_loop_t *loop, struct us_udp_packet_buffer_t *buf, void (*data_cb)(struct us_udp_socket_t *, struct us_udp_packet_buffer_t *, int), void (*drain_cb)(struct us_udp_socket_t *), const char *host, unsigned short port, void *user) {
+    
+    LIBUS_SOCKET_DESCRIPTOR fd = bsd_create_udp_socket(host, port);
+    if (fd == LIBUS_SOCKET_ERROR) {
+        return 0;
+    }
+
+    /* If buf is 0 then create one here */
+    if (!buf) {
+        buf = us_create_udp_packet_buffer();
+    }
+
+    int ext_size = 0;
+    int fallthrough = 0;
+
+    struct us_poll_t *p = us_create_poll(loop, fallthrough, sizeof(struct us_internal_udp_t) + ext_size);
+    us_poll_init(p, fd, POLL_TYPE_CALLBACK);
+
+    struct us_internal_udp_t *cb = (struct us_internal_udp_t *) p;
+    cb->cb.loop = loop;
+    cb->cb.cb_expects_the_loop = 0;
+    cb->cb.leave_poll_ready = 1;
+
+    /* Get and store the port once */
+    struct bsd_addr_t tmp;
+    bsd_local_addr(fd, &tmp);
+    cb->port = bsd_addr_get_port(&tmp);
+
+    printf("The port of UDP is: %d\n", cb->port);
+
+    /* There is no udp socket context, only user data */
+    /* This should really be ext like everything else */
+    cb->user = user;
+
+    cb->data_cb = data_cb;
+    cb->receive_buf = buf;
+    cb->drain_cb = drain_cb;
+
+    cb->cb.cb = (void (*)(struct us_internal_callback_t *)) internal_on_udp_read;
+
+    us_poll_start((struct us_poll_t *) cb, cb->cb.loop, LIBUS_SOCKET_READABLE);
+    
+    return (struct us_udp_socket_t *) cb;
+}
+
+#endif