iodine 0.2.17 → 0.3.0

data/ext/iodine/websockets.c

@@ -4,13 +4,16 @@ license: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
 */
-#include "websockets.h"
+#include "spnlock.inc"
+
 #include "bscrypt.h"
-#include "libserver.h"
+#include "websockets.h"
 #include <arpa/inet.h>
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <strings.h>
 
 #if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
 #include <endian.h>
@@ -161,13 +164,8 @@ The Websocket Protocol implementation
 
 static void ws_ping(intptr_t fd, protocol_s *ws) {
   (void)(ws);
-  sock_packet_s *packet;
-  while ((packet = sock_checkout_packet()) == NULL)
-    sock_flush_all();
-  *packet = (sock_packet_s){
-      .buffer = "\x89\x00", .length = 2, .metadata.urgent = 1,
-  };
-  sock_send_packet(fd, packet);
+  sock_write2(.uuid = fd, .buffer = "\x89\x00", .length = 2, .move = 1,
+              .dealloc = SOCK_DEALLOC_NOOP);
 }
 
 static void on_close(protocol_s *_ws) { destroy_ws((ws_s *)_ws); }
@@ -178,11 +176,11 @@ static void on_ready(intptr_t fduuid, protocol_s *ws) {
     ((ws_s *)ws)->on_ready((ws_s *)ws);
 }
 
