iodine 0.4.7 → 0.4.8

data/ext/iodine/http1_parser.c

@@ -0,0 +1,276 @@
+/*
+Copyright: Boaz segev, 2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#ifndef __GNU_SOURCE
+#define __GNU_SOURCE
+#endif
+
+#include "http1_parser.h"
+#include <ctype.h>
+#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;
+}
+
+#else
+
+/* 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... */
+  if (**buffer == c) {
+    **buffer = 0;
+    return 1;
+  }
+
+  uint64_t wanted = 0x0101010101010101ULL * c;
+  uint64_t *lpos = (uint64_t *)*buffer;
+  uint64_t *llimit = ((uint64_t *)limit) - 1;
+
+  for (; lpos < llimit; lpos++) {
+    const uint64_t eq = ~((*lpos) ^ wanted);
+    const uint64_t t0 = (eq & 0x7f7f7f7f7f7f7f7fllu) + 0x0101010101010101llu;
+    const uint64_t t1 = (eq & 0x8080808080808080llu);
+    if ((t0 & t1)) {
+      break;
+    }
+  }
+
+  *buffer = (uint8_t *)lpos;
+  while (*buffer < limit) {
+    if (**buffer == c) {
+      **buffer = 0;
+      return 1;
+    }
+    (*buffer)++;
+  }
+  return 0;
+}
+
+#endif
+
+/* a helper that seeks the EOL, converts it to NUL and returns it's length */
+inline static uint8_t seek2eol(uint8_t **pos, uint8_t *const limit) {
+  /* single char lookup using memchr might be better when target is far... */
+  if (!seek2ch(pos, limit, '\n'))
+    return 0;
+  if ((*pos)[-1] == '\r') {
+    (*pos)[-1] = 0;
+    return 2;
+  }
+  return 1;
+}
+
+/* *****************************************************************************
+HTTP/1.1 parsre stages
+***************************************************************************** */
+
+inline static int consume_response_line(struct http1_fio_parser_args_s *args,
+                                        uint8_t *start, uint8_t *end) {
+  args->parser->state.reserved |= 128;
+  uint8_t *tmp = start;
+  if (!seek2ch(&tmp, end, ' '))
+    return -1;
+  if (args->on_http_version(args->parser, (char *)start, tmp - start))
+    return -1;
+  tmp = start = tmp + 1;
+  if (!seek2ch(&tmp, end, ' '))
+    return -1;
+  if (args->on_status(args->parser, atol((char *)start), (char *)(tmp + 1),
+                      end - tmp))
+    return -1;
+  return 0;
+}
+
+inline static int consume_request_line(struct http1_fio_parser_args_s *args,
+                                       uint8_t *start, uint8_t *end) {
+  uint8_t *tmp = start;
+  if (!seek2ch(&tmp, end, ' '))
+    return -1;
+  if (args->on_method(args->parser, (char *)start, tmp - start))
+    return -1;
+  tmp = start = tmp + 1;
+  if (seek2ch(&tmp, end, '?')) {
+    if (args->on_path(args->parser, (char *)start, tmp - start))
+      return -1;
+    tmp = start = tmp + 1;
+    if (!seek2ch(&tmp, end, ' '))
+      return -1;
+    if (tmp - start > 0 &&
+        args->on_query(args->parser, (char *)start, tmp - start))
+      return -1;
+  } else {
+    tmp = start;
+    if (!seek2ch(&tmp, end, ' '))
+      return -1;
+    if (args->on_path(args->parser, (char *)start, tmp - start))
+      return -1;
+  }
+  start = tmp + 1;
+  if (start + 7 >= end)
+    return -1;
+  if (args->on_http_version(args->parser, (char *)start, end - 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;
+  /* divide header name from data */
+  if (!seek2ch(&tmp, end, ':'))
+    return -1;
+#if HTTP_HEADERS_LOWERCASE
+  for (uint8_t *t3 = start; t3 < tmp; t3++) {
+    *t3 = tolower(*t3);
+  }
+#endif
+
+  tmp++;
+  if (tmp[0] == ' ') {
+    tmp++;
+    t2++;
+  };
+#if HTTP_HEADERS_LOWERCASE
+  if ((tmp - start) - t2 == 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 == 14 &&
+      HEADER_NAME_IS_EQ((char *)start, "content-length", 14)) {
+    /* handle the special `content-length` header */
+    args->parser->state.content_length = atol((char *)tmp);
+  }
+#endif
+  /* perform callback */
+  if (args->on_header(args->parser, (char *)start, (tmp - start) - t2,
+                      (char *)tmp, end - tmp))
+    return -1;
+  return 0;
+}
+
+/* *****************************************************************************
+HTTP/1.1 parsre function
+***************************************************************************** */
+
+size_t http1_fio_parser_fn(struct http1_fio_parser_args_s *args) {
+  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)) {
+
+  /* request / response line */
+  case 0:
+    /* clear out any leadinng white space */
+    while (*start == '\r' || *start == '\r' || *start == ' ' || *start == 0) {
+      start++;
+    }
+    end = start;
+    /* make sure the whole line is available*/
+    if (!(eol_len = seek2eol(&end, stop)))
+      return CONSUMED;
+
+    if (start[0] >= '1' && start[0] <= '9') {
+      /* HTTP response */
+      if (consume_response_line(args, start, end - eol_len + 1))
+        goto error;
+    } else {
+      /* HTTP request */
+      if (consume_request_line(args, start, end - eol_len + 1))
+        goto error;
+    }
+    end = start = end + 1;
+    args->parser->state.reserved |= 1;
+
+  /* fallthrough */
+  /* headers */
+  case 1:
+    do {
+      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;
+    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))
+      goto error;
+    args->parser->state.read += (end - start);
+    start = end;
+    if (args->parser->state.content_length <= args->parser->state.read)
+      goto finish;
+    return CONSUMED;
+    break;
+  }
+
+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

