iodine 0.4.8 → 0.4.10

data/ext/iodine/fiobj_types.h

@@ -0,0 +1,290 @@
+/*
+Copyright: Boaz segev, 2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+
+#ifndef H_FIOBJ_TYPES_INTERNAL_H
+#define H_FIOBJ_TYPES_INTERNAL_H
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include "fiobj.h"
+
+#include <errno.h>
+#include <math.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <string.h>
+#include <sys/types.h>
+
+/* *****************************************************************************
+Atomic add / subtract
+***************************************************************************** */
+
+/* Select the correct compiler builtin method. */
+#if defined(__has_builtin)
+
+#if __has_builtin(__atomic_exchange_n)
+#define SPN_LOCK_BUILTIN(...) __atomic_exchange_n(__VA_ARGS__, __ATOMIC_ACQ_REL)
+/** An atomic addition operation */
+#define spn_add(...) __atomic_add_fetch(__VA_ARGS__, __ATOMIC_ACQ_REL)
+/** An atomic subtraction operation */
+#define spn_sub(...) __atomic_sub_fetch(__VA_ARGS__, __ATOMIC_ACQ_REL)
+
+#elif __has_builtin(__sync_fetch_and_or)
+#define SPN_LOCK_BUILTIN(...) __sync_fetch_and_or(__VA_ARGS__)
+/** An atomic addition operation */
+#define spn_add(...) __sync_add_and_fetch(__VA_ARGS__)
+/** An atomic subtraction operation */
+#define spn_sub(...) __sync_sub_and_fetch(__VA_ARGS__)
+
+#else
+#error Required builtin "__sync_swap" or "__sync_fetch_and_or" missing from compiler.
+#endif /* defined(__has_builtin) */
+
+#elif __GNUC__ > 3
+#define SPN_LOCK_BUILTIN(...) __sync_fetch_and_or(__VA_ARGS__)
+/** An atomic addition operation */
+#define spn_add(...) __sync_add_and_fetch(__VA_ARGS__)
+/** An atomic subtraction operation */
+#define spn_sub(...) __sync_sub_and_fetch(__VA_ARGS__)
+
+#else
+#error Required builtin "__sync_swap" or "__sync_fetch_and_or" not found.
+#endif
+
+/* *****************************************************************************
+Simple List - Used for fiobj_s * objects, but can be used for anything really.
+***************************************************************************** */
+
+typedef struct fio_ls_s {
+  struct fio_ls_s *prev;
+  struct fio_ls_s *next;
+  fiobj_s *obj;
+} fio_ls_s;
+
+#define FIO_LS_INIT(name)                                                      \
+  { .next = &(name), .prev = &(name) }
+
+/** Adds an object to the list's head. */
+static inline __attribute__((unused)) void fio_ls_push(fio_ls_s *pos,
+                                                       fiobj_s *obj) {
+  /* prepare item */
+  fio_ls_s *item = (fio_ls_s *)malloc(sizeof(*item));
+  if (!item)
+    perror("ERROR: fiobj list couldn't allocate memory"), exit(errno);
+  *item = (fio_ls_s){.prev = pos, .next = pos->next, .obj = obj};
+  /* inject item */
+  pos->next->prev = item;
+  pos->next = item;
+}
+
+/** Adds an object to the list's tail. */
+static inline __attribute__((unused)) void fio_ls_unshift(fio_ls_s *pos,
+                                                          fiobj_s *obj) {
+  pos = pos->prev;
+  fio_ls_push(pos, obj);
+}
+
+/** Removes an object from the list's head. */
+static inline __attribute__((unused)) fiobj_s *fio_ls_pop(fio_ls_s *list) {
+  if (list->next == list)
+    return NULL;
+  fio_ls_s *item = list->next;
+  fiobj_s *ret = item->obj;
+  list->next = item->next;
+  list->next->prev = list;
+  free(item);
+  return ret;
+}
+
+/** Removes an object from the list's tail. */
+static inline __attribute__((unused)) fiobj_s *fio_ls_shift(fio_ls_s *list) {
+  if (list->prev == list)
+    return NULL;
+  fio_ls_s *item = list->prev;
+  fiobj_s *ret = item->obj;
+  list->prev = item->prev;
+  list->prev->next = list;
+  free(item);
+  return ret;
+}
+
+/** Removes an object from the containing node. */
+static inline __attribute__((unused)) fiobj_s *fio_ls_remove(fio_ls_s *node) {
+  fiobj_s *ret = node->obj;
+  node->next->prev = node->prev->next;
+  node->prev->next = node->next->prev;
+  free(node);
+  return ret;
+}
+
+/* *****************************************************************************
+Memory Page Size
+***************************************************************************** */
+
+#if defined(__unix__) || defined(__APPLE__) || defined(__linux__)
+#include <unistd.h>
+
+size_t __attribute__((weak)) fiobj_memory_page_size(void) {
+  static size_t page_size = 0;
+  if (page_size)
+    return page_size;
+  page_size = sysconf(_SC_PAGESIZE);
+  if (!page_size)
+    page_size = 4096;
+  return page_size;
+}
+#pragma weak fiobj_memory_page_size
+
+#else
+#define fiobj_memory_page_size() 4096
+
+#endif
+/* *****************************************************************************
+Object types
+***************************************************************************** */
+
+/* Number */
+typedef struct {
+  fiobj_type_en type;
+  int64_t i;
+} fio_num_s;
+
+/* Float */
+typedef struct {
+  fiobj_type_en type;
+  double f;
+} fio_float_s;
+
+/* String */
+typedef struct {
+  fiobj_type_en type;
+  uint64_t capa;
+  uint64_t len;
+  uint8_t is_static;
+  char *str;
+} fio_str_s;
+
+/* Symbol */
+typedef struct {
+  fiobj_type_en type;
+  uintptr_t hash;
+  uint64_t len;
+  char str[];
+} fio_sym_s;
+
+/* IO */
+typedef struct {
+  fiobj_type_en type;
+  intptr_t fd;
+} fio_io_s;
+
+/* Array */
+typedef struct {
+  fiobj_type_en type;
+  uint64_t start;
+  uint64_t end;
+  uint64_t capa;
+  fiobj_s **arry;
+} fio_ary_s;
+
+/* *****************************************************************************
+Hash types
+***************************************************************************** */
+/* MUST be a power of 2 */
+#define FIOBJ_HASH_MAX_MAP_SEEK (256)
+
+typedef struct {
+  uintptr_t hash;
+  fio_ls_s *container;
+} map_info_s;
+
+typedef struct {
+  uintptr_t capa;
+  map_info_s *data;
+} fio_map_s;
+
+typedef struct {
+  fiobj_type_en type;
+  uintptr_t count;
+  uintptr_t mask;
+  fio_ls_s items;
+  fio_map_s map;
+} fio_hash_s;
+
+/* Hash node */
+typedef struct {
+  fiobj_type_en type;
+  fiobj_s *name;
+  fiobj_s *obj;
+} fio_couplet_s;
+
+void fiobj_hash_rehash(fiobj_s *h);
+
+/* *****************************************************************************
+Type VTable (virtual function table)
+***************************************************************************** */
+struct fiobj_vtable_s {
+  /* deallocate an object */
+  void (*free)(fiobj_s *);
+  /* object value as String */
+  fio_cstr_s (*to_str)(fiobj_s *);
+  /* object value as Integer */
+  int64_t (*to_i)(fiobj_s *);
+  /* object value as Float */
+  double (*to_f)(fiobj_s *);
+  /* true if object is equal. nested objects must be ignored (test container) */
+  int (*is_eq)(fiobj_s *self, fiobj_s *other);
+  /* return the number of nested object */
+  size_t (*count)(fiobj_s *);
+  /* perform a task for the object's children (-1 stops iteration)
+   * returns the number of items processed + `start_at`.
+   */
+  size_t (*each1)(fiobj_s *, size_t start_at,
+                  int (*task)(fiobj_s *obj, void *arg), void *arg);
+};
+
+fio_cstr_s fiobj_noop_str(fiobj_s *obj);
+int64_t fiobj_noop_i(fiobj_s *obj);
+double fiobj_noop_f(fiobj_s *obj);
+size_t fiobj_noop_count(fiobj_s *obj);
+size_t fiobj_noop_each1(fiobj_s *obj, size_t start_at,
+                        int (*task)(fiobj_s *obj, void *arg), void *arg);
+void fiobj_simple_dealloc(fiobj_s *o);
+
+/* *****************************************************************************
+The Object type head and management
+***************************************************************************** */
+
+typedef struct {
+  uint64_t ref;
+  struct fiobj_vtable_s *vtable;
+} fiobj_head_s;
+
+#define OBJ2HEAD(o) (((fiobj_head_s *)(o)) - 1)[0]
+#define HEAD2OBJ(o) ((fiobj_s *)(((fiobj_head_s *)(o)) + 1))
+
+#define OBJREF_ADD(o) spn_add(&OBJ2HEAD((o)).ref, 1)
+#define OBJREF_REM(o) spn_sub(&OBJ2HEAD((o)).ref, 1)
+
+#define obj2io(o) ((fio_io_s *)(o))
+#define obj2ary(o) ((fio_ary_s *)(o))
+#define obj2str(o) ((fio_str_s *)(o))
+#define obj2sym(o) ((fio_sym_s *)(o))
+#define obj2num(o) ((fio_num_s *)(o))
+#define obj2hash(o) ((fio_hash_s *)(o))
+#define obj2float(o) ((fio_float_s *)(o))
+#define obj2couplet(o) ((fio_couplet_s *)(o))
+
+/* *****************************************************************************
+Internal API required across the board
+***************************************************************************** */
+void fiobj_dealloc(fiobj_s *obj);
+uint64_t fiobj_sym_hash(const void *data, size_t len);
+
+#endif