-static void on_open(intptr_t fd, protocol_s *ws, void *callback) {
-  (void)(fd);
-  if (callback && ws && ws->service == WEBSOCKET_ID_STR)
-    ((void (*)(void *))callback)(ws);
-}
+// static void on_open(intptr_t fd, protocol_s *ws, void *callback) {
+//   (void)(fd);
+//   if (callback && ws && ws->service == WEBSOCKET_ID_STR)
+//     ((void (*)(void *))callback)(ws);
+// }
 
 static void on_shutdown(intptr_t fd, protocol_s *ws) {
   (void)(fd);
@@ -579,21 +577,25 @@ static void websocket_write_impl(intptr_t fd, void *data, size_t len,
                                  char text, /* TODO: add client masking */
                                  char first, char last, char client) {
   if (len < 126) {
-    char buff[len + (client ? 6 : 2)];
-    len = websocket_encode(buff, data, len, text, first, last, client);
-    sock_write(fd, buff, len);
+    sock_buffer_s *sbuff = sock_buffer_checkout();
+    sbuff->len =
+        websocket_encode(sbuff->buf, data, len, text, first, last, client);
+    sock_buffer_send(fd, sbuff);
+    // // was:
+    // char buff[len + (client ? 6 : 2)];
+    // len = websocket_encode(buff, data, len, text, first, last, client);
+    // sock_write(fd, buff, len);
   } else if (len <= WS_MAX_FRAME_SIZE) {
-    if (len >= BUFFER_PACKET_SIZE) { // if len is larger then a single packet.
+    if (len >= BUFFER_PACKET_SIZE - 8) { // can't feet in sock buffer
       /* head MUST be 4 bytes */
       void *buff = malloc(len + 4);
       len = websocket_encode(buff, data, len, text, first, last, client);
-      sock_write2(.fduuid = fd, .buffer = buff, .length = len, .move = 1);
+      sock_write2(.uuid = fd, .buffer = buff, .length = len, .move = 1);
     } else {
-      sock_packet_s *packet = sock_checkout_packet();
-      packet->length = websocket_encode(packet->buffer, data, len, text, first,
-                                        last, client);
-      packet->metadata.can_interrupt = 1;
-      sock_send_packet(fd, packet);
+      sock_buffer_s *sbuff = sock_buffer_checkout();
+      sbuff->len =
+          websocket_encode(sbuff->buf, data, len, text, first, last, client);
+      sock_buffer_send(fd, sbuff);
     }
   } else {
     /* frame fragmentation is better for large data then large frames */
@@ -617,8 +619,6 @@ The API implementation
 ssize_t websocket_upgrade(websocket_settings_s settings) {
   // A static data used for all websocket connections.
   static char ws_key_accpt_str[] = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
-  // a temporary response object, in case none is provided.
-  http_response_s tmp_response;
   // require either a request or a response.
   if (((uintptr_t)settings.request | (uintptr_t)settings.response) ==
       (uintptr_t)NULL)
@@ -631,23 +631,21 @@ ssize_t websocket_upgrade(websocket_settings_s settings) {
   http_response_s *response = settings.response;
   if (response == NULL) {
     /* initialize a default upgrade response */
-    tmp_response = http_response_init(settings.request);
-    response = &tmp_response;
+    response = http_response_create(settings.request);
   } else
-    settings.request = response->metadata.request;
+    settings.request = response->request;
   // allocate the protocol object (TODO: (maybe) pooling)
   ws_s *ws = new_websocket();
   if (!ws)
     goto refuse;
 
   // setup the socket-server data
-  ws->fd = response->metadata.request->metadata.fd;
+  ws->fd = response->request->fd;
   // Setup ws callbacks
   ws->on_close = settings.on_close;
   ws->on_message = settings.on_message;
   ws->on_ready = settings.on_ready;
   ws->on_shutdown = settings.on_shutdown;
-
   // setup any user data
   ws->udata = settings.udata;
   // buffer limits
@@ -655,17 +653,15 @@ ssize_t websocket_upgrade(websocket_settings_s settings) {
   const char *recv_str;
 
   recv_str =
-      http_request_find_header(settings.request, "sec-websocket-version", 21);
+      http_request_header_find(settings.request, "sec-websocket-version", 21)
+          .value;
   if (recv_str == NULL || recv_str[0] != '1' || recv_str[1] != '3')
     goto refuse;
 
-  recv_str =
-      http_request_find_header(settings.request, "sec-websocket-key", 17);
-  if (recv_str == NULL)
+  http_header_s sec_h =
+      http_request_header_find(settings.request, "sec-websocket-key", 17);
+  if (sec_h.value == NULL)
     goto refuse;
-  size_t recv_len =
-      settings.request->headers[settings.request->metadata.headers_pos]
-          .value_length;
 
   // websocket extentions (none)
 
@@ -674,7 +670,7 @@ ssize_t websocket_upgrade(websocket_settings_s settings) {
   // use the SHA1 methods provided to concat the client string and hash
   sha1_s sha1;
   sha1 = bscrypt_sha1_init();
-  bscrypt_sha1_write(&sha1, recv_str, recv_len);
+  bscrypt_sha1_write(&sha1, sec_h.value, sec_h.value_len);
   bscrypt_sha1_write(&sha1, ws_key_accpt_str, sizeof(ws_key_accpt_str) - 1);
   // base encode the data
   char websockets_key[32];
@@ -686,20 +682,19 @@ ssize_t websocket_upgrade(websocket_settings_s settings) {
   // upgrade taking place, make sure the upgrade headers are valid for the
   // response.
   response->status = 101;
-  http_response_write_header(response, .name = "Connection", .name_length = 10,
-                             .value = "Upgrade", .value_length = 7);
-  http_response_write_header(response, .name = "Upgrade", .name_length = 7,
-                             .value = "websocket", .value_length = 9);
+  http_response_write_header(response, .name = "Connection", .name_len = 10,
+                             .value = "Upgrade", .value_len = 7);
+  http_response_write_header(response, .name = "Upgrade", .name_len = 7,
+                             .value = "websocket", .value_len = 9);
   http_response_write_header(response, .name = "sec-websocket-version",
-                             .name_length = 21, .value = "13",
-                             .value_length = 2);
+                             .name_len = 21, .value = "13", .value_len = 2);
   // set the string's length and encoding
   http_response_write_header(response, .name = "Sec-WebSocket-Accept",
-                             .name_length = 20, .value = websockets_key,
-                             .value_length = len);
-  // inform about 0 extension support
-  recv_str = http_request_find_header(settings.request,
-                                      "sec-websocket-extensions", 24);
+                             .name_len = 20, .value = websockets_key,
+                             .value_len = len);
+  // // inform about 0 extension support
+  // sec_h = http_request_header_find(settings.request,
+  // "sec-websocket-extensions", 24);
   // if (recv_str != NULL)
   //   http_response_write_header(response, .name =
   //   "Sec-Websocket-Extensions",
@@ -711,21 +706,19 @@ refuse:
   response->status = 400;
 cleanup:
   if (response->status == 101) {
-    // set the protocol lock
-    ws->protocol.callback_lock = SPN_LOCK_INIT;
-    spn_lock(&ws->protocol.callback_lock);
     // send the response
     http_response_finish(response);
-    // update the protocol object, cleanning up the old one
-    server_switch_protocol(ws->fd, (void *)ws);
     // we have an active websocket connection - prep the connection buffer
     ws->buffer = create_ws_buffer(ws);
     // update the timeout
-    server_set_timeout(ws->fd, settings.timeout);
+    facil_set_timeout(ws->fd, settings.timeout);
     // call the on_open callback
     if (settings.on_open)
-      server_task(ws->fd, on_open, (void *)settings.on_open, NULL);
-    spn_unlock(&ws->protocol.callback_lock);
+      settings.on_open(ws);
+    // facil_defer(.uuid = ws->fd, .task = on_open,
+    //             .arg = (void *)settings.on_open);
+    // update the protocol object, cleanning up the old one
+    facil_attach(ws->fd, (protocol_s *)ws);
     return 0;
   }
   http_response_finish(response);
@@ -736,12 +729,12 @@ cleanup:
   websocket_upgrade((websocket_settings_s){__VA_ARGS__})
 
 /** Returns the opaque user data associated with the websocket. */
-void *websocket_get_udata(ws_s *ws) { return ws->udata; }
+void *websocket_udata(ws_s *ws) { return ws->udata; }
 /** Returns the the process specific connection's UUID (see `libsock`). */
-intptr_t websocket_get_fduuid(ws_s *ws) { return ws->fd; }
+intptr_t websocket_uuid(ws_s *ws) { return ws->fd; }
 /** Sets the opaque user data associated with the websocket.
  * Returns the old value, if any. */
-void *websocket_set_udata(ws_s *ws, void *udata) {
+void *websocket_udata_set(ws_s *ws, void *udata) {
   void *old = ws->udata;
   ws->udata = udata;
   return old;
@@ -756,13 +749,8 @@ int websocket_write(ws_s *ws, void *data, size_t size, uint8_t is_text) {
 }
 /** Closes a websocket connection. */
 void websocket_close(ws_s *ws) {
-  sock_packet_s *packet;
-  while ((packet = sock_checkout_packet()) == NULL)
-    sock_flush_all();
-  *packet = (sock_packet_s){
-      .buffer = "\x88\x00", .length = 2,
-  };
-  sock_send_packet(ws->fd, packet);
+  sock_write2(.uuid = ws->fd, .buffer = "\x88\x00", .length = 2, .move = 1,
+              .dealloc = SOCK_DEALLOC_NOOP);
   sock_close(ws->fd);
   return;
 }
@@ -770,10 +758,7 @@ void websocket_close(ws_s *ws) {
 /**
 Counts the number of websocket connections.
 */
-size_t websocket_count(ws_s *ws) {
-  (void)(ws);
-  return server_count(WEBSOCKET_ID_STR);
-}
+size_t websocket_count(void) { return facil_count(WEBSOCKET_ID_STR); }
 
 /*******************************************************************************
 Each Implementation
@@ -787,17 +772,24 @@ struct WSTask {
 };
 /** Performs a task on each websocket connection that shares the same process
  */
-static void perform_ws_task(intptr_t fd, protocol_s *_ws, void *_arg) {
+static void perform_ws_task(intptr_t fd, protocol_s *ws_, void *tsk_) {
   (void)(fd);
-  struct WSTask *tsk = _arg;
-  tsk->task((ws_s *)(_ws), tsk->arg);
+  struct WSTask *tsk = tsk_;
+  tsk->task((ws_s *)(ws_), tsk->arg);
 }
 /** clears away a wesbocket task. */
-static void finish_ws_task(intptr_t fd, protocol_s *_ws, void *_arg) {
-  (void)(fd);
-  struct WSTask *tsk = _arg;
-  if (tsk->on_finish)
-    tsk->on_finish((ws_s *)(_ws), tsk->arg);
+static void finish_ws_task(intptr_t fd, void *arg) {
+  struct WSTask *tsk = arg;
+  if (tsk->on_finish) {
+    protocol_s *ws = facil_protocol_try_lock(fd, FIO_PR_LOCK_TASK);
+    if (!ws && errno != EBADF) {
+      defer((void (*)(void *, void *))finish_ws_task, (void *)fd, arg);
+      return;
+    }
+    tsk->on_finish((ws_s *)ws, tsk->arg);
+    if (ws)
+      facil_protocol_unlock(ws, FIO_PR_LOCK_TASK);
+  }
   free(tsk);
 }
 
@@ -805,15 +797,15 @@ static void finish_ws_task(intptr_t fd, protocol_s *_ws, void *_arg) {
 Performs a task on each websocket connection that shares the same process
 (except the originating `ws_s` connection which is allowed to be NULL).
  */
-void websocket_each(ws_s *ws_originator,
-                    void (*task)(ws_s *ws_target, void *arg), void *arg,
-                    void (*on_finish)(ws_s *ws_originator, void *arg)) {
+#undef websocket_each
+void websocket_each(struct websocket_each_args_s args) {
   struct WSTask *tsk = malloc(sizeof(*tsk));
-  tsk->arg = arg;
-  tsk->on_finish = on_finish;
-  tsk->task = task;
-  server_each((ws_originator ? ws_originator->fd : -1), WEBSOCKET_ID_STR,
-              perform_ws_task, tsk, finish_ws_task);
+  tsk->arg = args.arg;
+  tsk->on_finish = args.on_finish;
+  tsk->task = args.task;
+  facil_each(.origin = (args.origin ? args.origin->fd : -1),
+             .service = WEBSOCKET_ID_STR, .task = perform_ws_task, .arg = tsk,
+             .on_complete = finish_ws_task);
 }
 /*******************************************************************************
 Multi-Write (direct broadcast) Implementation
@@ -835,14 +827,16 @@ struct websocket_multi_write {
 static void ws_mw_defered_on_finish_fb(intptr_t fd, void *arg) {
   (void)(fd);
   struct websocket_multi_write *fin = arg;
-  fin->on_finished(NULL, fin->arg);
+  if (fin->on_finished)
+    fin->on_finished(NULL, fin->arg);
   free(fin);
 }
 static void ws_mw_defered_on_finish(intptr_t fd, protocol_s *ws, void *arg) {
-  (void)(fd);
+  (void)fd;
   struct websocket_multi_write *fin = arg;
-  fin->on_finished((ws->service == WEBSOCKET_ID_STR ? (ws_s *)ws : NULL),
-                   fin->arg);
+  if (fin->on_finished) {
+    fin->on_finished((ws_s *)ws, fin->arg);
+  }
   free(fin);
 }
 
@@ -853,18 +847,18 @@ static void ws_reduce_or_free_multi_write(void *buff) {
   if (!mw->count) {
     spn_unlock(&mw->lock);
     if (mw->on_finished) {
-      server_task(mw->origin, ws_mw_defered_on_finish, mw,
-                  ws_mw_defered_on_finish_fb);
+      facil_defer(.uuid = mw->origin, .task = ws_mw_defered_on_finish,
+                  .arg = mw, .fallback = ws_mw_defered_on_finish_fb,
+                  .task_type = FIO_PR_LOCK_WRITE);
     } else
       free(mw);
   } else
     spn_unlock(&mw->lock);
 }
 
-static void ws_finish_multi_write(intptr_t fd, protocol_s *_ws, void *arg) {
+static void ws_finish_multi_write(intptr_t fd, void *arg) {
   struct websocket_multi_write *multi = arg;
   (void)(fd);
-  (void)(_ws);
   ws_reduce_or_free_multi_write(multi->buffer);
 }
 
@@ -872,21 +866,11 @@ static void ws_direct_multi_write(intptr_t fd, protocol_s *_ws, void *arg) {
   struct websocket_multi_write *multi = arg;
   if (((ws_s *)(_ws))->parser.client != multi->as_client)
     return;
-
-  sock_packet_s *packet = sock_checkout_packet();
-  *packet = (sock_packet_s){
-      .buffer = multi->buffer,
-      .length = multi->length,
-      .metadata.can_interrupt = 1,
-      .metadata.dealloc = ws_reduce_or_free_multi_write,
-      .metadata.external = 1,
-  };
-
   spn_lock(&multi->lock);
   multi->count += 1;
   spn_unlock(&multi->lock);
-
-  sock_send_packet(fd, packet);
+  sock_write2(.uuid = fd, .buffer = multi->buffer, .length = multi->length,
+              .dealloc = ws_reduce_or_free_multi_write, .move = 1);
 }
 
 static void ws_check_multi_write(intptr_t fd, protocol_s *_ws, void *arg) {
@@ -903,8 +887,11 @@ int websocket_write_each(struct websocket_write_each_args_s args) {
     return -1;
   struct websocket_multi_write *multi =
       malloc(sizeof(*multi) + args.length + 16 /* max head size + 2 */);
-  if (!multi)
+  if (!multi) {
+    if (args.on_finished)
+      defer((void (*)(void *, void *))args.on_finished, NULL, args.arg);
     return -1;
+  }
   *multi = (struct websocket_multi_write){
       .length = websocket_encode(multi->buffer, args.data, args.length,
                                  args.is_text, 1, 1, args.as_client),
@@ -917,8 +904,10 @@ int websocket_write_each(struct websocket_write_each_args_s args) {
       .count = 1,
   };
 
-  server_each(multi->origin, WEBSOCKET_ID_STR,
-              (args.filter ? ws_check_multi_write : ws_direct_multi_write),
-              multi, ws_finish_multi_write);
+  facil_each(.origin = multi->origin, .service = WEBSOCKET_ID_STR,
+             .task_type = FIO_PR_LOCK_WRITE,
+             .task =
+                 (args.filter ? ws_check_multi_write : ws_direct_multi_write),
+             .arg = multi, .on_complete = ws_finish_multi_write);
   return 0;
 }

data/ext/iodine/websockets.h

@@ -7,8 +7,7 @@ Feel free to copy, use and enjoy according to the license provided.
 #ifndef WEBSOCKETS_H
 #define WEBSOCKETS_H
 
-#include "http_request.h"
-#include "http_response.h"
+#include "http.h"
 
 /**
 The Websocket type is an opaque type used by the websocket API to provide
@@ -40,8 +39,8 @@ typedef struct {
   void (*on_message)(ws_s *ws, char *data, size_t size, uint8_t is_text);
   /**
   The (optional) on_open callback will be called once the websocket connection
-  is
-  established.
+  is established and before is is registered with `facil`, so no `on_message`
+  events are raised before `on_open` returns.
   */
   void (*on_open)(ws_s *ws);
   /**
@@ -111,23 +110,47 @@ ssize_t websocket_upgrade(websocket_settings_s settings);
   websocket_upgrade((websocket_settings_s){__VA_ARGS__})
 
 /** Returns the opaque user data associated with the websocket. */
-void *websocket_get_udata(ws_s *ws);
-/** Returns the the process specific connection's UUID (see `libsock`). */
-intptr_t websocket_get_fduuid(ws_s *ws);
-/** Sets the opaque user data associated with the websocket.
- * Returns the old value, if any. */
-void *websocket_set_udata(ws_s *ws, void *udata);
+void *websocket_udata(ws_s *ws);
+/**
+Returns the underlying socket UUID.
+
+This is only relevant for collecting the protocol object from outside of
+websocket events, as the socket shouldn't be written to.
+*/
+intptr_t websocket_uuid(ws_s *ws);
+/**
+Sets the opaque user data associated with the websocket.
+
+Returns the old value, if any.
+*/
+void *websocket_udata_set(ws_s *ws, void *udata);
 /** Writes data to the websocket. Returns -1 on failure (0 on success). */
 int websocket_write(ws_s *ws, void *data, size_t size, uint8_t is_text);
 /** Closes a websocket connection. */
 void websocket_close(ws_s *ws);
 /**
+Counts the number of websocket connections.
+*/
+size_t websocket_count(void);
+
+/** The named arguments for `websocket_each` */
+struct websocket_each_args_s {
+  /** The websocket originating the task. It will be excluded for the loop. */
+  ws_s *origin;
+  /** The task (function) to be performed. This is required. */
+  void (*task)(ws_s *ws_target, void *arg);
+  /** User opaque data to be passed along. */
+  void *arg;
+  /** The on_finish callback is always called. Good for cleanup. */
+  void (*on_finish)(ws_s *origin, void *arg);
+};
+/**
 Performs a task on each websocket connection that shares the same process
 (except the originating `ws_s` connection which is allowed to be NULL).
  */
-void websocket_each(ws_s *ws_originator,
-                    void (*task)(ws_s *ws_target, void *arg), void *arg,
-                    void (*on_finish)(ws_s *ws_originator, void *arg));
+void websocket_each(struct websocket_each_args_s args);
+#define websocket_each(...)                                                    \
+  websocket_each((struct websocket_each_args_s){__VA_ARGS__})
 
 /**
 The Arguments passed to the `websocket_write_each` function / macro are defined
@@ -135,7 +158,7 @@ here, for convinience of calling the function.
 */
 struct websocket_write_each_args_s {
   /** The originating websocket client will be excluded from the `write`.
-    * Can be NULL. */
+   * Can be NULL. */
   ws_s *origin;
   /** The data to be written to the websocket - required(!) */
   void *data;
@@ -151,7 +174,7 @@ struct websocket_write_each_args_s {
    * Should return 1 to send data and 0 to exclude. */
   uint8_t (*filter)(ws_s *ws_to, void *arg);
   /** A callback called once all the data was sent. */
-  void (*on_finished)(ws_s *ws_to, void *arg);
+  void (*on_finished)(ws_s *ws_origin, void *arg);
   /** A user specified argumernt passed to each of the callbacks. */
   void *arg;
 };
@@ -165,9 +188,5 @@ details for possible arguments.
 int websocket_write_each(struct websocket_write_each_args_s args);
 #define websocket_write_each(...)                                              \
   websocket_write_each((struct websocket_write_each_args_s){__VA_ARGS__})
-/**
-Counts the number of websocket connections.
-*/
-size_t websocket_count(ws_s *ws);
 
 #endif