data/ext/iodine/http1_parser.h

@@ -0,0 +1,111 @@
+#ifndef H_HTTP1_PARSER_H
+/*
+Copyright: Boaz segev, 2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+
+/**
+This is a callback based parser. It parses the skeleton of the HTTP/1.x protocol
+and leaves most of the work (validation, error checks, etc') to the callbacks.
+
+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 <stdint.h>
+#include <stdlib.h>
+
+#ifndef HTTP_HEADERS_LOWERCASE
+/** when defined, HTTP headers will be converted to lowercase and header
+ * searches will be case sensitive. */
+#define HTTP_HEADERS_LOWERCASE 1
+#endif
+
+#if HTTP_HEADERS_LOWERCASE
+
+#define HEADER_NAME_IS_EQ(var_name, const_name, len)                           \
+  (!memcmp((var_name), (const_name), (len)))
+#else
+#define HEADER_NAME_IS_EQ(var_name, const_name, len)                           \
+  (!strncasecmp((var_name), (const_name), (len)))
+#endif
+
+/** this struct contains the state of the parser. */
+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;
+  } state;
+} http1_parser_s;
+
+/**
+ * Available options for the parsing function.
+ *
+ * Callbacks should return 0 unless an error occured.
+ */
+struct http1_fio_parser_args_s {
+  /** REQUIRED: the parser object that manages the parser's state. */
+  http1_parser_s *parser;
+  /** REQUIRED: the data to be parsed. */
+  void *buffer;
+  /** REQUIRED: the length of the data to be parsed. */
+  size_t length;
+  /** called when a request was received. */
+  int (*const on_request)(http1_parser_s *parser);
+  /** called when a response was received. */
+  int (*const on_response)(http1_parser_s *parser);
+  /** called when a request method is parsed. */
+  int (*const on_method)(http1_parser_s *parser, char *method,
+                         size_t method_len);
+  /** called when a response status is parsed. the status_str is the string
+   * without the prefixed numerical status indicator.*/
+  int (*const on_status)(http1_parser_s *parser, size_t status,
+                         char *status_str, size_t len);
+  /** called when a request path (excluding query) is parsed. */
+  int (*const on_path)(http1_parser_s *parser, char *path, size_t path_len);
+  /** called when a request path (excluding query) is parsed. */
+  int (*const on_query)(http1_parser_s *parser, char *query, size_t query_len);
+  /** called when a the HTTP/1.x version is parsed. */
+  int (*const on_http_version)(http1_parser_s *parser, char *version,
+                               size_t len);
+  /** called when a header is parsed. */
+  int (*const on_header)(http1_parser_s *parser, char *name, size_t name_len,
+                         char *data, size_t data_len);
+  /** called when a body chunk is parsed. */
+  int (*const on_body_chunk)(http1_parser_s *parser, char *data,
+                             size_t data_len);
+  /** called when a protocol error occured. */
+  int (*const on_error)(http1_parser_s *parser);
+};
+
+/**
+ * Returns the amount of data actually consumed by the parser.
+ *
+ * The value 0 indicates there wasn't enough data to be parsed and the same
+ * buffer (with more data) should be resubmitted.
+ *
+ * A value smaller than the buffer size indicates that EITHER a request /
+ * response was detected OR that the leftover could not be consumed because more
+ * data was required.
+ *
+ * Simply resubmit the reminder of the data to continue parsing.
+ *
+ * A request / response callback automatically stops the parsing process,
+ * allowing the user to adjust or refresh the state of the data.
+ */
+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) {
+  return http1_fio_parser_fn(&args);
+}
+#if __STDC_VERSION__ >= 199901L
+#define http1_fio_parser(...)                                                  \
+  http1_fio_parser((struct http1_fio_parser_args_s){__VA_ARGS__})
+#endif
+
+#endif

