iodine 0.4.8 → 0.4.10

data/ext/iodine/http1_parser.h

@@ -14,8 +14,11 @@ This is an attempt to replace the existing HTTP/1.x parser with something easier
 to maintain and that could be used for an HTTP/1.x client as well.
 */
 #define H_HTTP1_PARSER_H
+#include <stddef.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <stdlib.h>
+#include <sys/types.h>
 
 #ifndef HTTP_HEADERS_LOWERCASE
 /** when defined, HTTP headers will be converted to lowercase and header
@@ -36,9 +39,9 @@ to maintain and that could be used for an HTTP/1.x client as well.
 typedef struct http1_parser_s {
   void *udata;
   struct http1_parser_protected_read_only_state_s {
-    size_t content_length;
-    size_t read;
-    uint8_t reserved;
+    ssize_t content_length; /* negative values indicate chuncked data state */
+    ssize_t read;           /* total number of bytes read so far (body only) */
+    uint8_t reserved;       /* for internal use */
   } state;
 } http1_parser_s;
 

data/ext/iodine/http1_response.c

@@ -160,7 +160,6 @@ static void http1_response_finalize_headers(http1_response_s *rs) {
       rs->response.last_modified = rs->response.date;
     else if (rs->response.date < rs->response.last_modified)
       rs->response.date = rs->response.last_modified;
-    struct tm t;
     /* date header */
     h1p_protected_copy(rs, "Date: ", 6);
     rs->buffer_end +=

data/ext/iodine/http_response.c

@@ -1669,7 +1669,7 @@ const char *http_response_ext2mime(const char *ext) {
   char *extlow = (void *)(&ext8byte);
   // change the copy to lowercase
   size_t pos = 0;
-  while (ext[pos] && pos < 8) {
+  while (pos < 8 && ext[pos]) {
     extlow[pos] =
         (ext[pos] >= 'A' && ext[pos] <= 'Z') ? (ext[pos] | 32) : ext[pos];
     ++pos;

data/ext/iodine/iodine.c

@@ -5,6 +5,7 @@
 #include "iodine_pubsub.h"
 #include "iodine_websockets.h"
 #include "rb-rack-io.h"
+#include <dlfcn.h>
 /*
 Copyright: Boaz segev, 2016-2017
 License: MIT
@@ -82,8 +83,11 @@ static VALUE iodine_run_after(VALUE self, VALUE milliseconds) {
   if (block == Qnil)
     return Qfalse;
   Registry.add(block);
-  facil_run_every(milli, 1, iodine_run_task, (void *)block,
-                  (void (*)(void *))Registry.remove);
+  if (facil_run_every(milli, 1, iodine_run_task, (void *)block,
+                      (void (*)(void *))Registry.remove) == -1) {
+    perror("ERROR: Iodine couldn't initialize timer");
+    return Qnil;
+  }
   return block;
 }
 /**
@@ -123,8 +127,11 @@ static VALUE iodine_run_every(int argc, VALUE *argv, VALUE self) {
   // requires a block to be passed
   rb_need_block();
   Registry.add(block);
-  facil_run_every(milli, repeat, iodine_run_task, (void *)block,
-                  (void (*)(void *))Registry.remove);
+  if (facil_run_every(milli, repeat, iodine_run_task, (void *)block,
+                      (void (*)(void *))Registry.remove) == -1) {
+    perror("ERROR: Iodine couldn't initialize timer");
+    return Qnil;
+  }
   return block;
 }
 
@@ -320,6 +327,13 @@ VALUE iodine_print_registry(VALUE self) {
   (void)self;
 }
 
+static void patch_env(void) {
+#ifdef __APPLE__
+  /* patch for dealing with the High Sierra `fork` limitations */
+  void *obj_c_runtime = dlopen("Foundation.framework/Foundation", RTLD_LAZY);
+#endif
+}
+
 /* *****************************************************************************
 Library Initialization
 ***************************************************************************** */
@@ -330,6 +344,8 @@ Library Initialization
 // Here we connect all the C code to the Ruby interface, completing the bridge
 // between Lib-Server and Ruby.
 void Init_iodine(void) {
+  // load any environment specific patches
+  patch_env();
   // initialize globally used IDs, for faster access to the Ruby layer.
   iodine_fd_var_id = rb_intern("scrtfd");
   iodine_call_proc_id = rb_intern("call");

data/ext/iodine/iodine_protocol.c

@@ -72,6 +72,7 @@ static VALUE not_implemented2(VALUE self, VALUE data) {
   return Qnil;
 }
 
+static VALUE dyn_read(int argc, VALUE *argv, VALUE self);
 /**
 A default on_data implementation will read up to 1Kb into a reusable buffer from
 the socket and call the `on_message` callback.
@@ -79,7 +80,6 @@ the socket and call the `on_message` callback.
 It is recommended that you implement this callback if messages might require
 more then 1Kb of space.
 */
-static VALUE dyn_read(int argc, VALUE *argv, VALUE self);
 static VALUE default_on_data(VALUE self) {
   VALUE buff = rb_ivar_get(self, iodine_buff_var_id);
   if (buff == Qnil) {
@@ -132,15 +132,16 @@ static VALUE dyn_run_each(VALUE self) {
 }
 
 /**
-Reads `n` bytes from the network connection.
+Reads up to `n` bytes from the network connection.
 The number of bytes to be read (n) is:
 - the number of bytes set in the optional `buffer_or_length` argument.
 - the String capacity (not length) of the String passed as the optional
   `buffer_or_length` argument.
 - 1024 Bytes (1Kb) if the optional `buffer_or_length` is either missing or
-  contains a String who's capacity is less then 1Kb.
+  contains a String with a capacity less then 1Kb.
 Returns a String (either the same one used as the buffer or a new one) on a
-successful read. Returns `nil` if no data was available.
+successful read.
+Returns `nil` if no data was available.
 */
 static VALUE dyn_read(int argc, VALUE *argv, VALUE self) {
   if (argc > 1) {

data/ext/iodine/iodine_pubsub.c

@@ -478,7 +478,7 @@ The function accepts a single argument (a Hash) and a required block.
 Accepts a single Hash argument with the following possible options:
 
 :engine :: If provided, the engine to use for pub/sub. Otherwise the default
-engine is used.
+        :: engine is used.
 
 :channel :: Required (unless :pattern). The channel to subscribe to.
 

data/ext/iodine/random.c

@@ -75,34 +75,34 @@ void bscrypt_rand_bytes(void *target, size_t length) {
   while (length > 64) {
     memcpy(target, sha2.digest.str, 64);
     length -= 64;
-    target += 64;
+    target = (void *)((uintptr_t)target + 64);
     bscrypt_sha2_write(&sha2, &cpu_state, sizeof(cpu_state));
     bscrypt_sha2_result(&sha2);
   }
   if (length > 32) {
     memcpy(target, sha2.digest.str, 32);
     length -= 32;
-    target += 32;
+    target = (void *)((uintptr_t)target + 32);
     bscrypt_sha2_write(&sha2, &cpu_state, sizeof(cpu_state));
     bscrypt_sha2_result(&sha2);
   }
   if (length > 16) {
     memcpy(target, sha2.digest.str, 16);
     length -= 16;
-    target += 16;
+    target = (void *)((uintptr_t)target + 16);
     bscrypt_sha2_write(&sha2, &cpu_state, sizeof(cpu_state));
     bscrypt_sha2_result(&sha2);
   }
   if (length > 8) {
     memcpy(target, sha2.digest.str, 8);
     length -= 8;
-    target += 8;
+    target = (void *)((uintptr_t)target + 8);
     bscrypt_sha2_write(&sha2, &cpu_state, sizeof(cpu_state));
     bscrypt_sha2_result(&sha2);
   }
   while (length) {
     *((uint8_t *)target) = sha2.digest.str[length];
-    ++target;
+    target = (void *)((uintptr_t)target + 1);
     --length;
   }
 }

data/ext/iodine/sha1.c

@@ -220,12 +220,12 @@ void bscrypt_sha1_write(sha1_s *s, const void *data, size_t len) {
   if (in_buffer) {
     memcpy(s->buffer + in_buffer, data, partial);
     len -= partial;
-    data += partial;
+    data = (void *)((uintptr_t)data + partial);
     perform_all_rounds(s, s->buffer);
   }
   while (len >= 64) {
     perform_all_rounds(s, data);
-    data += 64;
+    data = (void *)((uintptr_t)data + 64);
     len -= 64;
   }
   if (len) {
@@ -276,11 +276,8 @@ SHA-1 testing
 #include <time.h>
 
 // clang-format off
-#if defined(TEST_OPENSSL) && defined(__has_include)
-#  if __has_include(<openssl/sha.h>)
-#    include <openssl/sha.h>
-#    define HAS_OPEN_SSL 1
-#  endif
+#if defined(HAVE_OPENSSL)
+#  include <openssl/sha.h>
 #endif
 // clang-format on
 
@@ -326,7 +323,7 @@ void bscrypt_test_sha1(void) {
   }
   fprintf(stderr, " SHA-1 passed.\n");
 
-#ifdef HAS_OPEN_SSL
+#ifdef HAVE_OPENSSL
   fprintf(stderr, "===================================\n");
   fprintf(stderr, "bscrypt SHA-1 struct size: %lu\n", sizeof(sha1_s));
   fprintf(stderr, "OpenSSL SHA-1 struct size: %lu\n", sizeof(SHA_CTX));

data/ext/iodine/sha2.c

@@ -478,12 +478,12 @@ void bscrypt_sha2_write(sha2_s *s, const void *data, size_t len) {
     if (in_buffer) {
       memcpy(s->buffer + in_buffer, data, partial);
       len -= partial;
-      data += partial;
+      data = (void *)((uintptr_t)data + partial);
       perform_all_rounds(s, s->buffer);
     }
     while (len >= 128) {
       perform_all_rounds(s, data);
-      data += 128;
+      data = (void *)((uintptr_t)data + 128);
       len -= 128;
     }
     if (len) {
@@ -505,12 +505,12 @@ void bscrypt_sha2_write(sha2_s *s, const void *data, size_t len) {
   if (in_buffer) {
     memcpy(s->buffer + in_buffer, data, partial);
     len -= partial;
-    data += partial;
+    data = (void *)((uintptr_t)data + partial);
     perform_all_rounds(s, s->buffer);
   }
   while (len >= 64) {
     perform_all_rounds(s, data);
-    data += 64;
+    data = (void *)((uintptr_t)data + 64);
     len -= 64;
   }
   if (len) {
@@ -658,11 +658,8 @@ static char *sha2_variant_names[] = {
 };
 
 // clang-format off
-#if defined(TEST_OPENSSL) && defined(__has_include)
-#  if __has_include(<openssl/sha.h>)
-#    include <openssl/sha.h>
-#    define HAS_OPEN_SSL 1
-#  endif
+#if defined(HAVE_OPENSSL)
+#  include <openssl/sha.h>
 #endif
 // clang-format on
 
@@ -761,7 +758,7 @@ void bscrypt_test_sha2(void) {
 
   fprintf(stderr, " SHA-2 passed.\n");
 
-#ifdef HAS_OPEN_SSL
+#ifdef HAVE_OPENSSL
   fprintf(stderr, "===================================\n");
   fprintf(stderr, "bscrypt SHA-2 struct size: %lu\n", sizeof(sha2_s));
   fprintf(stderr, "OpenSSL SHA-2/256 struct size: %lu\n", sizeof(SHA256_CTX));
@@ -812,7 +809,7 @@ void bscrypt_test_sha2(void) {
 #endif
 
   return;
-  goto error;
+
 error:
   fprintf(stderr,
           ":\n--- bscrypt SHA-2 Test FAILED!\ntype: "

data/ext/iodine/sha2.h

@@ -96,7 +96,7 @@ An SHA2 helper function that performs initialiation, writing and finalizing.
 Uses the SHA2 512 variant.
 */
 static inline UNUSED_FUNC char *bscrypt_sha2_512(sha2_s *s, const void *data,
-                                              size_t len) {
+                                                 size_t len) {
   *s = bscrypt_sha2_init(SHA_512);
   bscrypt_sha2_write(s, data, len);
   return bscrypt_sha2_result(s);
@@ -107,7 +107,7 @@ An SHA2 helper function that performs initialiation, writing and finalizing.
 Uses the SHA2 256 variant.
 */
 static inline UNUSED_FUNC char *bscrypt_sha2_256(sha2_s *s, const void *data,
-                                              size_t len) {
+                                                 size_t len) {
   *s = bscrypt_sha2_init(SHA_256);
   bscrypt_sha2_write(s, data, len);
   return bscrypt_sha2_result(s);
@@ -118,7 +118,7 @@ An SHA2 helper function that performs initialiation, writing and finalizing.
 Uses the SHA2 384 variant.
 */
 static inline UNUSED_FUNC char *bscrypt_sha2_384(sha2_s *s, const void *data,
-                                              size_t len) {
+                                                 size_t len) {
   *s = bscrypt_sha2_init(SHA_384);
   bscrypt_sha2_write(s, data, len);
   return bscrypt_sha2_result(s);

data/ext/iodine/sock.c

@@ -133,7 +133,7 @@ static inline void sock_packet_free(packet_s *packet) {
 }
 
 static inline packet_s *sock_packet_try_grab(void) {
-  packet_s *packet = NULL;
+  packet_s *packet;
   spn_lock(&packet_pool.lock);
   packet = packet_pool.next;
   if (packet == NULL)
@@ -236,7 +236,6 @@ struct fd_data_s {
 
 static struct sock_data_store {
   size_t capacity;
-  uint8_t exit_init;
   struct fd_data_s *fds;
 } sock_data_store;
 
@@ -270,40 +269,39 @@ static inline int initialize_sock_lib(size_t capacity) {
     return 0;
   struct fd_data_s *new_collection =
       realloc(sock_data_store.fds, sizeof(struct fd_data_s) * capacity);
-  if (new_collection) {
-    sock_data_store.fds = new_collection;
-    for (size_t i = sock_data_store.capacity; i < capacity; i++) {
-      fdinfo(i) =
-          (struct fd_data_s){.open = 0,
-                             .lock = SPN_LOCK_INIT,
-                             .rw_hooks = (sock_rw_hook_s *)&SOCK_DEFAULT_HOOKS,
-                             .counter = 0};
-    }
-    sock_data_store.capacity = capacity;
+  if (!new_collection)
+    return -1;
+  sock_data_store.fds = new_collection;
+  for (size_t i = sock_data_store.capacity; i < capacity; i++) {
+    fdinfo(i) =
+        (struct fd_data_s){.open = 0,
+                           .lock = SPN_LOCK_INIT,
+                           .rw_hooks = (sock_rw_hook_s *)&SOCK_DEFAULT_HOOKS,
+                           .counter = 0};
+  }
+  sock_data_store.capacity = capacity;
 
 #ifdef DEBUG
-    fprintf(stderr,
-            "\nInitialized libsock for %lu sockets, "
-            "each one requires %lu bytes.\n"
-            "overall ovearhead: %lu bytes.\n"
-            "Initialized packet pool for %d elements, "
-            "each one %lu bytes.\n"
-            "overall buffer ovearhead: %lu bytes.\n"
-            "=== Socket Library Total: %lu bytes ===\n\n",
-            capacity, sizeof(struct fd_data_s),
-            sizeof(struct fd_data_s) * capacity, BUFFER_PACKET_POOL,
-            sizeof(packet_s), sizeof(packet_s) * BUFFER_PACKET_POOL,
-            (sizeof(packet_s) * BUFFER_PACKET_POOL) +
-                (sizeof(struct fd_data_s) * capacity));
+  fprintf(stderr,
+          "\nInitialized libsock for %lu sockets, "
+          "each one requires %lu bytes.\n"
+          "overall ovearhead: %lu bytes.\n"
+          "Initialized packet pool for %d elements, "
+          "each one %lu bytes.\n"
+          "overall buffer ovearhead: %lu bytes.\n"
+          "=== Socket Library Total: %lu bytes ===\n\n",
+          capacity, sizeof(struct fd_data_s),
+          sizeof(struct fd_data_s) * capacity, BUFFER_PACKET_POOL,
+          sizeof(packet_s), sizeof(packet_s) * BUFFER_PACKET_POOL,
+          (sizeof(packet_s) * BUFFER_PACKET_POOL) +
+              (sizeof(struct fd_data_s) * capacity));
 #endif
 
-    if (init_exit)
-      return 0;
-    init_exit = 1;
-    atexit(clear_sock_lib);
+  if (init_exit)
     return 0;
-  }
-  return -1;
+  init_exit = 1;
+  atexit(clear_sock_lib);
+  return 0;
 }
 
 static inline int clear_fd(uintptr_t fd, uint8_t is_open) {

data/ext/iodine/websocket_parser.h

@@ -0,0 +1,428 @@
+/*
+copyright: Boaz Segev, 2017
+license: MIT
+
+Feel free to copy, use and enjoy according to the license specified.
+*/
+#ifndef H_WEBSOCKET_PARSER_H
+/**\file
+
+A single file Websocket message parser and Websocket message wrapper, decoupled
+from any IO layer.
+
+Notice that this header file library includes static funnction declerations that
+must be implemented by the including file (the callbacks).
+
+*/
+#define H_WEBSOCKET_PARSER_H
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+/* *****************************************************************************
+API - Internal Helpers
+***************************************************************************** */
+
+/** used internally to mask and unmask client messages. */
+inline static void websocket_xmask(void *msg, uint64_t len, uint32_t mask);
+
+/* *****************************************************************************
+API - Message Wrapping
+***************************************************************************** */
+
+/** returns the length of the buffer required to wrap a message `len` long */
+static inline __attribute__((unused)) uint64_t
+websocket_wrapped_len(uint64_t len);
+
+/**
+ * Wraps a Websocket server message and writes it to the target buffer.
+ *
+ * The `first` and `last` flags can be used to support message fragmentation.
+ *
+ * * target: the target buffer to write to.
+ * * msg:    the message to be wrapped.
+ * * len:    the message length.
+ * * opcode: set to 1 for UTF-8 message, 2 for binary, etc'.
+ * * first:  set to 1 if `msg` points the begining of the message.
+ * * last:   set to 1 if `msg + len` ends the message.
+ * * client: set to 1 to use client mode (data  masking).
+ *
+ * Further opcode values:
+ * * %x0 denotes a continuation frame
+ * *  %x1 denotes a text frame
+ * *  %x2 denotes a binary frame
+ * *  %x3-7 are reserved for further non-control frames
+ * *  %x8 denotes a connection close
+ * *  %x9 denotes a ping
+ * *  %xA denotes a pong
+ * *  %xB-F are reserved for further control frames
+ *
+ * Returns the number of bytes written. Always `websocket_wrapped_len(len)`
+ */
+inline static uint64_t __attribute__((unused))
+websocket_server_wrap(void *target, void *msg, uint64_t len,
+                      unsigned char opcode, unsigned char first,
+                      unsigned char last, unsigned char rsv);
+
+/**
+ * Wraps a Websocket client message and writes it to the target buffer.
+ *
+ * The `first` and `last` flags can be used to support message fragmentation.
+ *
+ * * target: the target buffer to write to.
+ * * msg:    the message to be wrapped.
+ * * len:    the message length.
+ * * opcode: set to 1 for UTF-8 message, 2 for binary, etc'.
+ * * first:  set to 1 if `msg` points the begining of the message.
+ * * last:   set to 1 if `msg + len` ends the message.
+ * * client: set to 1 to use client mode (data  masking).
+ *
+ * Returns the number of bytes written. Always `websocket_wrapped_len(len) + 4`
+ */
+inline static __attribute__((unused)) uint64_t
+websocket_client_wrap(void *target, void *msg, uint64_t len,
+                      unsigned char opcode, unsigned char first,
+                      unsigned char last, unsigned char rsv);
+
+/* *****************************************************************************
+Callbacks - Required functions that must be inplemented to use this header
+***************************************************************************** */
+
+static void websocket_on_unwrapped(void *udata, void *msg, uint64_t len,
+                                   char first, char last, char text,
+                                   unsigned char rsv);
+static void websocket_on_protocol_ping(void *udata, void *msg, uint64_t len);
+static void websocket_on_protocol_pong(void *udata, void *msg, uint64_t len);
+static void websocket_on_protocol_close(void *udata);
+static void websocket_on_protocol_error(void *udata);
+
+/* *****************************************************************************
+API - Parsing (unwrapping)
+***************************************************************************** */
+
+/** the returned value for `websocket_buffer_required` */
+struct websocket_packet_info_s {
+  /** the expected packet length */
+  uint64_t packet_length;
+  /** the packet's "head" size (before the data) */
+  uint8_t head_length;
+  /** a flag indicating if the packet is masked */
+  uint8_t masked;
+};
+
+/**
+ * Returns all known information regarding the upcoming message.
+ *
+ * @returns a struct websocket_packet_info_s.
+ *
+ * On protocol error, the `head_length` value is 0 (no valid head detected).
+ */
+inline static struct websocket_packet_info_s
+websocket_buffer_peek(void *buffer, uint64_t len);
+
+/**
+ * Consumes the data in the buffer, calling any callbacks required.
+ *
+ * Returns the remaining data in the existing buffer (can be 0).
+ *
+ * Notice: if there's any remaining data in the buffer, `memmove` is used to
+ * place the data at the begining of the buffer.
+ */
+inline static __attribute__((unused)) uint64_t
+websocket_consume(void *buffer, uint64_t len, void *udata,
+                  uint8_t require_masking);
+
+/* *****************************************************************************
+
+                                Implementation
+
+***************************************************************************** */
+
+/* *****************************************************************************
+Message masking
+***************************************************************************** */
+/** used internally to mask and unmask client messages. */
+void websocket_xmask(void *msg, uint64_t len, uint32_t mask) {
+  const uint64_t xmask = (((uint64_t)mask) << 32) | mask;
+  while (len >= 8) {
+    *((uint64_t *)msg) ^= xmask;
+    len -= 8;
+    msg = (void *)((uintptr_t)msg + 8);
+  }
+  switch (len) {
+  case 7:
+    ((uint8_t *)msg)[6] ^= ((uint8_t *)(&mask))[2];
+  /* fallthrough */
+  case 6:
+    ((uint8_t *)msg)[5] ^= ((uint8_t *)(&mask))[1];
+  /* fallthrough */
+  case 5:
+    ((uint8_t *)msg)[4] ^= ((uint8_t *)(&mask))[0];
+  /* fallthrough */
+  case 4:
+    ((uint8_t *)msg)[3] ^= ((uint8_t *)(&mask))[3];
+  /* fallthrough */
+  case 3:
+    ((uint8_t *)msg)[2] ^= ((uint8_t *)(&mask))[2];
+  /* fallthrough */
+  case 2:
+    ((uint8_t *)msg)[1] ^= ((uint8_t *)(&mask))[1];
+  /* fallthrough */
+  case 1:
+    ((uint8_t *)msg)[0] ^= ((uint8_t *)(&mask))[0];
+    /* fallthrough */
+  }
+}
+
+/* *****************************************************************************
+Message wrapping
+***************************************************************************** */
+
+// clang-format off
+#if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
+#   if defined(__has_include)
+#     if __has_include(<endian.h>)
+#      include <endian.h>
+#     elif __has_include(<sys/endian.h>)
+#      include <sys/endian.h>
+#     endif
+#   endif
+#   if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) && \
+                __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#      define __BIG_ENDIAN__
+#   endif
+#endif
+// clang-format on
+
+#ifdef __BIG_ENDIAN__
+/** stub byte swap 64 bit integer */
+#define netiswap64(i) (i)
+/** stub byte swap 16 bit integer */
+#define netiswap16(i) (i)
+
+#else
+// TODO: check for __builtin_bswap64
+/** byte swap 64 bit integer */
+#define netiswap64(i)                                                          \
+  ((((i)&0xFFULL) << 56) | (((i)&0xFF00ULL) << 40) |                           \
+   (((i)&0xFF0000ULL) << 24) | (((i)&0xFF000000ULL) << 8) |                    \
+   (((i)&0xFF00000000ULL) >> 8) | (((i)&0xFF0000000000ULL) >> 24) |            \
+   (((i)&0xFF000000000000ULL) >> 40) | (((i)&0xFF00000000000000ULL) >> 56))
+/** byte swap 16 bit integer */
+#define netiswap16(i) ((((i)&0x00ff) << 8) | (((i)&0xff00) >> 8))
+
+#endif
+
+/** returns the length of the buffer required to wrap a message `len` long */
+static inline uint64_t websocket_wrapped_len(uint64_t len) {
+  if (len < 126)
+    return len + 2;
+  if (len < (1UL << 16))
+    return len + 4;
+  return len + 10;
+}
+
+/**
+ * Wraps a Websocket server message and writes it to the target buffer.
+ *
+ * The `first` and `last` flags can be used to support message fragmentation.
+ *
+ * * target: the target buffer to write to.
+ * * msg:    the message to be wrapped.
+ * * len:    the message length.
+ * * opcode: set to 1 for UTF-8 message, 2 for binary, etc'.
+ * * first:  set to 1 if `msg` points the begining of the message.
+ * * last:   set to 1 if `msg + len` ends the message.
+ * * client: set to 1 to use client mode (data  masking).
+ *
+ * Further opcode values:
+ * * %x0 denotes a continuation frame
+ * *  %x1 denotes a text frame
+ * *  %x2 denotes a binary frame
+ * *  %x3-7 are reserved for further non-control frames
+ * *  %x8 denotes a connection close
+ * *  %x9 denotes a ping
+ * *  %xA denotes a pong
+ * *  %xB-F are reserved for further control frames
+ *
+ * Returns the number of bytes written. Always `websocket_wrapped_len(len)`
+ */
+static uint64_t websocket_server_wrap(void *target, void *msg, uint64_t len,
+                                      unsigned char opcode, unsigned char first,
+                                      unsigned char last, unsigned char rsv) {
+  ((uint8_t *)target)[0] = 0 |
+                           /* opcode */ (((first ? opcode : 0) & 15)) |
+                           /* rsv */ ((rsv & 7) << 4) |
+                           /*fin*/ ((last & 1) << 7);
+  if (len < 126) {
+    ((uint8_t *)target)[1] = len;
+    memcpy(((uint8_t *)target) + 2, msg, len);
+    return len + 2;
+  } else if (len < (1UL << 16)) {
+    /* head is 4 bytes */
+    ((uint8_t *)target)[1] = 126;
+    ((uint16_t *)target)[1] = netiswap16(len);
+    memcpy((uint8_t *)target + 4, msg, len);
+    return len + 4;
+  }
+  /* Really Long Message  */
+  ((uint8_t *)target)[1] = 127;
+  ((uint64_t *)((uint8_t *)target + 2))[0] = netiswap64(len);
+  memcpy((uint8_t *)target + 10, msg, len);
+  return len + 10;
+}
+
+/**
+ * Wraps a Websocket client message and writes it to the target buffer.
+ *
+ * The `first` and `last` flags can be used to support message fragmentation.
+ *
+ * * target: the target buffer to write to.
+ * * msg:    the message to be wrapped.
+ * * len:    the message length.
+ * * opcode: set to 1 for UTF-8 message, 2 for binary, etc'.
+ * * first:  set to 1 if `msg` points the begining of the message.
+ * * last:   set to 1 if `msg + len` ends the message.
+ *
+ * Returns the number of bytes written. Always `websocket_wrapped_len(len) + 4`
+ */
+static uint64_t websocket_client_wrap(void *target, void *msg, uint64_t len,
+                                      unsigned char opcode, unsigned char first,
+                                      unsigned char last, unsigned char rsv) {
+  uint32_t mask = rand() + 0x01020408;
+  ((uint8_t *)target)[0] = 0 |
+                           /* opcode */ (((first ? opcode : 0) & 15)) |
+                           /* rsv */ ((rsv & 7) << 4) |
+                           /*fin*/ ((last & 1) << 7);
+  if (len < 126) {
+    ((uint8_t *)target)[1] = len | 128;
+    ((uint32_t *)((uint8_t *)target + 2))[0] = mask;
+    memcpy(((uint8_t *)target) + 6, msg, len);
+    websocket_xmask((uint8_t *)target + 6, len, mask);
+    return len + 6;
+  } else if (len < (1UL << 16)) {
+    /* head is 4 bytes */
+    ((uint8_t *)target)[1] = 126 | 128;
+    ((uint16_t *)target)[1] = netiswap16(len);
+    ((uint32_t *)((uint8_t *)target + 4))[0] = mask;
+    memcpy((uint8_t *)target + 8, msg, len);
+    websocket_xmask((uint8_t *)target + 8, len, mask);
+    return len + 8;
+  }
+  /* Really Long Message  */
+  ((uint8_t *)target)[1] = 255;
+  ((uint64_t *)((uint8_t *)target + 2))[0] = netiswap64(len);
+  ((uint32_t *)((uint8_t *)target + 10))[0] = mask;
+  memcpy((uint8_t *)target + 14, msg, len);
+  websocket_xmask((uint8_t *)target + 14, len, mask);
+  return len + 14;
+}
+
+/* *****************************************************************************
+Message unwrapping
+***************************************************************************** */
+
+/**
+ * Returns all known information regarding the upcoming message.
+ *
+ * @returns a struct websocket_packet_info_s.
+ *
+ * On protocol error, the `head_length` value is 0 (no valid head detected).
+ */
+inline static struct websocket_packet_info_s
+websocket_buffer_peek(void *buffer, uint64_t len) {
+  if (len < 2)
+    return (struct websocket_packet_info_s){0, 2, 0};
+  const uint8_t mask_f = (((uint8_t *)buffer)[1] >> 7) & 1;
+  const uint8_t mask_l = (mask_f << 2);
+  uint8_t len_indicator = (((uint8_t *)buffer)[1] & 127);
+  if (len < 126)
+    return (struct websocket_packet_info_s){len_indicator,
+                                            (uint8_t)(2 + mask_l), mask_f};
+  switch (len_indicator) {
+  case 126:
+    if (len < 4)
+      return (struct websocket_packet_info_s){0, (uint8_t)(4 + mask_l), mask_f};
+    return (struct websocket_packet_info_s){
+        (uint64_t)netiswap16(((uint16_t *)buffer)[1]), (uint8_t)(4 + mask_l),
+        mask_f};
+  case 127:
+    if (len < 10)
+      return (struct websocket_packet_info_s){0, (uint8_t)(10 + mask_l),
+                                              mask_f};
+    return (struct websocket_packet_info_s){
+        netiswap64(((uint64_t *)((uint8_t *)buffer + 2))[0]),
+        (uint8_t)(10 + mask_l), mask_f};
+  default:
+    return (struct websocket_packet_info_s){0, 0, 0};
+  }
+}
+
+/**
+ * Consumes the data in the buffer, calling any callbacks required.
+ *
+ * Returns the remaining data in the existing buffer (can be 0).
+ */
+static uint64_t websocket_consume(void *buffer, uint64_t len, void *udata,
+                                  uint8_t require_masking) {
+  struct websocket_packet_info_s info = websocket_buffer_peek(buffer, len);
+  if (info.head_length + info.packet_length > len)
+    return len;
+  uint64_t reminder = len;
+  uint8_t *pos = (uint8_t *)buffer;
+  while (info.head_length + info.packet_length <= reminder) {
+    /* parse head */
+    void *payload = (void *)(pos + info.head_length);
+    /* unmask? */
+    if (info.masked) {
+      /* masked */
+      const uint32_t mask = ((uint32_t *)payload)[-1];
+      websocket_xmask(payload, info.packet_length, mask);
+    } else if (require_masking) {
+      /* error */
+      websocket_on_protocol_error(udata);
+    }
+    /* call callback */
+    switch (pos[0] & 15) {
+    case 0:
+      /* continuation frame */
+      websocket_on_unwrapped(udata, payload, info.packet_length, 0,
+                             ((pos[0] >> 7) & 1), 0, ((pos[0] >> 4) & 7));
+      break;
+    case 1:
+      /* text frame */
+      websocket_on_unwrapped(udata, payload, info.packet_length, 1,
+                             ((pos[0] >> 7) & 1), 1, ((pos[0] >> 4) & 7));
+      break;
+    case 2:
+      /* data frame */
+      websocket_on_unwrapped(udata, payload, info.packet_length, 1,
+                             ((pos[0] >> 7) & 1), 0, ((pos[0] >> 4) & 7));
+      break;
+    case 8:
+      /* close frame */
+      websocket_on_protocol_close(udata);
+      break;
+    case 9:
+      /* ping frame */
+      websocket_on_protocol_ping(udata, payload, info.packet_length);
+      break;
+    case 10:
+      /* pong frame */
+      websocket_on_protocol_pong(udata, payload, info.packet_length);
+      break;
+    default:
+      websocket_on_protocol_error(udata);
+    }
+    /* step forward */
+    reminder -= info.head_length + info.packet_length;
+    pos += info.head_length + info.packet_length;
+    info = websocket_buffer_peek(pos, reminder);
+  }
+  /* reset buffer state - support pipelining */
+  if (!reminder)
+    return 0;
+  memmove(buffer, (uint8_t *)buffer + len - reminder, reminder);
+  return reminder;
+}
+
+#endif