iodine 0.3.5 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 84f989dded41a91d68df5799a63f428dec2dedd9
-  data.tar.gz: 7810e73f1f50a5ac9428419d8f17fa6d31aeb8b4
+  metadata.gz: efa1a3d3d054e8668d5e7f79bf04e61d5f0b169b
+  data.tar.gz: fe096a9cc9f6e6a1196c3c3091228c6d3a72a539
 SHA512:
-  metadata.gz: 607d4b9e6956149302d33e4f3b9a097a83ace382be08a7b55a80c86e4f57630c5dc0abcb7668ab69469a6aeb834f68606087d40f10ac5e3d8cc1f1714cd73e2b
-  data.tar.gz: 4651ef17299e34d1eb83d7fd673e57340b3ec060c3d0b633918ef6876644624072e02f9c930acec4c1a010a4a5ce4ead2a5aa106d134b9882bbe75a36b0a00d2
+  metadata.gz: 6a6d75ec543937ff9f660cf643b442bd8adc8f4c31deac8d9233570385a6ae38a8743c4f1360b7bf3215401019d254e1fbb31c9dc57a1a197ee3c56aad97a1a6
+  data.tar.gz: 980fa44bbba6a0ad6c43c5f8383482261540a6c602b52a98ad716d7bb51ff7635f8fd58aaeb0bfb60bdcbed74218fa98a9ea8edc3cb2122cb5ed1d88c104098e

data/CHANGELOG.md

@@ -8,6 +8,12 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ***
 
+#### Change log v.0.3.6
+
+**Update**: Now using `facil.io` v.0.4.3. This fixes some delays in websocket packet flushing (latency), as well as other internal polishes. It also promises some possible future feature extensions that could add a major performance boost.
+
+***
+
 #### Change log v.0.3.5
 
 **Fix**: (`sock`) Fixed an issue with the `sendfile` implementation on macOS and BSD, where medium to large files wouldn't be sent correctly.

data/ext/iodine/defer.c

@@ -23,7 +23,7 @@ Compile time settings
 #define DEFER_QUEUE_BUFFER 4096
 #endif
 #ifndef DEFER_THROTTLE
-#define DEFER_THROTTLE 16384UL
+#define DEFER_THROTTLE 524287UL
 #endif
 
 /* *****************************************************************************
@@ -86,7 +86,7 @@ schedule:
 error:
   spn_unlock(&deferred.lock);
   perror("ERROR CRITICAL: defer can't allocate task");
-  exit(9);
+  kill(0, SIGINT), exit(errno);
 call_error:
   return -1;
 initialize:
@@ -156,6 +156,11 @@ int defer_join_thread(void *p_thr) {
   return 0;
 }
 
+#pragma weak defer_thread_throttle
+void defer_thread_throttle(unsigned long microsec) {
+  throttle_thread(microsec);
+}
+
 #else /* No pthreads... BYO thread implementation. */
 
 #pragma weak defer_new_thread
@@ -170,6 +175,9 @@ int defer_join_thread(void *p_thr) {
   return -1;
 }
 