data/ext/iodine/http1_response.c

@@ -85,11 +85,11 @@ initialize:
   return (http_response_s *)http1_response_pool.pool_mem;
 }
 
-static void http1_response_deffered_destroy(void *rs_, void *ignr) {
+static void http1_response_deferred_destroy(void *rs_, void *ignr) {
   (void)(ignr);
   http1_response_s *rs = rs_;
   if (spn_trylock(&rs->lock)) {
-    defer(http1_response_deffered_destroy, rs, NULL);
+    defer(http1_response_deferred_destroy, rs, NULL);
     return;
   }
   rs->use_count -= 1;
@@ -118,7 +118,7 @@ use_free:
 /** Destroys the response object. No data is sent.*/
 void http1_response_destroy(http_response_s *rs) {
   ((http1_response_s *)rs)->dest_count++;
-  http1_response_deffered_destroy(rs, NULL);
+  http1_response_deferred_destroy(rs, NULL);
 }
 
 /* *****************************************************************************
@@ -162,15 +162,15 @@ static void http1_response_finalize_headers(http1_response_s *rs) {
       rs->response.date = rs->response.last_modified;
     struct tm t;
     /* date header */
-    http_gmtime(&rs->response.date, &t);
     h1p_protected_copy(rs, "Date: ", 6);
-    rs->buffer_end += http_date2str(rs->buffer + rs->buffer_end, &t);
+    rs->buffer_end +=
+        http_time2str(rs->buffer + rs->buffer_end, rs->response.date);
     rs->buffer[rs->buffer_end++] = '\r';
     rs->buffer[rs->buffer_end++] = '\n';
     /* last-modified header */
-    http_gmtime(&rs->response.last_modified, &t);
     h1p_protected_copy(rs, "Last-Modified: ", 15);
-    rs->buffer_end += http_date2str(rs->buffer + rs->buffer_end, &t);
+    rs->buffer_end +=
+        http_time2str(rs->buffer + rs->buffer_end, rs->response.last_modified);
     rs->buffer[rs->buffer_end++] = '\r';
     rs->buffer[rs->buffer_end++] = '\n';
   }
@@ -229,7 +229,7 @@ void http1_response_finish(http_response_s *rs) {
     http1_response_send_headers((http1_response_s *)rs);
   if (rs->should_close)
     sock_close(rs->fd);
-  http1_response_deffered_destroy(rs, NULL);
+  http1_response_deferred_destroy(rs, NULL);
 }
 
 /* *****************************************************************************

data/ext/iodine/http_response.c

@@ -485,20 +485,6 @@ static void http_response_log_finish(http_response_s *response) {
           ? ((get_clock_mili() - response->clock_start) / CLOCK_RESOLUTION)
           : 0;
 
-  /* pre-print log message every 1 or 2 seconds or so. */
-  static __thread time_t cached_tick;
-  static __thread char cached_httpdate[48];
-  static __thread size_t chached_len;
-  time_t last_tick = facil_last_tick();
-  if (last_tick > cached_tick) {
-    struct tm tm;
-    cached_tick = last_tick | 1;
-    http_gmtime(&last_tick, &tm);
-    chached_len = http_date2str(cached_httpdate, &tm);
-    fprintf(stderr, "Updated date cache to (%lu) %s\n", chached_len,
-            cached_httpdate);
-  }
-
   // TODO Guess IP address from headers (forwarded) where possible
   sock_peer_addr_s addrinfo = sock_peer_addr(response->fd);
 
@@ -519,8 +505,7 @@ static void http_response_log_finish(http_response_s *response) {
   }
   memcpy(buffer + pos, " - - [", 6);
   pos += 6;
-  memcpy(buffer + pos, cached_httpdate, chached_len);
-  pos += chached_len;
+  pos += http_time2str(buffer + pos, facil_last_tick());
   buffer[pos++] = ']';
   buffer[pos++] = ' ';
   buffer[pos++] = '"';