data/ext/iodine/http1.c

@@ -101,6 +101,43 @@ initialize:
   return http1_pool.protocol_mem;
 }
 
+/* *****************************************************************************
+HTTP/1.1 error responses
+***************************************************************************** */
+
+static void err_bad_request(http1_protocol_s *pr) {
+  http_response_s *response = http_response_create(&pr->request.request);
+  if (pr->settings->log_static)
+    http_response_log_start(response);
+  response->status = 400;
+  if (!pr->settings->public_folder ||
+      http_response_sendfile2(response, &pr->request.request,
+                              pr->settings->public_folder,
+                              pr->settings->public_folder_length, "400.html", 8,
+                              pr->settings->log_static)) {
+    response->should_close = 1;
+    http_response_write_body(response, "Bad Request", 11);
+    http_response_finish(response);
+  }
+  sock_close(pr->request.request.fd);
+  pr->request.buffer_pos = 0;
+}
+
+static void err_too_big(http1_protocol_s *pr) {
+  http_response_s *response = http_response_create(&pr->request.request);
+  if (pr->settings->log_static)
+    http_response_log_start(response);
+  response->status = 431;
+  if (!pr->settings->public_folder ||
+      http_response_sendfile2(response, &pr->request.request,
+                              pr->settings->public_folder,
+                              pr->settings->public_folder_length, "431.html", 8,
+                              pr->settings->log_static)) {
+    http_response_write_body(response, "Request Header Fields Too Large", 31);
+    http_response_finish(response);
+  }
+}
+
 /* *****************************************************************************
 HTTP/1.1 parsre callbacks
 ***************************************************************************** */