+#pragma weak defer_thread_throttle
+void defer_thread_throttle(unsigned long microsec) { return; }
+
 #endif /* DEBUG || pthread default */
 
 struct defer_pool {
@@ -181,8 +189,8 @@ struct defer_pool {
 static void *defer_worker_thread(void *pool) {
   signal(SIGPIPE, SIG_IGN);
   size_t throttle = (((pool_pt)pool)->count) * DEFER_THROTTLE;
-  if (!throttle || throttle > 524288UL)
-    throttle = 524288UL;
+  if (!throttle || throttle > 1572864UL)
+    throttle = 1572864UL;
   do {
     throttle_thread(throttle);
     defer_perform();
@@ -260,10 +268,11 @@ inline static void reap_children(void) {
   sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
   if (sigaction(SIGCHLD, &sa, 0) == -1) {
     perror("Child reaping initialization failed");
-    exit(1);
+    kill(0, SIGINT), exit(errno);
   }
 }
 
+static int defer_fork_pid_id = 0;
 /**
  * Forks the process, starts up a thread pool and waits for all tasks to run.
  * All existing tasks will run in all processes (multiple times).
@@ -308,6 +317,7 @@ int defer_perform_in_fork(unsigned int process_count,
     goto finish;
   for (pids_count = 0; pids_count < process_count; pids_count++) {
     if (!(pids[pids_count] = fork())) {
+      defer_fork_pid_id = pids_count + 1;
       forked_pool = defer_pool_start(thread_count);
       defer_pool_wait(forked_pool);
       defer_perform();
@@ -344,6 +354,9 @@ finish:
  * up. */
 int defer_fork_is_active(void) { return forked_pool && forked_pool->flag; }
 
+/** Returns the process number for the current working proceess. 0 == parent. */
+int defer_fork_pid(void) { return defer_fork_pid_id; }
+
 /* *****************************************************************************
 Test
 ***************************************************************************** */

data/ext/iodine/defer.h

@@ -74,6 +74,14 @@ Return value is ignored.
 */
 int defer_join_thread(void *p_thr);
 
+/**
+OVERRIDE THIS to replace the default pthread implementation.
+
+Throttles or reschedules the current running thread. Default implementation
+simply micro-sleeps.
+*/
+void defer_thread_throttle(unsigned long microsec);
+
 /* *****************************************************************************
 Child Process support (`fork`)
 ***************************************************************************** */
@@ -97,6 +105,8 @@ int defer_perform_in_fork(unsigned int process_count,
 /** Returns TRUE (1) if the forked thread pool hadn't been signaled to finish
  * up. */
 int defer_fork_is_active(void);
+/** Returns the process number for the current working proceess. 0 == parent. */
+int defer_fork_pid(void);
 
 #ifdef __cplusplus
 } /* closing brace for extern "C" */

data/ext/iodine/facil.c

@@ -8,6 +8,7 @@ Feel free to copy, use and enjoy according to the license provided.
 
 #include "evio.h"
 #include "facil.h"
+#include "fio_list.h"
 
 #include <errno.h>
 #include <signal.h>
@@ -56,16 +57,22 @@ static inline void clear_connection_data_unsafe(intptr_t uuid,
 inline static protocol_s *protocol_try_lock(intptr_t fd,
                                             enum facil_protocol_lock_e type) {
   if (spn_trylock(&fd_data(fd).lock))
-    return NULL;
+    goto would_block;
   protocol_s *pr = fd_data(fd).protocol;
   if (!pr) {
     spn_unlock(&fd_data(fd).lock);
+    errno = EBADF;
     return NULL;
   }
-  if (spn_trylock(&prt_meta(pr).locks[type]))
-    pr = NULL;
+  if (spn_trylock(&prt_meta(pr).locks[type])) {
+    spn_unlock(&fd_data(fd).lock);
+    goto would_block;
+  }
   spn_unlock(&fd_data(fd).lock);
   return pr;
+would_block:
+  errno = EWOULDBLOCK;
+  return NULL;
 }
 /** See `facil_protocol_try_lock` for details. */
 inline static void protocol_unlock(protocol_s *pr,
@@ -363,9 +370,10 @@ listener_alloc(struct facil_listen_args settings) {
 inline static void listener_on_start(size_t fd) {
   intptr_t uuid = sock_fd2uuid(fd);
   if (uuid < 0)
-    fprintf(stderr, "ERROR: listening socket dropped?\n"), exit(4);
+    fprintf(stderr, "ERROR: listening socket dropped?\n"), kill(0, SIGINT),
+        exit(4);
   if (evio_add(fd, (void *)uuid) < 0)
-    perror("Couldn't register listening socket"), exit(4);
+    perror("Couldn't register listening socket"), kill(0, SIGINT), exit(4);
   fd_data(fd).active = facil_data->last_cycle;
   // call the on_init callback
   struct ListenerProtocol *listener =
@@ -540,7 +548,8 @@ static inline timer_protocol_s *timer_alloc(void (*task)(void *), void *arg,
 inline static void timer_on_server_start(int fd) {
   if (evio_add_timer(fd, (void *)sock_fd2uuid(fd),
                      prot2timer(fd_data(fd).protocol).milliseconds))
-    perror("Couldn't register a required timed event."), exit(4);
+    perror("Couldn't register a required timed event."), kill(0, SIGINT),
+        exit(4);
 }
 
 /**
@@ -581,6 +590,261 @@ error:
   return -1;
 }
 
+/* *****************************************************************************
+Cluster Messaging
+***************************************************************************** */
+/* cluster state management */
+static struct {
+  uintptr_t count;
+  fio_list_s handlers;
+  spn_lock_i lock;
+  struct facil_cluster_data_pipe {
+    intptr_t in;
+    intptr_t out;
+  } * pipes;
+} facil_cluster_data = {.handlers.next = &facil_cluster_data.handlers,
+                        .handlers.prev = &facil_cluster_data.handlers,
+                        .lock = SPN_LOCK_INIT};
+
+/* internal support for the default pub/sub cluster engin */
+#pragma weak pubsub_cluster_init
+void pubsub_cluster_init(void) {}
+
+/* message handler */
+typedef struct {
+  fio_list_s list;
+  void (*on_message)(void *data, uint32_t len);
+  uint32_t msg_type;
+} fio_cluster_handler;
+
+/* message sending and protocol. */
+struct facil_cluster_msg_packet {
+  uint16_t count;
+  spn_lock_i lock;
+  struct facil_cluster_msg {
+    uint32_t len;
+    uint32_t msg_type;
+  } payload;
+  uint8_t data[];
+};
+
+/* pipe communication protocol object. */
+struct facil_cluster_protocol {
+  protocol_s protocol;
+  size_t mem_size;
+  size_t read;
+  struct facil_cluster_msg *msg;
+};
+
+/* cluster handling of message */
+static void facil_cluster_handle_msg(struct facil_cluster_msg *msg) {
+  fio_cluster_handler *hnd;
+  spn_lock(&facil_cluster_data.lock);
+  fio_list_for_each(fio_cluster_handler, list, hnd,
+                    facil_cluster_data.handlers) {
+    if (hnd->msg_type == msg->msg_type) {
+      hnd->on_message(msg + 1, msg->len - sizeof(*msg));
+    }
+  }
+  spn_unlock(&facil_cluster_data.lock);
+}
+
+/* cluster service ID */
+static char *facil_cluster_protocol_id = "facil_io_internal_cluster_protocol";
+
+/* cluster protocol on_close callback */
+static void facil_cluster_on_close(protocol_s *pr_) {
+  struct facil_cluster_protocol *pr = (struct facil_cluster_protocol *)pr_;
+  if (pr->msg)
+    free(pr->msg);
+  free(pr);
+#if FACIL_PRINT_STATE == 1
+  if (defer_fork_is_active())
+    fprintf(stderr, "ERROR: facil cluster member (%d) closed prematurely.\n",
+            defer_fork_pid());
+#endif
+}
+
+/* cluster protocol on_data callback */
+static void facil_cluster_on_data(intptr_t uuid, protocol_s *pr_) {
+  struct facil_cluster_protocol *pr = (struct facil_cluster_protocol *)pr_;
+  while (1) {
+    errno = 0;
+    if (pr->read < 8 || pr->read < pr->msg->len) {
+      ssize_t read = sock_read(uuid, (void *)((uintptr_t)pr->msg + pr->read),
+                               pr->mem_size - pr->read);
+      if (read <= 0) {
+        if (read < 0)
+          perror("ERROR: cluster pipe read error");
+        return;
+      }
+      pr->read += read;
+      if (pr->read < 8)
+        continue;
+      if (pr->mem_size < pr->msg->len) {
+        void *tmp = realloc(pr->msg, pr->msg->len);
+        if (!tmp)
+          perror("ERROR: (critical) cannot allocate memory for a clustered "
+                 "message."),
+              kill(0, SIGINT), exit(errno);
+        pr->msg = tmp;
+#if defined(FACIL_PRINT_STATE) && FACIL_PRINT_STATE == 1 && defined(DEBUG)
+        fprintf(stderr, "* Cluster (%d) Reallocated msg size to %u\n",
+                defer_fork_pid(), pr->msg->len);
+#endif
+        pr->mem_size = pr->msg->len;
+      }
+    }
+    if ((size_t)(pr->msg->len) <= pr->read) {
+      facil_cluster_handle_msg(pr->msg);
+      pr->read = pr->read - pr->msg->len;
+      if (pr->read)
+        memcpy(pr->msg, (void *)((uintptr_t)pr->msg + pr->msg->len), pr->read);
+    }
+  }
+}
+
+/* Registers process specific information */
+static void facil_cluster_register(void *arg1, void *arg2) {
+  (void)arg1;
+  (void)arg2;
+  if (facil_cluster_data.count < 2)
+    return;
+  // for (size_t i = 0; i < facil_cluster_data.count; i++) {
+  //   if (i == (size_t)defer_fork_pid())
+  //     continue;
+  //   sock_close(facil_cluster_data.pipes[i].in);
+  // }
+  // sock_close(facil_cluster_data.pipes[defer_fork_pid()].out);
+  struct facil_cluster_protocol *pr = malloc(sizeof(*pr));
+  if (!pr)
+    perror("ERROR: (critical) cannot allocate memory for cluster."),
+        kill(0, SIGINT), exit(errno);
+  *pr = (struct facil_cluster_protocol){
+      .protocol.service = facil_cluster_protocol_id,
+      .protocol.on_data = facil_cluster_on_data,
+      .protocol.on_close = facil_cluster_on_close,
+      .protocol.ping = listener_ping,
+  };
+  pr->msg = calloc(1, 1024);
+  pr->mem_size = 1024;
+  if (!pr->msg)
+    perror("ERROR: (critical) cannot allocate memory for cluster."),
+        kill(0, SIGINT), exit(errno);
+  facil_attach(facil_cluster_data.pipes[defer_fork_pid()].in, &pr->protocol);
+}
+
+static void facil_cluster_init(uint16_t count) {
+  if (facil_cluster_data.pipes || count < 2)
+    return;
+  facil_cluster_data.pipes =
+      malloc((sizeof(struct facil_cluster_data_pipe) * count));
+  if (!facil_cluster_data.pipes)
+    goto error;
+
+  static protocol_s stub_protocol = {.service = NULL, .ping = listener_ping};
+  stub_protocol.service = facil_cluster_protocol_id;
+
+  facil_cluster_data.count = count;
+  int p_tmp[2];
+
+  for (size_t i = 0; i < count; i++) {
+    if (pipe(p_tmp))
+      goto error;
+    sock_set_non_block(p_tmp[0]);
+    sock_set_non_block(p_tmp[1]);
+    facil_cluster_data.pipes[i].in = sock_open(p_tmp[0]);
+    facil_cluster_data.pipes[i].out = sock_open(p_tmp[1]);
+    facil_attach(facil_cluster_data.pipes[i].in, &stub_protocol);
+    facil_attach(facil_cluster_data.pipes[i].out, &stub_protocol);
+  }
+  pubsub_cluster_init();
+  defer(facil_cluster_register, NULL, NULL);
+  return;
+error:
+  perror("ERROR: (facil.io) Couldn't initialize cluster pipes");
+  kill(0, SIGINT), exit(errno);
+}
+
+static void facil_cluster_destroy(void) {
+  if (!facil_cluster_data.pipes)
+    return;
+  for (size_t i = 0; i < facil_cluster_data.count; i++) {
+    sock_close(facil_cluster_data.pipes[i].out);
+    sock_close(facil_cluster_data.pipes[i].in);
+  }
+
+  fio_cluster_handler *hnd;
+  while ((hnd = fio_list_pop(fio_cluster_handler, list,
+                             facil_cluster_data.handlers)))
+    free(hnd);
+  free(facil_cluster_data.pipes);
+  facil_cluster_data.pipes = NULL;
+}
+
+void facil_cluster_set_handler(uint32_t msg_type,
+                               void (*on_message)(void *data, uint32_t len)) {
+  fio_cluster_handler *hnd;
+  spn_lock(&facil_cluster_data.lock);
+  fio_list_for_each(fio_cluster_handler, list, hnd,
+                    facil_cluster_data.handlers) {
+    if (hnd->msg_type == msg_type) {
+      hnd->on_message = on_message;
+      spn_unlock(&facil_cluster_data.lock);
+      return;
+    }
+  }
+  hnd = malloc(sizeof(*hnd));
+  *hnd = (fio_cluster_handler){.msg_type = msg_type, .on_message = on_message};
+  fio_list_push(fio_cluster_handler, list, facil_cluster_data.handlers, hnd);
+  spn_unlock(&facil_cluster_data.lock);
+}
+
+static void facil_msg_free(void *msg_) {
+  struct facil_cluster_msg_packet *msg = msg_;
+  spn_lock(&msg->lock);
+  msg->count--;
+  if (msg->count) {
+    spn_unlock(&msg->lock);
+    return;
+  }
+  free(msg);
+}
+int facil_cluster_send(uint32_t msg_type, void *data, uint32_t len) {
+  if (!defer_fork_is_active()) {
+#ifdef DEBUG
+    fprintf(stderr,
+            "WARNING: (debug, ignored) `facil_cluster_send` can only be "
+            "called while facil.io is running.\n");
+#endif
+    return -1;
+  }
+  if (facil_cluster_data.count < 2)
+    return 0;
+  if (!data || !len)
+    return -1;
+  struct facil_cluster_msg_packet *msg = malloc(len + sizeof(*msg));
+  if (!msg)
+    return -1;
+  msg->count = facil_cluster_data.count - 1;
+  msg->lock = SPN_LOCK_INIT;
+  msg->payload.len = len + sizeof(msg->payload);
+  msg->payload.msg_type = msg_type;
+  memcpy(msg->data, data, len);
+  for (int i = 0; i < (int)facil_cluster_data.count; i++) {
+    if (defer_fork_pid() == i)
+      continue;
+    if (sock_write2(.uuid = facil_cluster_data.pipes[i].out, .buffer = msg,
+                    .offset =
+                        ((uintptr_t) &
+                         (((struct facil_cluster_msg_packet *)(0))->payload)),
+                    .length = msg->payload.len, .move = 1,
+                    .dealloc = facil_msg_free))
+      perror("ERROR: Cluster `write` failed");
+  }
+  return 0;
+}
+
 /* *****************************************************************************
 Running the server
 ***************************************************************************** */
@@ -685,6 +949,7 @@ static void facil_cleanup(void *arg) {
   ((struct facil_run_args *)arg)->on_finish();
   defer_perform();
   evio_close();
+  facil_cluster_destroy();
 }
 
 #undef facil_run
@@ -707,6 +972,7 @@ void facil_run(struct facil_run_args args) {
     args.processes = 1;
   if (!args.threads)
     args.threads = 1;
+  facil_cluster_init(args.processes);
   if (FACIL_PRINT_STATE) {
     fprintf(stderr, "Server is running %u %s X %u %s, press ^C to stop\n",
             args.processes, args.processes > 1 ? "workers" : "worker",
@@ -747,8 +1013,11 @@ int facil_attach(intptr_t uuid, protocol_s *protocol) {
       protocol->on_shutdown = mock_on_ev;
     protocol->rsv = 0;
   }
-  if (!sock_isvalid(uuid))
+  if (!sock_isvalid(uuid)) {
+    if (protocol)
+      defer(deferred_on_close, protocol, NULL);
     return -1;
+  }
   spn_lock(&uuid_data(uuid).lock);
   protocol_s *old_protocol = uuid_data(uuid).protocol;
   uuid_data(uuid).protocol = protocol;
@@ -787,7 +1056,7 @@ time_t facil_last_tick(void) { return facil_data->last_cycle; }
  */
 protocol_s *facil_protocol_try_lock(intptr_t uuid,
                                     enum facil_protocol_lock_e type) {
-  if (sock_isvalid(uuid) || !uuid_data(uuid).protocol) {
+  if (!sock_isvalid(uuid) || !uuid_data(uuid).protocol) {
     errno = EBADF;
     return NULL;
   }

data/ext/iodine/facil.h

@@ -287,6 +287,8 @@ void facil_run(struct facil_run_args args);
  * The old protocol's `on_close` will be scheduled, if they both exist.
  *
  * Returns -1 on error and 0 on success.
+ *
+ * On error, the new protocol's `on_close` callback will be called.
  */
 int facil_attach(intptr_t uuid, protocol_s *protocol);
 
@@ -399,6 +401,37 @@ struct facil_each_args_s {
 int facil_each(struct facil_each_args_s args);
 #define facil_each(...) facil_each((struct facil_each_args_s){__VA_ARGS__})
 
+/* *****************************************************************************
+Cluster specific API - cluster messaging.
+***************************************************************************** */
+
+/**
+Sets a callback / handler for a message of type `msg_type`.
+
+Callbacks are invoked using an O(n) matching, where `n` is the number of
+registered callbacks.
+
+The `msg_type` value can be any number less than 1,073,741,824. All values
+starting at 1,073,741,824 are reserved for internal use.
+*/
+void facil_cluster_set_handler(uint32_t msg_type,
+                               void (*on_message)(void *data, uint32_t len));
+
+/** Sends a message of type `msg_type` to the **other** cluster processes.
+
+`msg_type` should match a message type used when calling
+`facil_cluster_set_handler` to set the appropriate callback.
+
+Unknown `msg_type` values are silently ignored.
+
+The `msg_type` value can be any number less than 1,073,741,824. All values
+starting at 1,073,741,824 are reserved for internal use.
+
+Callbacks are invoked using an O(n) matching, where `n` is the number of
+registered callbacks.
+*/
+int facil_cluster_send(uint32_t msg_type, void *data, uint32_t len);
+
 /* *****************************************************************************
 Lower Level API - for special circumstances, use with care under .
 ***************************************************************************** */

data/ext/iodine/fio_list.h

@@ -0,0 +1,84 @@
+/*
+Copyright: Boaz segev, 2016-2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#ifndef H_FACIL_IO_LIST_H
+/**
+A simple doubly linked list implementation... Doesn't do much, but does it well.
+*/
+#define H_FACIL_IO_LIST_H
+
+/** The data structure for a doubly linked list. */
+typedef struct fio_list_s {
+  struct fio_list_s *prev;
+  struct fio_list_s *next;
+} fio_list_s;
+
+/** An inline function that initializes a list's head. */
+static inline __attribute__((unused)) void fio_list_init(fio_list_s *list) {
+  *list = (fio_list_s){.next = list, .prev = list};
+}
+
+/** A macro that evaluates to an initialized list head. */
+#define FIO_LIST_INIT(name)                                                    \
+  (fio_list_s) { .next = &(name), .prev = &(name) }
+
+/** Adds a list reference to the list at the specified position. */
+static inline __attribute__((unused)) void fio_list_add(fio_list_s *pos,
+                                                        fio_list_s *item) {
+  /* prepare item */
+  item->next = pos->next;
+  item->prev = pos;
+  /* inject item only after preperation (in case of misuse or memory tearing) */
+  pos->next = item;
+  item->next->prev = item;
+}
+
+/** Removes a list reference from the list. Returns the same reference. */
+static inline __attribute__((unused)) fio_list_s *
+fio_list_remove(fio_list_s *item) {
+  item->next->prev = item->prev;
+  item->prev->next = item->next;
+  *item = (fio_list_s){.next = item, .prev = item};
+  return item;
+}
+
+/** Takes a list pointer and returns a pointer to it's container. */
+#define fio_list_object(type, member, plist)                                   \
+  ((type *)((uintptr_t)(plist) - (uintptr_t)(&(((type *)0)->member))))
+
+/** iterates the whole list. */
+#define fio_list_for_each(type, member, var, head)                             \
+  for (fio_list_s *pos = (head).next->next;                                    \
+       &((var) = fio_list_object(type, member, pos->prev))->member != &(head); \
+       (var) = fio_list_object(type, member, pos), pos = pos->next)
+
+/** Removes a member from the end of the list. */
+#define fio_list_pop(type, member, head)                                       \
+  (((head).prev == &(head))                                                    \
+       ? ((type *)(0x0))                                                       \
+       : (fio_list_object(type, member, fio_list_remove((head).prev))))
+
+/** Adds a member to the end of the list. */
+#define fio_list_push(type, member, head, pitem)                               \
+  fio_list_add((head).prev, &(pitem)->member)
+
+/** Removes a member from the beginning of the list. */
+#define fio_list_shift(type, member, head)                                     \
+  (((head).next == &(head))                                                    \
+       ? ((type *)(0x0))                                                       \
+       : (fio_list_object(type, member, fio_list_remove((head).next))))
+
+/** Adds a member to the beginning of the list. */
+#define fio_list_unshift(type, member, head, pitem)                            \
+  fio_list_add((head).next, &(pitem)->member)
+
+/** Tests if the list is empty. */
+#define fio_list_is_empty(head) ((head).next == &(head))
+
+/** Tests if the list is NOT empty. */
+#define fio_list_any(head) ((head).next != &(head))
+
+#endif

data/ext/iodine/http.c

@@ -9,6 +9,7 @@ Feel free to copy, use and enjoy according to the license provided.
 #include "http.h"
 #include "http1.h"
 
+#include <signal.h>
 #include <string.h>
 #include <strings.h>
 #include <time.h>
@@ -54,13 +55,13 @@ int http_listen(const char *port, const char *address,
     fprintf(
         stderr,
         "ERROR: http_listen requires the .on_request parameter to be set\n");
-    exit(11);
+    kill(0, SIGINT), exit(11);
   }
   http_on_open_func on_open_callback = http_get_on_open_func(&arg_settings);
   if (!on_open_callback) {
     fprintf(stderr, "ERROR: The requested HTTP protocol version isn't "
                     "supported at the moment.\n");
-    exit(11);
+    kill(0, SIGINT), exit(11);
   }
   http_settings_s *settings = malloc(sizeof(*settings));
   *settings = arg_settings;
@@ -258,6 +259,25 @@ size_t http_date2str(char *target, struct tm *tmbuf) {
                  return -1;                                                    \
                  0;                                                            \
                }))
+static inline int hex2byte(uint8_t *dest, const uint8_t *source) {
+  if (source[0] >= '0' && source[0] <= '9')
+    *dest = (source[0] - '0');
+  else if ((source[0] >= 'a' && source[0] <= 'f') ||
+           (source[0] >= 'A' && source[0] <= 'F'))
+    *dest = (source[0] | 32) - 87;
+  else
+    return -1;
+  *dest <<= 4;
+  if (source[1] >= '0' && source[1] <= '9')
+    *dest |= (source[1] - '0');
+  else if ((source[1] >= 'a' && source[1] <= 'f') ||
+           (source[1] >= 'A' && source[1] <= 'F'))
+    *dest |= (source[1] | 32) - 87;
+  else
+    return -1;
+  return 0;
+}
+#undef hex_val_tmp
 ssize_t http_decode_url(char *dest, const char *url_data, size_t length) {
   char *pos = dest;
   const char *end = url_data + length;
@@ -269,7 +289,9 @@ ssize_t http_decode_url(char *dest, const char *url_data, size_t length) {
     } else if (*url_data == '%') {
       // decode hex value
       // this is a percent encoded value.
-      *(pos++) = (hex_val(url_data[1]) << 4) | hex_val(url_data[2]);
+      if (hex2byte((uint8_t *)pos, (uint8_t *)&url_data[1]))
+        return -1;
+      pos++;
       url_data += 3;
     } else
       *(pos++) = *(url_data++);
@@ -288,7 +310,9 @@ ssize_t http_decode_url_unsafe(char *dest, const char *url_data) {
     } else if (*url_data == '%') {
       // decode hex value
       // this is a percent encoded value.
-      *(pos++) = (hex_val(url_data[1]) << 4) | hex_val(url_data[2]);
+      if (hex2byte((uint8_t *)pos, (uint8_t *)&url_data[1]))
+        return -1;
+      pos++;
       url_data += 3;
     } else
       *(pos++) = *(url_data++);

data/ext/iodine/http_request.c

@@ -7,6 +7,7 @@ Feel free to copy, use and enjoy according to the license provided.
 #include "http.h"
 #include "http1_request.h"
 
+#include <signal.h>
 /* *****************************************************************************
 Unsupported function placeholders
 ***************************************************************************** */
@@ -17,7 +18,7 @@ static void fail_destroy(http_request_s *req) {
   (void)req;
   fprintf(stderr, "ERROR: possible memory leak - request to be freed has "
                   "unsupported version.\n");
-  exit(9);
+  kill(0, SIGINT), exit(9);
 }
 
 static http_request_s *fail_dup(http_request_s *req) {

data/ext/iodine/iodine_core.c

@@ -616,11 +616,12 @@ static pthread_t sock_io_pthread;
 
 static void *iodine_io_thread(void *arg) {
   (void)arg;
+  struct timespec tm;
   // static const struct timespec tm = {.tv_nsec = 524288UL};
   while (sock_io_thread) {
     sock_flush_all();
-    throttle_thread(524288UL);
-    // nanosleep(&tm, NULL);
+    tm = (struct timespec){.tv_nsec = 524288UL, .tv_sec = 1};
+    nanosleep(&tm, NULL);
   }
   return NULL;
 }

data/ext/iodine/sock.c

@@ -354,7 +354,6 @@ static int sock_write_buffer(int fd, struct packet_s *packet) {
     fdinfo(fd).sent += written;
     if (fdinfo(fd).sent == packet->buffer.len)
       sock_packet_rotate_unsafe(fd);
-    return written;
   }
   return written;
 }
@@ -368,12 +367,8 @@ static int sock_write_buffer_ext(int fd, struct packet_s *packet) {
     fdinfo(fd).sent += written;
     if (fdinfo(fd).sent == packet->buffer.len)
       sock_packet_rotate_unsafe(fd);
-    return written;
   }
-  if (written < 0 && (errno == EWOULDBLOCK || errno == EAGAIN ||
-                      errno == EINTR || errno == ENOTCONN))
-    return 0;
-  return -1;
+  return written;
 }
 
 static void sock_free_buffer_ext(packet_s *packet) {
@@ -415,13 +410,13 @@ static int sock_write_from_fd(int fd, struct packet_s *packet) {
       goto read_error;
     count = fdinfo(fd).rw_hooks->write(fd2uuid(fd), ext->buffer, count);
   } while (count == BUFFER_FILE_READ_SIZE && packet->buffer.len);
-  if (count < 0)
-    return -1;
-  fdinfo(fd).sent += count;
-  packet->buffer.len -= count;
-  if (!packet->buffer.len) {
-    sock_packet_rotate_unsafe(fd);
-    return 1;
+  if (count >= 0) {
+    fdinfo(fd).sent += count;
+    packet->buffer.len -= count;
+    if (!packet->buffer.len) {
+      sock_packet_rotate_unsafe(fd);
+      return 1;
+    }
   }
   return count;
 
@@ -853,17 +848,21 @@ ssize_t sock_read(intptr_t uuid, void *buf, size_t count) {
     errno = EBADF;
     return -1;
   }
-  ssize_t ret = fdinfo(sock_uuid2fd(uuid)).rw_hooks->read(uuid, buf, count);
+  sock_rw_hook_s *rw = fdinfo(sock_uuid2fd(uuid)).rw_hooks;
   unlock_fd(sock_uuid2fd(uuid));
+  if (count == 0)
+    return rw->read(uuid, buf, count);
+  int old_errno = errno;
+  ssize_t ret = rw->read(uuid, buf, count);
   sock_touch(uuid);
   if (ret > 0)
     return ret;
   if (ret < 0 && (errno == EWOULDBLOCK || errno == EAGAIN || errno == EINTR ||
-                  errno == ENOTCONN))
+                  errno == ENOTCONN)) {
+    errno = old_errno;
     return 0;
-  int old_errno = errno;
+  }
   sock_force_close(uuid);
-  errno = ret ? old_errno : ECONNRESET;
   return -1;
 }
 
@@ -978,23 +977,29 @@ ssize_t sock_flush(intptr_t uuid) {
     return -1;
   ssize_t ret;
   lock_fd(fd);
+  sock_rw_hook_s *rw;
 retry:
-  while ((ret = fdinfo(fd).rw_hooks->flush(fd)) > 0)
+  rw = fdinfo(fd).rw_hooks;
+  unlock_fd(fd);
+  while ((ret = rw->flush(fd)) > 0)
     ;
   if (ret == -1) {
     if (errno == EINTR)
       goto retry;
-    if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ENOTCONN)
+    if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ENOTCONN ||
+        errno == ENOSPC)
       goto finish;
     goto error;
   }
+  lock_fd(fd);
   while (fdinfo(fd).packet && (ret = fdinfo(fd).packet->metadata.write_func(
                                    fd, fdinfo(fd).packet)) > 0)
     ;
   if (ret == -1) {
     if (errno == EINTR)
       goto retry;
-    if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ENOTCONN)
+    if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ENOTCONN ||
+        errno == ENOSPC)
       goto finish;
     goto error;
   }
@@ -1006,6 +1011,10 @@ finish:
   return 0;
 error:
   unlock_fd(fd);
+  // fprintf(stderr,
+  //         "ERROR: sock `write` failed"
+  //         " for %p with %d\n",
+  //         (void *)uuid, errno);
   sock_force_close(uuid);
   return -1;
 }
@@ -1047,6 +1056,10 @@ buffer.
 void sock_force_close(intptr_t uuid) {
   if (validate_uuid(uuid))
     return;
+  // fprintf(stderr,
+  //         "ERROR: `sock_force_close` called"
+  //         " for %p with errno %d\n",
+  //         (void *)uuid, errno);
   shutdown(sock_uuid2fd(uuid), SHUT_RDWR);
   close(sock_uuid2fd(uuid));
   clear_fd(sock_uuid2fd(uuid), 0);
@@ -1091,6 +1104,7 @@ ssize_t sock_buffer_send(intptr_t uuid, sock_buffer_s *buffer) {
     tmp = &(*tmp)->metadata.next;
   *tmp = packet;
   unlock_fd(fd);
+  defer(sock_flush_defer, (void *)uuid, NULL);
   return 0;
 }
 

data/ext/iodine/spnlock.inc

@@ -27,8 +27,8 @@ spinlock / sync for tasks
   }
 #define throttle_thread(micosec)                                               \
   {                                                                            \
-    const struct timespec tm = {.tv_nsec = (micosec),                          \
-                                .tv_sec = /* (micosec >> 20)*/ 1};             \
+    const struct timespec tm = {.tv_nsec = (micosec & 0xfffff),                \
+                                .tv_sec = (micosec >> 20)};                    \
     nanosleep(&tm, NULL);                                                      \
   }
 #else /* no effective rescheduling, just spin... */

data/ext/iodine/websockets.c

@@ -715,8 +715,6 @@ cleanup:
     // call the on_open callback
     if (settings.on_open)
       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;

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.3.5'.freeze
+  VERSION = '0.3.6'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.6
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-06-02 00:00:00.000000000 Z
+date: 2017-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -129,6 +129,7 @@ files:
 - ext/iodine/extconf.rb
 - ext/iodine/facil.c
 - ext/iodine/facil.h
+- ext/iodine/fio_list.h
 - ext/iodine/hex.c
 - ext/iodine/hex.h
 - ext/iodine/http.c