iodine 0.2.7 → 0.2.8

data/ext/iodine/misc.c

@@ -1,7 +1,7 @@
 /*
-(un)copyright: Boaz segev, 2016
-License: Public Domain except for any non-public-domain algorithms, which are
-subject to their own licenses.
+Copyright: Boaz segev, 2016-2017
+License: MIT except for any non-public-domain algorithms (none that I'm aware
+of), which might be subject to their own licenses.
 
 Feel free to copy, use and enjoy in accordance with to the license(s).
 */
@@ -14,12 +14,12 @@ Other helper functions
 */
 
 #ifdef HAS_UNIX_FEATURES
+#include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
-#include <errno.h>
-#include <unistd.h>
-#include <sys/types.h>
 #include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 /**
 Allocates memory and dumps the whole file into the memory allocated.
@@ -32,10 +32,10 @@ container pointer to NULL.
 This function has some Unix specific properties that resolve links and user
 folder referencing.
 */
-fdump_s* bscrypt_fdump(const char* file_path, size_t size_limit) {
+fdump_s *bscrypt_fdump(const char *file_path, size_t size_limit) {
   struct stat f_data;
   int file = -1;
-  fdump_s* container = NULL;
+  fdump_s *container = NULL;
   size_t file_path_len;
   if (file_path == NULL || (file_path_len = strlen(file_path)) == 0 ||
       file_path_len > PATH_MAX)
@@ -82,14 +82,14 @@ See the libc `gmtime_r` documentation for details.
 
 Falls back to `gmtime_r` for dates before epoch.
 */
-struct tm* bscrypt_gmtime(const time_t* timer, struct tm* tmbuf) {
+struct tm *bscrypt_gmtime(const time_t *timer, struct tm *tmbuf) {
   // static char* DAYS[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
   // static char * Months = {  "Jan", "Feb", "Mar", "Apr", "May", "Jun",
   // "Jul",
   // "Aug", "Sep", "Oct", "Nov", "Dec"};
   static uint8_t month_len[] = {
-      31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,  // nonleap year
-      31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31   // leap year
+      31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, // nonleap year
+      31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31  // leap year
   };
   if (*timer < 0)
     return gmtime_r(timer, tmbuf);
@@ -97,7 +97,7 @@ struct tm* bscrypt_gmtime(const time_t* timer, struct tm* tmbuf) {
   tmbuf->tm_gmtoff = 0;
   tmbuf->tm_zone = "UTC";
   tmbuf->tm_isdst = 0;
-  tmbuf->tm_year = 70;  // tm_year == The number of years since 1900
+  tmbuf->tm_year = 70; // tm_year == The number of years since 1900
   tmbuf->tm_mon = 0;
   // for seconds up to weekdays, we build up, as small values clean up larger
   // values.
@@ -122,7 +122,7 @@ struct tm* bscrypt_gmtime(const time_t* timer, struct tm* tmbuf) {
     tmbuf->tm_year += 100;
     tmp -= DAYS_PER_100_YEARS;
     if (((tmbuf->tm_year / 100) & 3) ==
-        0)  // leap century divisable by 400 => add leap
+        0) // leap century divisable by 400 => add leap
       --tmp;
   }
 #undef DAYS_PER_100_YEARS
@@ -147,7 +147,7 @@ struct tm* bscrypt_gmtime(const time_t* timer, struct tm* tmbuf) {
   while (tmp >= 365) {
     tmbuf->tm_year += 1;
     tmp -= 365;
-    if ((tmbuf->tm_year & 3) == 0) {  // leap year
+    if ((tmbuf->tm_year & 3) == 0) { // leap year
       if (tmp > 0) {
         --tmp;
         continue;

data/ext/iodine/misc.h

@@ -1,7 +1,7 @@
 /*
-(un)copyright: Boaz segev, 2016
-License: Public Domain except for any non-public-domain algorithms, which are
-subject to their own licenses.
+Copyright: Boaz segev, 2016-2017
+License: MIT except for any non-public-domain algorithms (none that I'm aware
+of), which might be subject to their own licenses.
 
 Feel free to copy, use and enjoy in accordance with to the license(s).
 */

data/ext/iodine/random.c

@@ -1,7 +1,7 @@
 /*
-(un)copyright: Boaz segev, 2016
-License: Public Domain except for any non-public-domain algorithms, which are
-subject to their own licenses.
+Copyright: Boaz segev, 2016-2017
+License: MIT except for any non-public-domain algorithms (none that I'm aware
+of), which might be subject to their own licenses.
 
 Feel free to copy, use and enjoy in accordance with to the license(s).
 */
@@ -11,8 +11,8 @@ Feel free to copy, use and enjoy in accordance with to the license(s).
 #include "random.h"
 
 #if defined(USE_ALT_RANDOM) || !defined(HAS_UNIX_FEATURES)
-#include <time.h>
 #include "sha2.h"
+#include <time.h>
 uint32_t bscrypt_rand32(void) {
   bits256_u pseudo = bscrypt_rand256();
   return pseudo.ints[3];
@@ -96,10 +96,10 @@ void bscrypt_rand_bytes(void *target, size_t length) {
 /* ***************************************************************************
 Unix Random Engine (use built in machine)
 */
-#include <fcntl.h>
 #include <errno.h>
-#include <unistd.h>
+#include <fcntl.h>
 #include <pthread.h>
+#include <unistd.h>
 
 /* ***************************************************************************
 Machine specific changes

data/ext/iodine/random.h

@@ -1,7 +1,7 @@
 /*
-(un)copyright: Boaz segev, 2016
-License: Public Domain except for any non-public-domain algorithms, which are
-subject to their own licenses.
+Copyright: Boaz segev, 2016-2017
+License: MIT except for any non-public-domain algorithms (none that I'm aware
+of), which might be subject to their own licenses.
 
 Feel free to copy, use and enjoy in accordance with to the license(s).
 */

data/ext/iodine/rb-call.c

@@ -1,3 +1,9 @@
+/*
+Copyright: Boaz segev, 2016-2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
 #include "rb-call.h"
 #include <pthread.h>
 #include <ruby.h>

data/ext/iodine/rb-call.h

@@ -1,6 +1,6 @@
 /*
-copyright: Boaz segev, 2016
-license: MIT
+Copyright: Boaz segev, 2016-2017
+License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
 */

data/ext/iodine/rb-libasync.h

@@ -1,14 +1,16 @@
 /*
-copyright: Boaz segev, 2016
-license: MIT
+Copyright: Boaz segev, 2016-2017
+License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
 */
 #ifndef RB_ASYNC_EXT_H
 #define RB_ASYNC_EXT_H
+// clang-format off
+#include "rb-registry.h"
 #include <ruby.h>
 #include <ruby/thread.h>
-#include "rb-registry.h"
+// clang-format on
 
 /******************************************************************************
 Portability - used to help port this to different frameworks (i.e. Ruby).

data/ext/iodine/rb-rack-io.c

@@ -1,9 +1,21 @@
+/*
+Copyright: Boaz segev, 2016-2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+// clang-format off
 #include "rb-rack-io.h"
-#include "rb-call.h"
 #include "iodine_core.h"
-#include <ruby/encoding.h>
-#include <ruby/io.h>
 #include <ruby/io.h>
+#include <ruby/encoding.h>
+#include <unistd.h>
+// clang-format on
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include "rb-call.h"
 
 /* RackIO manages a minimal interface to act as an IO wrapper according to
 these Rack specifications:

data/ext/iodine/rb-rack-io.h

@@ -1,12 +1,15 @@
 /*
-copyright: Boaz segev, 2016
-license: MIT
+Copyright: Boaz segev, 2016-2017
+License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
 */
 #ifndef RUBY_RACK_IO_H
 #define RUBY_RACK_IO_H
+// clang-format off
 #include <ruby.h>
+// clang-format on
+
 #include "http_request.h"
 
 extern struct _RackIO_ {

data/ext/iodine/rb-registry.c

@@ -1,3 +1,9 @@
+/*
+Copyright: Boaz segev, 2016-2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
 #include "rb-registry.h"
 #include "spnlock.h"
 #include <ruby.h>

data/ext/iodine/rb-registry.h

@@ -1,6 +1,6 @@
 /*
-copyright: Boaz segev, 2016
-license: MIT
+Copyright: Boaz segev, 2016-2017
+License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
 */

data/ext/iodine/sha1.c

@@ -1,7 +1,7 @@
 /*
-(un)copyright: Boaz segev, 2016
-License: Public Domain except for any non-public-domain algorithms, which are
-subject to their own licenses.
+Copyright: Boaz segev, 2016-2017
+License: MIT except for any non-public-domain algorithms (none that I'm aware
+of), which might be subject to their own licenses.
 
 Feel free to copy, use and enjoy in accordance with to the license(s).
 */
@@ -276,9 +276,11 @@ SHA-1 testing
 #include <time.h>
 
 // clang-format off
-#if defined(TEST_OPENSSL) && defined(__has_include) && __has_include(<openssl/sha.h>)
-#   include <openssl/sha.h>
-#   define HAS_OPEN_SSL 1
+#if defined(TEST_OPENSSL) && defined(__has_include)
+#  if __has_include(<openssl/sha.h>)
+#    include <openssl/sha.h>
+#    define HAS_OPEN_SSL 1
+#  endif
 #endif
 // clang-format on
 
@@ -288,13 +290,13 @@ void bscrypt_test_sha1(void) {
     char hash[21];
   } sets[] = {
       {"The quick brown fox jumps over the lazy dog",
-       {0x2f, 0xd4, 0xe1, 0xc6, 0x7a, 0x2d, 0x28, 0xfc, 0xed, 0x84, 0x9e, 0xe1,
-        0xbb, 0x76, 0xe7, 0x39, 0x1b, 0x93, 0xeb, 0x12,
-        0}}, // a set with a string
+       {0x2f, 0xd4, 0xe1, 0xc6, 0x7a, 0x2d, 0x28, 0xfc, 0xed, 0x84, 0x9e,
+        0xe1, 0xbb, 0x76, 0xe7, 0x39, 0x1b, 0x93, 0xeb, 0x12, 0}}, // a set with
+                                                                   // a string
       {"",
        {
-           0xda, 0x39, 0xa3, 0xee, 0x5e, 0x6b, 0x4b, 0x0d, 0x32, 0x55, 0xbf,
-           0xef, 0x95, 0x60, 0x18, 0x90, 0xaf, 0xd8, 0x07, 0x09,
+           0xda, 0x39, 0xa3, 0xee, 0x5e, 0x6b, 0x4b, 0x0d, 0x32, 0x55,
+           0xbf, 0xef, 0x95, 0x60, 0x18, 0x90, 0xaf, 0xd8, 0x07, 0x09,
        }},        // an empty set
       {NULL, {0}} // Stop
   };

data/ext/iodine/sha1.h

@@ -1,7 +1,7 @@
 /*
-(un)copyright: Boaz segev, 2016
-License: Public Domain except for any non-public-domain algorithms, which are
-subject to their own licenses.
+Copyright: Boaz segev, 2016-2017
+License: MIT except for any non-public-domain algorithms (none that I'm aware
+of), which might be subject to their own licenses.
 
 Feel free to copy, use and enjoy in accordance with to the license(s).
 */

data/ext/iodine/sha2.c

@@ -1,7 +1,7 @@
 /*
-(un)copyright: Boaz segev, 2016
-License: Public Domain except for any non-public-domain algorithms, which are
-subject to their own licenses.
+Copyright: Boaz segev, 2016-2017
+License: MIT except for any non-public-domain algorithms (none that I'm aware
+of), which might be subject to their own licenses.
 
 Feel free to copy, use and enjoy in accordance with to the license(s).
 */
@@ -658,9 +658,11 @@ static char *sha2_variant_names[] = {
 };
 
 // clang-format off
-#if defined(TEST_OPENSSL) && defined(__has_include) && __has_include(<openssl/sha.h>)
-#   include <openssl/sha.h>
-#   define HAS_OPEN_SSL 1
+#if defined(TEST_OPENSSL) && defined(__has_include)
+#  if __has_include(<openssl/sha.h>)
+#    include <openssl/sha.h>
+#    define HAS_OPEN_SSL 1
+#  endif
 #endif
 // clang-format on
 

data/ext/iodine/sha2.h

@@ -1,7 +1,7 @@
 /*
-(un)copyright: Boaz segev, 2016
-License: Public Domain except for any non-public-domain algorithms, which are
-subject to their own licenses.
+Copyright: Boaz segev, 2016-2017
+License: MIT except for any non-public-domain algorithms (none that I'm aware
+of), which might be subject to their own licenses.
 
 Feel free to copy, use and enjoy in accordance with to the license(s).
 */

data/ext/iodine/siphash.c

@@ -1,6 +1,13 @@
+/*
+Copyright: Boaz segev, 2016-2017
+License: MIT except for any non-public-domain algorithms (none that I'm aware
+of), which might be subject to their own licenses.
+
+Feel free to copy, use and enjoy in accordance with to the license(s).
+*/
 #include "siphash.h"
-#include <stdlib.h>
 #include <stdint.h>
+#include <stdlib.h>
 
 // clang-format off
 #if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
@@ -80,7 +87,7 @@ uint64_t siphash24(const void *data, size_t len, uint64_t iv_key[2]) {
   word.i = 0;
   uint8_t *pos = word.str;
   uint8_t *w8 = (void *)w64;
-  switch (len) {
+  switch (len) { // fallthrough is intentional
   case 7:
     pos[6] = w8[6];
   case 6:

data/ext/iodine/siphash.h

@@ -1,7 +1,14 @@
+/*
+Copyright: Boaz segev, 2016-2017
+License: MIT except for any non-public-domain algorithms (none that I'm aware
+of), which might be subject to their own licenses.
+
+Feel free to copy, use and enjoy in accordance with to the license(s).
+*/
 #ifndef BS_SIPHASH_H
 #define BS_SIPHASH_H
-#include <stdlib.h>
 #include <stdint.h>
+#include <stdlib.h>
 
 #define SIPHASH_DEFAULT_KEY                                                    \
   (uint64_t[]) { 0x0706050403020100, 0x0f0e0d0c0b0a0908 }

data/ext/iodine/spnlock.h

@@ -1,12 +1,18 @@
+/*
+Copyright: Boaz segev, 2016-2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#ifndef _SPN_LOCK_H
 /* *****************************************************************************
 A Simple busy lock implementation ... (spnlock.h)
 
-Based on a lot of internet reading as well as comperative work (i.e the Linux
+Based on a lot of internet reading as well as comparative work (i.e the Linux
 karnel's code and the more readable Apple's kernel code)
 
 Written by Boaz Segev at 2016. Donated to the public domain for all to enjoy.
 */
-#ifndef _SPN_LOCK_H
 #define _SPN_LOCK_H
 
 /* allow of the unused flag */
@@ -14,8 +20,8 @@ Written by Boaz Segev at 2016. Donated to the public domain for all to enjoy.
 #define __unused __attribute__((unused))
 #endif
 
-#include <stdlib.h>
 #include <stdint.h>
+#include <stdlib.h>
 
 /*********
  * manage the way threads "wait" for the lock to release

data/ext/iodine/websockets.c

@@ -1,6 +1,13 @@
+/*
+copyright: Boaz segev, 2016-2017
+license: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
 #include "websockets.h"
 #include "bscrypt.h"
 #include "libserver.h"
+#include "mempool.h"
 #include <arpa/inet.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -34,8 +41,8 @@ struct buffer_s resize_ws_buffer(ws_s *owner, struct buffer_s);
 /** releases an existing buffer. */
 void free_ws_buffer(ws_s *owner, struct buffer_s);
 
-/** Sets the initial buffer size. (16Kb)*/
-#define WS_INITIAL_BUFFER_SIZE 16384
+/** Sets the initial buffer size. (4Kb)*/
+#define WS_INITIAL_BUFFER_SIZE 4096
 
 /*******************************************************************************
 Buffer management - simple implementation...
@@ -47,15 +54,16 @@ the code probably wouldn't offer a high performance boost.
 #define round_up_buffer_size(size) (((size) >> 12) + 1) << 12
 
 struct buffer_s create_ws_buffer(ws_s *owner) {
+  (void)(owner);
   struct buffer_s buff;
   buff.size = round_up_buffer_size(WS_INITIAL_BUFFER_SIZE);
-  buff.data = malloc(buff.size);
+  buff.data = mempool_malloc(buff.size);
   return buff;
 }
 
 struct buffer_s resize_ws_buffer(ws_s *owner, struct buffer_s buff) {
   buff.size = round_up_buffer_size(buff.size);
-  void *tmp = realloc(buff.data, buff.size);
+  void *tmp = mempool_realloc(buff.data, buff.size);
   if (!tmp) {
     free_ws_buffer(owner, buff);
     buff.size = 0;
@@ -64,8 +72,9 @@ struct buffer_s resize_ws_buffer(ws_s *owner, struct buffer_s buff) {
   return buff;
 }
 void free_ws_buffer(ws_s *owner, struct buffer_s buff) {
+  (void)(owner);
   if (buff.data)
-    free(buff.data);
+    mempool_free(buff.data);
 }
 
 #undef round_up_buffer_size
@@ -107,10 +116,8 @@ struct Websocket {
     } psize;
     size_t length;
     size_t received;
-    int pos;
     int data_len;
     char mask[4];
-    char tmp_buffer[1024];
     struct {
       unsigned op_code : 4;
       unsigned rsv3 : 1;
@@ -137,13 +144,22 @@ The Websocket Protocol Identifying String. Used for the `each` function.
 */
 char *WEBSOCKET_ID_STR = "websockets";
 
+/**
+A thread localized buffer used for reading and parsing data from the socket.
+*/
+static __thread struct {
+  int pos;
+  char buffer[1024];
+} read_buffer;
+
 /*******************************************************************************
 The Websocket Protocol implementation
 */
 
 #define ws_protocol(fd) ((ws_s *)(server_get_protocol(fd)))
 
-static void ws_ping(intptr_t fd, protocol_s *_ws) {
+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();
@@ -156,16 +172,19 @@ static void ws_ping(intptr_t fd, protocol_s *_ws) {
 static void on_close(protocol_s *_ws) { destroy_ws((ws_s *)_ws); }
 
 static void on_ready(intptr_t fduuid, protocol_s *ws) {
+  (void)(fduuid);
   if (ws && ws->service == WEBSOCKET_ID_STR && ((ws_s *)ws)->on_ready)
     ((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_shutdown(intptr_t fd, protocol_s *ws) {
+  (void)(fd);
   if (ws && ((ws_s *)ws)->on_shutdown)
     ((ws_s *)ws)->on_shutdown((ws_s *)ws);
 }
@@ -174,37 +193,37 @@ static void on_shutdown(intptr_t fd, protocol_s *ws) {
 static void websocket_write_impl(intptr_t fd, void *data, size_t len, char text,
                                  char first, char last, char client);
 
+/* read data from the socket, parse it and invoke the websocket events. */
 static void on_data(intptr_t sockfd, protocol_s *_ws) {
 #define ws ((ws_s *)_ws)
   if (ws == NULL || ws->protocol.service != WEBSOCKET_ID_STR)
     return;
   ssize_t len = 0;
-  while ((len = sock_read(sockfd, ws->parser.tmp_buffer, 1024)) > 0) {
+  while ((len = sock_read(sockfd, read_buffer.buffer, 1024)) > 0) {
     ws->parser.data_len = 0;
-    ws->parser.pos = 0;
-    while (ws->parser.pos < len) {
+    read_buffer.pos = 0;
+    while (read_buffer.pos < len) {
       // collect the frame's head
       if (!(*(char *)(&ws->parser.head))) {
-        *((char *)(&(ws->parser.head))) = ws->parser.tmp_buffer[ws->parser.pos];
+        *((char *)(&(ws->parser.head))) = read_buffer.buffer[read_buffer.pos];
         // save a copy if it's the first head in a fragmented message
         if (!(*(char *)(&ws->parser.head2))) {
           ws->parser.head2 = ws->parser.head;
         }
         // advance
-        ws->parser.pos++;
+        read_buffer.pos++;
         // go back to the `while` head, to review if there's more data
         continue;
       }
 
       // save the mask and size information
       if (!(*(char *)(&ws->parser.sdata))) {
-        *((char *)(&(ws->parser.sdata))) =
-            ws->parser.tmp_buffer[ws->parser.pos];
+        *((char *)(&(ws->parser.sdata))) = read_buffer.buffer[read_buffer.pos];
         // set length
         ws->parser.state.at_len = ws->parser.sdata.size == 127
                                       ? 7
                                       : ws->parser.sdata.size == 126 ? 1 : 0;
-        ws->parser.pos++;
+        read_buffer.pos++;
         continue;
       }
 
@@ -218,29 +237,29 @@ static void on_data(intptr_t sockfd, protocol_s *_ws) {
         if ((ws->parser.state.at_len == 1 && ws->parser.sdata.size == 126) ||
             (ws->parser.state.at_len == 7 && ws->parser.sdata.size == 127)) {
           ws->parser.psize.bytes[ws->parser.state.at_len] =
-              ws->parser.tmp_buffer[ws->parser.pos++];
+              read_buffer.buffer[read_buffer.pos++];
           ws->parser.state.has_len = 1;
           ws->parser.length = (ws->parser.sdata.size == 126)
                                   ? ws->parser.psize.len1
                                   : ws->parser.psize.len2;
         } else {
           ws->parser.psize.bytes[ws->parser.state.at_len++] =
-              ws->parser.tmp_buffer[ws->parser.pos++];
-          if (ws->parser.pos < len)
+              read_buffer.buffer[read_buffer.pos++];
+          if (read_buffer.pos < len)
             goto collect_len;
         }
 #else
         if (ws->parser.state.at_len == 0) {
           ws->parser.psize.bytes[ws->parser.state.at_len] =
-              ws->parser.tmp_buffer[ws->parser.pos++];
+              read_buffer.buffer[read_buffer.pos++];
           ws->parser.state.has_len = 1;
           ws->parser.length = (ws->parser.sdata.size == 126)
                                   ? ws->parser.psize.len1
                                   : ws->parser.psize.len2;
         } else {
           ws->parser.psize.bytes[ws->parser.state.at_len--] =
-              ws->parser.tmp_buffer[ws->parser.pos++];
-          if (ws->parser.pos < len)
+              read_buffer.buffer[read_buffer.pos++];
+          if (read_buffer.pos < len)
             goto collect_len;
         }
 #endif
@@ -255,13 +274,13 @@ static void on_data(intptr_t sockfd, protocol_s *_ws) {
       collect_mask:
         if (ws->parser.state.at_mask == 3) {
           ws->parser.mask[ws->parser.state.at_mask] =
-              ws->parser.tmp_buffer[ws->parser.pos++];
+              read_buffer.buffer[read_buffer.pos++];
           ws->parser.state.has_mask = 1;
           ws->parser.state.at_mask = 0;
         } else {
           ws->parser.mask[ws->parser.state.at_mask++] =
-              ws->parser.tmp_buffer[ws->parser.pos++];
-          if (ws->parser.pos < len)
+              read_buffer.buffer[read_buffer.pos++];
+          if (read_buffer.pos < len)
             goto collect_mask;
           else
             continue;
@@ -274,7 +293,7 @@ static void on_data(intptr_t sockfd, protocol_s *_ws) {
       // Now that we know everything about the frame, let's collect the data
 
       // How much data in the buffer is part of the frame?
-      ws->parser.data_len = len - ws->parser.pos;
+      ws->parser.data_len = len - read_buffer.pos;
       if (ws->parser.data_len + ws->parser.received > ws->parser.length)
         ws->parser.data_len = ws->parser.length - ws->parser.received;
 
@@ -283,7 +302,7 @@ static void on_data(intptr_t sockfd, protocol_s *_ws) {
       // unmask:
       if (ws->parser.sdata.masked) {
         for (int i = 0; i < ws->parser.data_len; i++) {
-          ws->parser.tmp_buffer[i + ws->parser.pos] ^=
+          read_buffer.buffer[i + read_buffer.pos] ^=
               ws->parser.mask[ws->parser.state.at_mask++];
         }
       } else if (ws->parser.state.client == 0) {
@@ -292,8 +311,7 @@ static void on_data(intptr_t sockfd, protocol_s *_ws) {
         sock_close(sockfd);
         return;
       }
-      // Copy the data to the Ruby buffer - only if it's a user message
-      // RubyCaller.call_c(copy_data_to_buffer_in_gvl, ws);
+      // Copy the data to the Websocket buffer - only if it's a user message
       if (ws->parser.head.op_code == 1 || ws->parser.head.op_code == 2 ||
           (!ws->parser.head.op_code &&
            (ws->parser.head2.op_code == 1 || ws->parser.head2.op_code == 2))) {
@@ -316,7 +334,7 @@ static void on_data(intptr_t sockfd, protocol_s *_ws) {
         }
         // copy here
         memcpy(ws->buffer.data + ws->length,
-               ws->parser.tmp_buffer + ws->parser.pos, ws->parser.data_len);
+               read_buffer.buffer + read_buffer.pos, ws->parser.data_len);
         ws->length += ws->parser.data_len;
       }
       // set the frame's data received so far (copied or not)
@@ -326,7 +344,7 @@ static void on_data(intptr_t sockfd, protocol_s *_ws) {
 
       // check that we have collected the whole of the frame.
       if (ws->parser.length > ws->parser.received) {
-        ws->parser.pos += ws->parser.data_len;
+        read_buffer.pos += ws->parser.data_len;
         continue;
       }
 
@@ -358,7 +376,7 @@ static void on_data(intptr_t sockfd, protocol_s *_ws) {
       } else if (ws->parser.head.op_code == 9) {
         /* ping */
         // write Pong - including ping data...
-        websocket_write_impl(sockfd, ws->parser.tmp_buffer + ws->parser.pos,
+        websocket_write_impl(sockfd, read_buffer.buffer + read_buffer.pos,
                              ws->parser.data_len, 10, 1, 1,
                              ws->parser.state.client);
         if (ws->parser.head2.op_code == ws->parser.head.op_code)
@@ -378,13 +396,13 @@ static void on_data(intptr_t sockfd, protocol_s *_ws) {
           goto reset_parser;
       }
       // not done, but move the pos marker along
-      ws->parser.pos += ws->parser.data_len;
+      read_buffer.pos += ws->parser.data_len;
       continue;
 
     reset_parser:
       // move the pos marker along - in case we have more then one frame in the
       // buffer
-      ws->parser.pos += ws->parser.data_len;
+      read_buffer.pos += ws->parser.data_len;
       // clear the parser
       *((char *)(&(ws->parser.state))) = *((char *)(&(ws->parser.sdata))) =
           *((char *)(&(ws->parser.head2))) = *((char *)(&(ws->parser.head))) =
@@ -404,8 +422,9 @@ Create/Destroy the websocket object
 */
 
 static ws_s *new_websocket() {
-  // allocate the protocol object (TODO: (maybe) pooling)
-  ws_s *ws = calloc(sizeof(*ws), 1);
+  // allocate the protocol object
+  ws_s *ws = mempool_malloc(sizeof(*ws));
+  memset(ws, 0, sizeof(*ws));
 
   // setup the protocol & protocol callbacks
   ws->protocol.ping = ws_ping;
@@ -421,7 +440,7 @@ static void destroy_ws(ws_s *ws) {
   if (ws->on_close)
     ws->on_close(ws);
   free_ws_buffer(ws, ws->buffer);
-  free(ws);
+  mempool_free(ws);
 }
 
 /*******************************************************************************
@@ -654,7 +673,10 @@ void websocket_close(ws_s *ws) {
 /**
 Counts the number of websocket connections.
 */
-size_t websocket_count(ws_s *ws) { return server_count(WEBSOCKET_ID_STR); }
+size_t websocket_count(ws_s *ws) {
+  (void)(ws);
+  return server_count(WEBSOCKET_ID_STR);
+}
 
 /*******************************************************************************
 Each Implementation
@@ -668,11 +690,13 @@ 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) {
+  (void)(fd);
   struct WSTask *tsk = _arg;
   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);