iodine 0.4.19 → 0.5.0

data/ext/iodine/http1.h

@@ -1,52 +1,29 @@
 /*
-copyright: Boaz segev, 2016-2017
-license: MIT
-
-Feel free to copy, use and enjoy according to the license provided.
+Copyright: Boaz Segev, 2017
+License: MIT
 */
 #ifndef H_HTTP1_H
 #define H_HTTP1_H
+
 #include "http.h"
 
-#ifndef HTTP1_MAX_HEADER_SIZE
+#ifndef HTTP1_READ_BUFFER
 /**
-Sets the maximum allowed size of a requests header section
-(all cookies, headers and other data that isn't the request's "body").
-
-This value includes the request line itself.
-
-Defaults to ~16Kb headers per request.
-*/
-#define HTTP1_MAX_HEADER_SIZE (16 * 1024) /* ~16kb */
-#endif
-
-#ifndef HTTP1_MAX_HEADER_COUNT
-/** Sets the maximum allowed headers per request (obligatory).
-
-Defaults to 64 headers per request */
-#define HTTP1_MAX_HEADER_COUNT (64)
+ * The size of a single `read` command, it sets the limit for an HTTP/1.1
+ * header line.
+ */
+#define HTTP1_READ_BUFFER (8 * 1024) /* ~8kb */
 #endif
 
-#ifndef HTTP1_POOL_SIZE
-/** Defines the pre-allocated memory for incoming concurrent connections.
+/** Creates an HTTP1 protocol object and handles any unread data in the buffer
+ * (if any). */
+protocol_s *http1_new(uintptr_t uuid, http_settings_s *settings,
+                      void *unread_data, size_t unread_length);
 
-Any concurrent HTTP1 connections over this amount will be dynamically allocated.
-*/
-#define HTTP1_POOL_SIZE (64) /* should be ~0.5Mb with default values*/
-#endif
-
-/** The HTTP/1.1 protocol identifier. */
-extern char *HTTP1_Protocol_String;
-
-/* *****************************************************************************
-HTTP listening helpers
-*/
-
-/**
-Allocates memory for an upgradable HTTP/1.1 protocol.
+/** Manually destroys the HTTP1 protocol object. */
+void http1_destroy(protocol_s *);
 
-The protocol self destructs when the `on_close` callback is called.
-*/
-protocol_s *http1_on_open(intptr_t fd, http_settings_s *settings);
+/** returns the HTTP/1.1 protocol's VTable. */
+void * http1_vtable(void);
 
 #endif

data/ext/iodine/http1_parser.c

@@ -1,5 +1,5 @@
 /*
-Copyright: Boaz segev, 2017
+Copyright: Boaz Segev, 2017-2018
 License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
@@ -13,58 +13,72 @@ Feel free to copy, use and enjoy according to the license provided.
 #include <stdio.h>
 #include <string.h>
 
-#define PREFER_MEMCHAR 0
-
 /* *****************************************************************************
 Seeking for characters in a string
 ***************************************************************************** */
 
-#if PREFER_MEMCHAR
-
-/* a helper that seeks any char, converts it to NUL and returns 1 if found. */
-inline static uint8_t seek2ch(uint8_t **pos, uint8_t *const limit, uint8_t ch) {
-  /* This is library based alternative that is sometimes slower  */
-  if (*pos >= limit || **pos == ch) {
-    return 0;
-  }
-  uint8_t *tmp = memchr(*pos, ch, limit - (*pos));
-  if (tmp) {
-    *pos = tmp;
-    *tmp = 0;
-    return 1;
-  }
-  *pos = limit;
-  return 0;
-}
+#ifndef ALLOW_UNALIGNED_MEMORY_ACCESS
+#define ALLOW_UNALIGNED_MEMORY_ACCESS 0
+#endif
 
-#else
+#if FIO_MEMCHAR
 