@@ -115,6 +152,7 @@ static int http1_on_request(http1_parser_s *parser) {
   if (pr->request.request.host == NULL) {
     goto bad_request;
   }
+  pr->request.request.content_length = parser->state.content_length;
   http_settings_s *settings = pr->settings;
   pr->request.request.settings = settings;
   // make sure udata to NULL, making it available for the user
@@ -131,23 +169,7 @@ static int http1_on_request(http1_parser_s *parser) {
   return 0;
 bad_request:
   /* handle generally bad requests */
-  {
-    http_response_s *response = http_response_create(&pr->request.request);
-    if (pr->settings->log_static)
-      http_response_log_start(response);
-    response->status = 400;
-    if (!pr->settings->public_folder ||
-        http_response_sendfile2(response, &pr->request.request,
-                                pr->settings->public_folder,
-                                pr->settings->public_folder_length, "400.html",
-                                8, pr->settings->log_static)) {
-      response->should_close = 1;
-      http_response_write_body(response, "Bad Request", 11);
-      http_response_finish(response);
-    }
-    sock_close(pr->request.request.fd);
-    pr->request.buffer_pos = 0;
-  }
+  err_bad_request(pr);
   return -1;
 }
 /** called when a response was received. */
@@ -215,6 +237,8 @@ static int http1_on_header(http1_parser_s *parser, char *name, size_t name_len,
   http1_protocol_s *pr = parser->udata;
   if (!pr || pr->request.header_pos >= HTTP1_MAX_HEADER_COUNT - 1)
     goto too_big;
+  if (parser->state.read)
+    goto too_big; /* refuse trailer header data, it isn't in buffer */
 
 /** test for special headers that should be easily accessible **/
 #if HTTP_HEADERS_LOWERCASE
@@ -259,20 +283,7 @@ static int http1_on_header(http1_parser_s *parser, char *name, size_t name_len,
   return 0;
 too_big:
   /* handle oversized headers */
-  {
-    http_response_s *response = http_response_create(&pr->request.request);
-    if (pr->settings->log_static)
-      http_response_log_start(response);
-    response->status = 431;
-    if (!pr->settings->public_folder ||
-        http_response_sendfile2(response, &pr->request.request,
-                                pr->settings->public_folder,
-                                pr->settings->public_folder_length, "431.html",
-                                8, pr->settings->log_static)) {
-      http_response_write_body(response, "Request Header Fields Too Large", 31);
-      http_response_finish(response);
-    }
-  }
+  err_too_big(pr);
   return -1;
 }
 
@@ -282,12 +293,13 @@ static int http1_on_body_chunk(http1_parser_s *parser, char *data,
   http1_protocol_s *pr = parser->udata;
   if (!pr)
     return -1;
+  if (parser->state.content_length > (ssize_t)pr->settings->max_body_size ||
+      parser->state.read > (ssize_t)pr->settings->max_body_size)
+    return -1; /* test every time, in case of chunked data */
   if (!parser->state.read) {
-    if (parser->state.content_length > pr->settings->max_body_size)
-      return -1;
-    pr->request.request.content_length = parser->state.content_length;
-    if (pr->request.buffer_pos + parser->state.content_length <
-        HTTP1_MAX_HEADER_SIZE) {
+    if (parser->state.content_length > 0 &&
+        (pr->request.buffer_pos + parser->state.content_length <
+         HTTP1_MAX_HEADER_SIZE)) {
       pr->request.request.body_str = data;
     } else {
 // create a temporary file to contain the data.
@@ -348,6 +360,12 @@ static void http1_on_data(intptr_t uuid, http1_protocol_s *pr) {
       tmp = 0;
     buffer = request->buffer + request->buffer_pos - pr->len;
   } else {
+    if (pr->len) {
+      /* protocol error, we shouldn't have letfovers during file processing */
+      err_bad_request(pr);
+      http1_on_error(&pr->parser);
+      return;
+    }
     buffer = buff;
     tmp = sock_read(uuid, buffer, HTTP_BODY_CHUNK_SIZE);
     if (tmp > 0) {

data/ext/iodine/http1_parser.c

@@ -163,12 +163,34 @@ inline static int consume_header(struct http1_fio_parser_args_s *args,
       *((uint64_t *)(start + 6)) == *((uint64_t *)"t-length")) {
     /* handle the special `content-length` header */
     args->parser->state.content_length = atol((char *)tmp);
+  } else if ((tmp - start) - t2 == 17 &&
+             *((uint64_t *)start) == *((uint64_t *)"transfer") &&
+             *((uint64_t *)(start + 8)) == *((uint64_t *)"-encodin") &&
+             *((uint32_t *)tmp) == *((uint32_t *)"chun") &&
+             *((uint32_t *)(tmp + 3)) == *((uint32_t *)"nked")) {
+    /* handle the special `transfer-encoding: chunked` header */
+    args->parser->state.reserved |= 64;
+  } else if ((tmp - start) - t2 == 7 &&
+             *((uint64_t *)start) == *((uint64_t *)"trailer")) {
+    /* chunked data with trailer... */
+    args->parser->state.reserved |= 64;
+    args->parser->state.reserved |= 32;
   }
 #else
   if ((tmp - start) - t2 == 14 &&
       HEADER_NAME_IS_EQ((char *)start, "content-length", 14)) {
     /* handle the special `content-length` header */
     args->parser->state.content_length = atol((char *)tmp);
+  } else if ((tmp - start) - t2 == 17 &&
+             HEADER_NAME_IS_EQ((char *)start, "transfer-encoding", 17) &&
+             memcmp(tmp, "chunked", 7)) {
+    /* handle the special `transfer-encoding: chunked` header */
+    args->parser->state.reserved |= 64;
+  } else if ((tmp - start) - t2 == 7 &&
+             HEADER_NAME_IS_EQ((char *)start, "trailer", 7)) {
+    /* chunked data with trailer... */
+    args->parser->state.reserved |= 64;
+    args->parser->state.reserved |= 32;
   }
 #endif
   /* perform callback */
@@ -178,25 +200,124 @@ inline static int consume_header(struct http1_fio_parser_args_s *args,
   return 0;
 }
 
+/* *****************************************************************************
+HTTP/1.1 Body handling
+***************************************************************************** */
+
+inline static int consume_body_streamed(struct http1_fio_parser_args_s *args,
+                                        uint8_t **start) {
+  uint8_t *end =
+      *start + args->parser->state.content_length - args->parser->state.read;
+  uint8_t *const stop = ((uint8_t *)args->buffer) + args->length;
+  if (end > stop)
+    end = stop;
+  if (end > *start &&
+      args->on_body_chunk(args->parser, (char *)(*start), end - *start))
+    return -1;
+  args->parser->state.read += (end - *start);
+  *start = end;
+  if (args->parser->state.content_length <= args->parser->state.read)
+    args->parser->state.reserved |= 4;
+  return 0;
+}
+
+inline static int consume_body_chunked(struct http1_fio_parser_args_s *args,
+                                       uint8_t **start) {
+  uint8_t *const stop = ((uint8_t *)args->buffer) + args->length;
+  uint8_t *end = *start;
+  while (*start < stop) {
+    if (args->parser->state.content_length == 0) {
+      size_t eol_len;
+      /* collect chunked length */
+      if (!(eol_len = seek2eol(&end, stop))) {
+        /* requires length data to continue */
+        return 0;
+      }
+      /* an empty EOL is possible in mid stream processing */
+      if (*start + eol_len - 1 >= end && (*start = end) &&
+          !seek2eol(&end, stop)) {
+        return 0;
+      }
+      args->parser->state.content_length = 0 - strtol((char *)*start, NULL, 16);
+      *start = end = end + 1;
+      if (args->parser->state.content_length == 0) {
+        /* all chunked data was parsed */
+        args->parser->state.content_length = args->parser->state.read;
+        /* consume trailing EOL */
+        if (seek2eol(start, stop))
+          (*start)++;
+        if (args->parser->state.reserved & 32) {
+          /* remove the "headers complete" and "trailer" flags */
+          args->parser->state.reserved &= 0xDD; /* 0xDD == ~2 & ~32 & 0xFF */
+          return -2;
+        }
+        /* the parsing complete flag */
+        args->parser->state.reserved |= 4;
+        return 0;
+      }
+    }
+    end = *start + (0 - args->parser->state.content_length);
+    if (end > stop)
+      end = stop;
+    if (end > *start &&
+        args->on_body_chunk(args->parser, (char *)(*start), end - *start)) {
+      return -1;
+    }
+    args->parser->state.read += (end - *start);
+    args->parser->state.content_length += (end - *start);
+    *start = end;
+    if (args->parser->state.content_length == 0 && seek2eol(start, stop))
+      (*start)++;
+  }
+  return 0;
+}
+
+inline static int consume_body(struct http1_fio_parser_args_s *args,
+                               uint8_t **start) {
+  if (args->parser->state.content_length > 0 &&
+      args->parser->state.content_length > args->parser->state.read) {
+    /* normal, streamed data */
+    return consume_body_streamed(args, start);
+  } else if (args->parser->state.content_length <= 0 &&
+             (args->parser->state.reserved & 64)) {
+    /* chuncked encoding */
+    return consume_body_chunked(args, start);
+  } else {
+    /* nothing to do - parsing complete */
+    args->parser->state.reserved |= 4;
+  }
+  return 0;
+}
+
 /* *****************************************************************************
 HTTP/1.1 parsre function
 ***************************************************************************** */
+#ifdef DEBUG
+#include <assert.h>
+#else
+#define DEBUG 0
+#define assert(...)
+#endif
 
 size_t http1_fio_parser_fn(struct http1_fio_parser_args_s *args) {
+  if (DEBUG) {
+    assert(args->parser && args->buffer);
+  }
   uint8_t *start = args->buffer;
   uint8_t *end = start;
   uint8_t *const stop = start + args->length;
   uint8_t eol_len = 0;
 #define CONSUMED ((size_t)((uintptr_t)start - (uintptr_t)args->buffer))
-  // fprintf(stderr, "** resuming with at %p with %.*s...(%lu)\n", args->buffer,
-  // 4,
-  //         start, args->length);
-  switch ((args->parser->state.reserved & 31)) {
+// fprintf(stderr, "** resuming with at %p with %.*s...(%lu)\n", args->buffer,
+// 4,
+//         start, args->length);
+re_eval:
+  switch ((args->parser->state.reserved & 15)) {
 
   /* request / response line */
   case 0:
     /* clear out any leadinng white space */
-    while (*start == '\r' || *start == '\r' || *start == ' ' || *start == 0) {
+    while (*start == '\r' || *start == '\n' || *start == ' ' || *start == 0) {
       start++;
     }
     end = start;
@@ -204,11 +325,11 @@ size_t http1_fio_parser_fn(struct http1_fio_parser_args_s *args) {
     if (!(eol_len = seek2eol(&end, stop)))
       return CONSUMED;
 
-    if (start[0] >= '1' && start[0] <= '9') {
+    if (((uint32_t *)start)[0] == ((uint32_t *)"HTTP")[0]) {
       /* HTTP response */
       if (consume_response_line(args, start, end - eol_len + 1))
         goto error;
-    } else {
+    } else if (tolower(start[0]) >= 'a' && tolower(start[0]) <= 'z') {
       /* HTTP request */
       if (consume_request_line(args, start, end - eol_len + 1))
         goto error;
@@ -233,44 +354,31 @@ size_t http1_fio_parser_fn(struct http1_fio_parser_args_s *args) {
   finished_headers:
     end = start = end + 1;
     args->parser->state.reserved |= 2;
-    if (args->parser->state.content_length == 0)
-      goto finish;
-    if (end >= stop)
-      return args->length;
-
   /* fallthrough */
   /* request body */
-  case 3: /*  2 | 1 == 3 */
-    end = start + args->parser->state.content_length - args->parser->state.read;
-    if (end > stop)
-      end = stop;
-    if (end == start)
-      return CONSUMED;
-    // fprintf(stderr, "Consuming body at (%lu/%lu):%.*s\n", end - start,
-    //         args->parser->state.content_length, (int)(end - start), start);
-    if (args->on_body_chunk(args->parser, (char *)start, end - start))
+  case 3: { /*  2 | 1 == 3 */
+    int t3 = consume_body(args, &start);
+    if (t3 == -1)
       goto error;
-    args->parser->state.read += (end - start);
-    start = end;
-    if (args->parser->state.content_length <= args->parser->state.read)
-      goto finish;
-    return CONSUMED;
+    if (t3 == -2)
+      goto re_eval;
     break;
   }
-
+  }
+  /* are we done ? */
+  if (args->parser->state.reserved & 4) {
+    if (((args->parser->state.reserved & 128) ? args->on_response
+                                              : args->on_request)(args->parser))
+      goto error;
+    args->parser->state =
+        (struct http1_parser_protected_read_only_state_s){0, 0, 0};
+  }
+  return CONSUMED;
 error:
   args->on_error(args->parser);
   args->parser->state =
       (struct http1_parser_protected_read_only_state_s){0, 0, 0};
   return args->length;
-
-finish:
-  if (((args->parser->state.reserved & 128) ? args->on_response
-                                            : args->on_request)(args->parser))
-    goto error;
-  args->parser->state =
-      (struct http1_parser_protected_read_only_state_s){0, 0, 0};
-  return CONSUMED;
 }
 
 #undef CONSUMED