-/* a helper that seeks any char, converts it to NUL and returns 1 if found. */
-static inline uint8_t seek2ch(uint8_t **buffer, const uint8_t *const limit,
-                              const uint8_t c) {
-  /* this single char lookup is better when target is closer... */
+/**
+ * This seems to be faster on some systems, especially for smaller distances.
+ *
+ * On newer systems, `memchr` should be faster.
+ */
+static inline int seek2ch(uint8_t **buffer, register uint8_t *const limit,
+                          const uint8_t c) {
   if (**buffer == c) {
+#if HTTP1_PARSER_CONVERT_EOL2NUL
     **buffer = 0;
+#endif
     return 1;
   }
 
-  uint64_t wanted = 0x0101010101010101ULL * c;
-  uint64_t *lpos = (uint64_t *)*buffer;
-  uint64_t *llimit = ((uint64_t *)limit) - 1;
+#if !ALLOW_UNALIGNED_MEMORY_ACCESS || !defined(__x86_64__)
+  /* too short for this mess */
+  if ((uintptr_t)limit <= 16 + ((uintptr_t)*buffer & (~(uintptr_t)7)))
+    goto finish;
 
-  for (; lpos < llimit; lpos++) {
-    const uint64_t eq = ~((*lpos) ^ wanted);
-    const uint64_t t0 = (eq & 0x7f7f7f7f7f7f7f7fllu) + 0x0101010101010101llu;
-    const uint64_t t1 = (eq & 0x8080808080808080llu);
+  /* align memory */
+  {
+    const uint8_t *alignment =
+        (uint8_t *)(((uintptr_t)(*buffer) & (~(uintptr_t)7)) + 8);
+    if (limit >= alignment) {
+      while (*buffer < alignment) {
+        if (**buffer == c) {
+#if HTTP1_PARSER_CONVERT_EOL2NUL
+          **buffer = 0;
+#endif
+          return 1;
+        }
+        *buffer += 1;
+      }
+    }
+  }
+  const uint8_t *limit64 = (uint8_t *)((uintptr_t)limit & (~(uintptr_t)7));
+#else
+  const uint8_t *limit64 = (uint8_t *)limit - 7;
+#endif
+  uint64_t wanted1 = 0x0101010101010101ULL * c;
+  for (; *buffer < limit64; *buffer += 8) {
+    const uint64_t eq1 = ~((*((uint64_t *)*buffer)) ^ wanted1);
+    const uint64_t t0 = (eq1 & 0x7f7f7f7f7f7f7f7fllu) + 0x0101010101010101llu;
+    const uint64_t t1 = (eq1 & 0x8080808080808080llu);
     if ((t0 & t1)) {
       break;
     }
   }
-
-  *buffer = (uint8_t *)lpos;
+#if !defined(__x86_64__)
+finish:
+#endif
   while (*buffer < limit) {
     if (**buffer == c) {
+#if HTTP1_PARSER_CONVERT_EOL2NUL
       **buffer = 0;
+#endif
       return 1;
     }
     (*buffer)++;
@@ -72,6 +86,26 @@ static inline uint8_t seek2ch(uint8_t **buffer, const uint8_t *const limit,
   return 0;
 }
 
+#else
+
+/* a helper that seeks any char, converts it to NUL and returns 1 if found. */
+inline static uint8_t seek2ch(uint8_t **pos, uint8_t *const limit, uint8_t ch) {
+  /* This is library based alternative that is sometimes slower  */
+  if (*pos >= limit || **pos == ch) {
+    return 0;
+  }
+  uint8_t *tmp = memchr(*pos, ch, limit - (*pos));
+  if (tmp) {
+    *pos = tmp;
+#if HTTP1_PARSER_CONVERT_EOL2NUL
+    *tmp = 0;
+#endif
+    return 1;
+  }
+  *pos = limit;
+  return 0;
+}
+
 #endif
 
 /* a helper that seeks the EOL, converts it to NUL and returns it's length */
@@ -80,7 +114,9 @@ inline static uint8_t seek2eol(uint8_t **pos, uint8_t *const limit) {
   if (!seek2ch(pos, limit, '\n'))
     return 0;
   if ((*pos)[-1] == '\r') {
+#if HTTP1_PARSER_CONVERT_EOL2NUL
     (*pos)[-1] = 0;
+#endif
     return 2;
   }
   return 1;
@@ -110,11 +146,37 @@ inline static int consume_response_line(struct http1_fio_parser_args_s *args,
 inline static int consume_request_line(struct http1_fio_parser_args_s *args,
                                        uint8_t *start, uint8_t *end) {
   uint8_t *tmp = start;
+  uint8_t *host_start = NULL;
+  uint8_t *host_end = NULL;
   if (!seek2ch(&tmp, end, ' '))
     return -1;
   if (args->on_method(args->parser, (char *)start, tmp - start))
     return -1;
   tmp = start = tmp + 1;
+  if (start[0] == 'h' && start[1] == 't' && start[2] == 't' &&
+      start[3] == 'p') {
+    if (start[4] == ':' && start[5] == '/' && start[6] == '/') {
+      /* Request URI is in long form... emulate Host header instead. */
+      tmp = host_end = host_start = (start += 7);
+    } else if (start[4] == 's' && start[5] == ':' && start[6] == '/' &&
+               start[7] == '/') {
+      /* Secure request is in long form... emulate Host header instead. */
+      tmp = host_end = host_start = (start += 8);
+    } else
+      goto review_path;
+    if (!seek2ch(&tmp, end, ' '))
+      return -1;
+    *tmp = ' ';
+    if (!seek2ch(&host_end, tmp, '/')) {
+      if (args->on_path(args->parser, "/", 1))
+        return -1;
+      goto start_version;
+    }
+    host_end[0] = '/';
+    start = host_end;
+  }
+review_path:
+  tmp = start;
   if (seek2ch(&tmp, end, '?')) {
     if (args->on_path(args->parser, (char *)start, tmp - start))
       return -1;
@@ -131,62 +193,65 @@ inline static int consume_request_line(struct http1_fio_parser_args_s *args,
     if (args->on_path(args->parser, (char *)start, tmp - start))
       return -1;
   }
+start_version:
   start = tmp + 1;
-  if (start + 7 >= end)
+  if (start + 5 >= end) /* require "HTTP/" */
     return -1;
   if (args->on_http_version(args->parser, (char *)start, end - start))
     return -1;
+  /* */
+  if (host_start && args->on_header(args->parser, "host", 4, (char *)host_start,
+                                    host_end - host_start))
+    return -1;
   return 0;
 }
 
 inline static int consume_header(struct http1_fio_parser_args_s *args,
                                  uint8_t *start, uint8_t *end) {
-  uint8_t t2 = 1;
-  uint8_t *tmp = start;
+  uint8_t *end_name = start;
   /* divide header name from data */
-  if (!seek2ch(&tmp, end, ':'))
+  if (!seek2ch(&end_name, end, ':'))
     return -1;
 #if HTTP_HEADERS_LOWERCASE
-  for (uint8_t *t3 = start; t3 < tmp; t3++) {
-    *t3 = tolower(*t3);
+  for (uint8_t *t = start; t < end_name; t++) {
+    *t = tolower(*t);
   }
 #endif
-
-  tmp++;
-  if (tmp[0] == ' ') {
-    tmp++;
-    t2++;
+  uint8_t *start_value = end_name + 1;
+  if (start_value[0] == ' ') {
+    start_value++;
   };
-#if HTTP_HEADERS_LOWERCASE
-  if ((tmp - start) - t2 == 14 &&
+#if ALLOW_UNALIGNED_MEMORY_ACCESS && HTTP_HEADERS_LOWERCASE
+  /* enable this section to test unaligned memory access */
+  if ((end_name - start) == 14 &&
       *((uint64_t *)start) == *((uint64_t *)"content-") &&
       *((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 &&
+    args->parser->state.content_length = atol((char *)start_value);
+  } else if ((end_name - start) == 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")) {
+             *((uint32_t *)start_value) == *((uint32_t *)"chun") &&
+             *((uint32_t *)(start_value + 3)) == *((uint32_t *)"nked")) {
     /* handle the special `transfer-encoding: chunked` header */
     args->parser->state.reserved |= 64;
-  } else if ((tmp - start) - t2 == 7 &&
+  } else if ((end_name - start) == 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 &&
+  if ((end_name - start) == 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 &&
+    args->parser->state.content_length = atol((char *)start_value);
+  } else if ((end_name - start) == 17 &&
              HEADER_NAME_IS_EQ((char *)start, "transfer-encoding", 17) &&
-             memcmp(tmp, "chunked", 7)) {
+             memcmp(start_value, "chunked", 7)) {
     /* handle the special `transfer-encoding: chunked` header */
     args->parser->state.reserved |= 64;
-  } else if ((tmp - start) - t2 == 7 &&
+  } else if ((end_name - start) == 7 &&
              HEADER_NAME_IS_EQ((char *)start, "trailer", 7)) {
     /* chunked data with trailer... */
     args->parser->state.reserved |= 64;
@@ -194,8 +259,8 @@ inline static int consume_header(struct http1_fio_parser_args_s *args,
   }
 #endif
   /* perform callback */
-  if (args->on_header(args->parser, (char *)start, (tmp - start) - t2,
-                      (char *)tmp, end - tmp))
+  if (args->on_header(args->parser, (char *)start, (end_name - start),
+                      (char *)start_value, end - start_value))
     return -1;
   return 0;
 }
@@ -228,14 +293,16 @@ inline static int consume_body_chunked(struct http1_fio_parser_args_s *args,
   while (*start < stop) {
     if (args->parser->state.content_length == 0) {
       size_t eol_len;
+      /* consume seperator */
+      while (*start < stop && (**start == '\n' || **start == '\r'))
+        ++(*start);
       /* 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)) {
+      if (*start + eol_len > end && (*start = end) && !seek2eol(&end, stop)) {
         return 0;
       }
       args->parser->state.content_length = 0 - strtol((char *)*start, NULL, 16);
@@ -266,8 +333,6 @@ inline static int consume_body_chunked(struct http1_fio_parser_args_s *args,
     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;
 }
@@ -300,9 +365,8 @@ HTTP/1.1 parsre function
 #endif
 
 size_t http1_fio_parser_fn(struct http1_fio_parser_args_s *args) {
-  if (DEBUG) {
-    assert(args->parser && args->buffer);
-  }
+  assert(args->parser && args->buffer);
+  args->parser->state.next = NULL;
   uint8_t *start = args->buffer;
   uint8_t *end = start;
   uint8_t *const stop = start + args->length;
@@ -325,7 +389,8 @@ re_eval:
     if (!(eol_len = seek2eol(&end, stop)))
       return CONSUMED;
 
-    if (((uint32_t *)start)[0] == ((uint32_t *)"HTTP")[0]) {
+    if (start[0] == 'H' && start[1] == 'T' && start[2] == 'T' &&
+        start[3] == 'P') {
       /* HTTP response */
       if (consume_response_line(args, start, end - eol_len + 1))
         goto error;
@@ -341,32 +406,39 @@ re_eval:
   /* headers */
   case 1:
     do {
+      if (start + 1 >= stop)
+        return CONSUMED; /* buffer ended on header line */
+      if (*start == '\r' || *start == '\n') {
+        goto finished_headers; /* empty line, end of headers */
+      }
       if (!(eol_len = seek2eol(&end, stop)))
         return CONSUMED;
-      /* test for header ending */
-      if (*start == 0)
-        goto finished_headers; /* break the do..while loop, not the switch
-                                  statement */
       if (consume_header(args, start, end - eol_len + 1))
         goto error;
       end = start = end + 1;
     } while ((args->parser->state.reserved & 2) == 0);
   finished_headers:
-    end = start = end + 1;
+    ++start;
+    if (*start == '\n')
+      ++start;
+    end = start;
     args->parser->state.reserved |= 2;
   /* fallthrough */
   /* request body */
   case 3: { /*  2 | 1 == 3 */
     int t3 = consume_body(args, &start);
-    if (t3 == -1)
+    switch (t3) {
+    case -1:
       goto error;
-    if (t3 == -2)
+    case -2:
       goto re_eval;
+    }
     break;
   }
   }
   /* are we done ? */
   if (args->parser->state.reserved & 4) {
+    args->parser->state.next = start;
     if (((args->parser->state.reserved & 128) ? args->on_response
                                               : args->on_request)(args->parser))
       goto error;

data/ext/iodine/http1_parser.h

@@ -1,6 +1,6 @@
 #ifndef H_HTTP1_PARSER_H
 /*
-Copyright: Boaz segev, 2017
+Copyright: Boaz Segev, 2017-2018
 License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
@@ -21,11 +21,19 @@ to maintain and that could be used for an HTTP/1.x client as well.
 #include <sys/types.h>
 
 #ifndef HTTP_HEADERS_LOWERCASE
-/** when defined, HTTP headers will be converted to lowercase and header
- * searches will be case sensitive. */
+/**
+ * when defined, HTTP headers will be converted to lowercase and header
+ * searches will be case sensitive.
+ *
+ * this is required by facil.io and helps with HTTP/2 compatibility.
+ */
 #define HTTP_HEADERS_LOWERCASE 1
 #endif
 
+#ifndef HTTP1_PARSER_CONVERT_EOL2NUL
+#define HTTP1_PARSER_CONVERT_EOL2NUL 0
+#endif
+
 #if HTTP_HEADERS_LOWERCASE
 
 #define HEADER_NAME_IS_EQ(var_name, const_name, len)                           \
@@ -41,7 +49,8 @@ typedef struct http1_parser_s {
   struct http1_parser_protected_read_only_state_s {
     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 */
+    uint8_t *next;    /* the known position for the end of request/response */
+    uint8_t reserved; /* for internal use */
   } state;
 } http1_parser_s;
 
@@ -104,6 +113,8 @@ size_t http1_fio_parser_fn(struct http1_fio_parser_args_s *args);
 
 static inline __attribute__((unused)) size_t
 http1_fio_parser(struct http1_fio_parser_args_s args) {
+  if (!args.length)
+    return 0;
   return http1_fio_parser_fn(&args);
 }
 #if __STDC_VERSION__ >= 199901L