pico_http_parser 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 417f57e6c7289be7606e9fdda1b65346751f3c10
-  data.tar.gz: 420957b9c7d8ed9338c29d20030109ea0f6c17c0
+  metadata.gz: 984780783c1c9bfce3fdcc058187bfe3fd553ceb
+  data.tar.gz: 2ad841f14ab2c12a79211634ae6758e22009e0f8
 SHA512:
-  metadata.gz: 1cd7184656ea42efb5f22aa27a42d30ed381f241c665859fbc9e94937195248db6216a4be25903799841148c51842fd2fa93bf0ddf39b699cb48192eb44d0e1a
-  data.tar.gz: 8656caa1f569d72acc097392e67c9316e26c7aa5546d165d1d600566e80a6e1057660696e8096fb00db9a6b7a88860fa890d8a801dbdbedf9f877c4f06e51f62
+  metadata.gz: c3dca6150fc78bd0946f4787b7f91dad54a7942ff7bc0f301a7580e277851fed9256008f740d930c4e757055230066af2c0d5ea72c3283f4d99db2f09a8ef1c4
+  data.tar.gz: 623cdcfc79c5c5cec7293e72996a92826a64b1e3d6fa05b1449631067b8cd99c2e80685b6c648e898042aa9813af5c7cb117ef80134c09ba32f28f942ebbefae

data/benchmark/benchmark.rb

@@ -2,13 +2,19 @@ require File.expand_path(File.dirname(__FILE__) + '/bench_helper')
 
 require 'pico_http_parser'
 
-# request_body = "GET /foo/bar/baz.html?key=value HTTP/1.0\r\nHost: blooperblorp\r\n\r\n"
-request_body = "GET /foo/bar/baz.html?key=value HTTP/1.0\r\nHost: blooperblorp\r\nCookie: foobar\r\nX-Forwared-For: 127.0.0.1\r\n\r\n"
-# request_body = "GET /foo/bar/baz.html?key=value HTTP/1.0\r\n\r\n"
+request_bodys = [
+  "GET /foo/bar/baz.html?key=value HTTP/1.0\r\nHost: blooperblorp\r\n\r\n",
+  "GET /foo/bar/baz.html?key=value HTTP/1.0\r\nHost: blooperblorp\r\nUser-Agent: Mozilla/5.0\r\n\r\n",
+  "GET /foo/bar/baz.html?key=value HTTP/1.0\r\nHost: blooperblorp\r\nCookie: foobar\r\nX-Forwarded-For: 127.0.0.1\r\nUser-Agent: Mozilla/5.0\r\n\r\n",
+  "GET /foo/bar/baz.html?key=value HTTP/1.0\r\nHost: blooperblorp\r\nCookie: foobar\r\nX-Forwarded-For: 127.0.0.1\r\nUser-Agent: Mozilla/5.0\r\nAccept: X-5\r\nConnection: XXXXXX-6\r\nReferer: XXXXXXXX-7\r\nAccept-Encoding: XXXXXXX8\r\nCache-Control: XXXXXXXX9\r\nIf-Modified-Since: XXXXXXXXXXXXXXX10\r\n\r\n",
+  "GET /foo/bar/baz.html?key=value HTTP/1.0\r\n\r\n"
+];
 
+request_bodys.each do |request_body|
+puts("benchmark #{request_body}");
 Benchmark.ips do |x|
   x.time = 5
-  x.warmup = 2
+  x.warmup = 1
 
   x.report("PicoHTTPParser") {
     env = {}
@@ -21,7 +27,7 @@ Benchmark.ips do |x|
     x.report("Unicorn's HttpParser") {
       parser = HttpParser.new
       parser.buf << request_body
-      parser.parse
+      env = parser.parse
     }
   rescue LoadError
     puts("Can't benchmark unicorn as it couldn't be loaded.")
@@ -29,3 +35,5 @@ Benchmark.ips do |x|
 
   x.compare!
 end
+end
+

data/ext/pico_http_parser/pico_http_parser.c

@@ -14,6 +14,11 @@ static VALUE script_name_key;
 static VALUE server_protocol_key;
 static VALUE query_string_key;
 
+static VALUE vacant_string_val;
+
+static VALUE http10_val;
+static VALUE http11_val;
+
 struct common_header {
   const char * name;
   size_t name_len;
@@ -147,8 +152,8 @@ VALUE phr_parse_http_request(VALUE self, VALUE buf, VALUE envref)
   char tmp[MAX_HEADER_NAME_LEN + sizeof("HTTP_") - 1];
   VALUE last_value;
 
-  buf_str = StringValuePtr(buf);
-  buf_len = strlen(buf_str);
+  buf_str = RSTRING_PTR(buf);
+  buf_len = RSTRING_LEN(buf);
   num_headers = MAX_HEADERS;
   ret = phr_parse_request(buf_str, buf_len, &method, &method_len, &path,
                           &path_len, &minor_version, headers, &num_headers, 0);
@@ -157,10 +162,8 @@ VALUE phr_parse_http_request(VALUE self, VALUE buf, VALUE envref)
 
   rb_hash_aset(envref, request_method_key, rb_str_new(method,method_len));
   rb_hash_aset(envref, request_uri_key, rb_str_new(path, path_len));
-  rb_hash_aset(envref, script_name_key, rb_str_new2(""));
-  strcpy(tmp, "HTTP/1.");
-  tmp[7] = 48 + ((minor_version > 1 || minor_version < 0 ) ? 0 : minor_version);
-  rb_hash_aset(envref, server_protocol_key, rb_str_new(tmp, sizeof("HTTP/1.0") - 1));
+  rb_hash_aset(envref, script_name_key, vacant_string_val);
+  rb_hash_aset(envref, server_protocol_key, (minor_version == 1) ? http11_val : http10_val);
 
   /* PATH_INFO QUERY_STRING */
   path_len = find_ch(path, path_len, '#'); /* strip off all text after # after storing request_uri */
@@ -172,7 +175,7 @@ VALUE phr_parse_http_request(VALUE self, VALUE buf, VALUE envref)
   }
   if (question_at != path_len) ++question_at;
   rb_hash_aset(envref, query_string_key, rb_str_new(path + question_at, path_len - question_at));
-
+ 
   last_value = Qnil;
   for (i = 0; i < num_headers; ++i) {
     if (headers[i].name != NULL) {
@@ -200,6 +203,7 @@ VALUE phr_parse_http_request(VALUE self, VALUE buf, VALUE envref)
             env_key = rb_str_new(name, name_len);
         }
       }
+      
       slot = rb_hash_aref(envref, env_key);
       if ( slot != Qnil ) {
         rb_str_cat2(slot, ", ");
@@ -209,11 +213,13 @@ VALUE phr_parse_http_request(VALUE self, VALUE buf, VALUE envref)
         rb_hash_aset(envref, env_key, slot);
         last_value = slot;
       }
+      
     } else {
       /* continuing lines of a mulitiline header */
       if ( last_value != Qnil )
         rb_str_cat(last_value, headers[i].value, headers[i].value_len);
     }
+    
   }
 
  done:
@@ -247,6 +253,13 @@ void Init_pico_http_parser()
   set_common_header("USER-AGENT",sizeof("USER-AGENT") - 1, 0);
   set_common_header("X-FORWARDED-FOR",sizeof("X-FORWARDED-FOR") - 1, 0);
 
+  http10_val = rb_obj_freeze(rb_str_new2("HTTP/1.0"));
+  rb_gc_register_address(&http10_val);
+  http11_val = rb_obj_freeze(rb_str_new2("HTTP/1.1"));
+  rb_gc_register_address(&http11_val);
+  vacant_string_val = rb_obj_freeze(rb_str_new("",0));
+  rb_gc_register_address(&vacant_string_val);
+
   cPicoHTTPParser = rb_const_get(rb_cObject, rb_intern("PicoHTTPParser"));
   rb_define_module_function(cPicoHTTPParser, "parse_http_request", phr_parse_http_request, 2);
 }

data/ext/pico_http_parser/picohttpparser/.clang-format

@@ -0,0 +1,6 @@
+# requires clang-format >= 3.6
+BasedOnStyle: "LLVM"
+IndentWidth: 4
+ColumnLimit: 132
+BreakBeforeBraces: Linux
+AllowShortFunctionsOnASingleLine: None

data/ext/pico_http_parser/picohttpparser/Jamfile

@@ -0,0 +1,7 @@
+project picohttpparser ;
+
+lib picohttpparser : picohttpparser.c ;
+
+unit-test test
+	: picohttpparser picotest/picotest.c test.c
+	: <testing.launcher>prove ;

data/ext/pico_http_parser/picohttpparser/README.md

@@ -14,6 +14,98 @@ Check out [test.c] to find out how to use the parser.
 
 The software is dual-licensed under the Perl License or the MIT License.
 
+Usage
+-----
+
+The library exposes four functions: `phr_parse_request`, `phr_parse_response`, `phr_parse_headers`, `phr_decode_chunked`.
+
+### phr_parse_request
+
+The example below reads an HTTP request from socket `sock` using `read(2)`, parses it using `phr_parse_request`, and prints the details.
+
+```
+char buf[4096], *method, *path;
+int pret, minor_version;
+struct phr_header headers[100];
+size_t buflen = 0, prevbuflen = 0, method_len, path_len, num_headers;
+ssize_t rret;
+
+while (1) {
+    /* read the request */
+    while ((rret = read(sock, buf + buflen, sizeof(buf) - buflen)) == -1 && errno == EINTR)
+        ;
+    if (rret <= 0)
+        return IOError;
+    prevbuflen = buflen;
+    buflen += rret;
+    /* parse the request */
+    num_headers = sizeof(headers) / sizeof(headers[0]);
+    pret = phr_parse_request(buf, buflen, &method, &method_len, &path, &path_len,
+                             &minor_version, headers, &num_headers, prevbuflen);
+    if (pret > 0)
+        break; /* successfully parsed the request */
+    else if (pret == -1)
+        return ParseError;
+    /* request is incomplete, continue the loop */
+    assert(pret == -2);
+    if (buflen == sizeof(buf))
+        return RequestIsTooLongError;
+}
+
+printf("request is %d bytes long\n", pret);
+printf("method is %.*s\n", (int)method_len, method);
+printf("path is %.*s\n", (int)path_len, path);
+printf("HTTP version is 1.%d\n", minor_version);
+printf("headers:\n");
+for (i = 0; i != num_headers; ++i) {
+    printf("%.*s: %.*s\n", (int)headers[i].name_len, headers[i].name,
+           (int)headers[i].value_len, headers[i].value);
+}
+```
+
+### phr_parse_response, phr_parse_headers
+
+`phr_parse_response` and `phr_parse_headers` provide similar interfaces as `phr_parse_request`.  `phr_parse_response` parses an HTTP response, and `phr_parse_headers` parses the headers only.
+
+### phr_decode_chunked
+
+The example below decodes incoming data in chunked-encoding.  The data is decoded in-place.
+
+```
+struct phr_chunked_decoder decoder = {}; /* zero-clear */
+char *buf = malloc(4096);
+size_t size = 0, capacity = 4096, rsize;
+ssize_t rret, pret;
+
+/* set consume_trailer to 1 to discard the trailing header, or the application
+ * should call phr_parse_headers to parse the trailing header */
+decoder.consume_trailer = 1;
+
+do {
+    /* expand the buffer if necessary */
+    if (size == capacity) {
+        capacity *= 2;
+        buf = realloc(buf, capacity);
+        assert(buf != NULL);
+    }
+    /* read */
+    while ((rret = read(sock, buf + size, capacity - size)) == -1 && errno == EINTR)
+        ;
+    if (rret <= 0)
+        return IOError;
+    /* decode */
+    rsize = rret;
+    pret = phr_decode_chunked(&decoder, buf + size, &rsize);
+    if (pret == -1)
+        return ParseError;
+    size += rsize;
+} while (pret == -2);
+
+/* successfully decoded the chunked data */
+assert(pret >= 0);
+printf("decoded data is at %p (%zu bytes)\n", buf, size);
+```
+
 Benchmark
 ---------
 

data/ext/pico_http_parser/picohttpparser/bench.c

@@ -28,26 +28,39 @@
 #include <stdio.h>
 #include "picohttpparser.h"
 
-#define REQ "GET /wp-content/uploads/2010/03/hello-kitty-darth-vader-pink.jpg HTTP/1.1\r\nHost: www.kittyhell.com\r\nUser-Agent: Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.6; ja-JP-mac; rv:1.9.2.3) Gecko/20100401 Firefox/3.6.3 Pathtraq/0.9\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: ja,en-us;q=0.7,en;q=0.3\r\nAccept-Encoding: gzip,deflate\r\nAccept-Charset: Shift_JIS,utf-8;q=0.7,*;q=0.7\r\nKeep-Alive: 115\r\nConnection: keep-alive\r\nCookie: wp_ozh_wsa_visits=2; wp_ozh_wsa_visit_lasttime=xxxxxxxxxx; __utma=xxxxxxxxx.xxxxxxxxxx.xxxxxxxxxx.xxxxxxxxxx.xxxxxxxxxx.x; __utmz=xxxxxxxxx.xxxxxxxxxx.x.x.utmccn=(referral)|utmcsr=reader.livedoor.com|utmcct=/reader/|utmcmd=referral\r\n\r\n"
+#define REQ                                                                                                                        \
+    "GET /wp-content/uploads/2010/03/hello-kitty-darth-vader-pink.jpg HTTP/1.1\r\n"                                                \
+    "Host: www.kittyhell.com\r\n"                                                                                                  \
+    "User-Agent: Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.6; ja-JP-mac; rv:1.9.2.3) Gecko/20100401 Firefox/3.6.3 "             \
+    "Pathtraq/0.9\r\n"                                                                                                             \
+    "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n"                                                  \
+    "Accept-Language: ja,en-us;q=0.7,en;q=0.3\r\n"                                                                                 \
+    "Accept-Encoding: gzip,deflate\r\n"                                                                                            \
+    "Accept-Charset: Shift_JIS,utf-8;q=0.7,*;q=0.7\r\n"                                                                            \
+    "Keep-Alive: 115\r\n"                                                                                                          \
+    "Connection: keep-alive\r\n"                                                                                                   \
+    "Cookie: wp_ozh_wsa_visits=2; wp_ozh_wsa_visit_lasttime=xxxxxxxxxx; "                                                          \
+    "__utma=xxxxxxxxx.xxxxxxxxxx.xxxxxxxxxx.xxxxxxxxxx.xxxxxxxxxx.x; "                                                             \
+    "__utmz=xxxxxxxxx.xxxxxxxxxx.x.x.utmccn=(referral)|utmcsr=reader.livedoor.com|utmcct=/reader/|utmcmd=referral\r\n"             \
+    "\r\n"
 
 int main(void)
 {
-  const char* method;
-  size_t method_len;
-  const char* path;
-  size_t path_len;
-  int minor_version;
-  struct phr_header headers[32];
-  size_t num_headers;
-  int i, ret;
-  
-  for (i = 0; i < 10000000; i++) {
-    num_headers = sizeof(headers) / sizeof(headers[0]);
-    ret = phr_parse_request(REQ, sizeof(REQ) - 1, &method, &method_len, &path,
-                            &path_len, &minor_version, headers, &num_headers,
-                            0);
-    assert(ret == sizeof(REQ) - 1);
-  }
-  
-  return 0;
+    const char *method;
+    size_t method_len;
+    const char *path;
+    size_t path_len;
+    int minor_version;
+    struct phr_header headers[32];
+    size_t num_headers;
+    int i, ret;
+
+    for (i = 0; i < 10000000; i++) {
+        num_headers = sizeof(headers) / sizeof(headers[0]);
+        ret = phr_parse_request(REQ, sizeof(REQ) - 1, &method, &method_len, &path, &path_len, &minor_version, headers, &num_headers,
+                                0);
+        assert(ret == sizeof(REQ) - 1);
+    }
+
+    return 0;
 }

data/ext/pico_http_parser/picohttpparser/picohttpparser.c

@@ -24,409 +24,576 @@
  * IN THE SOFTWARE.
  */
 
+#include <assert.h>
 #include <stddef.h>
+#include <string.h>
 #ifdef __SSE4_2__
-# include <x86intrin.h>
+#ifdef _MSC_VER
+#include <nmmintrin.h>
+#else
+#include <x86intrin.h>
+#endif
 #endif
 #include "picohttpparser.h"
 
 /* $Id$ */
 
 #if __GNUC__ >= 3
-# define likely(x) __builtin_expect(!!(x), 1)
-# define unlikely(x) __builtin_expect(!!(x), 0)
+#define likely(x) __builtin_expect(!!(x), 1)
+#define unlikely(x) __builtin_expect(!!(x), 0)
+#else
+#define likely(x) (x)
+#define unlikely(x) (x)
+#endif
+
+#ifdef _MSC_VER
+#define ALIGNED(n) _declspec(align(n))
 #else
-# define likely(x) (x)
-# define unlikely(x) (x)
+#define ALIGNED(n) __attribute__((aligned(n)))
 #endif
 
-#define IS_PRINTABLE_ASCII(c) ((unsigned char)(c) - 040u < 0137u)
-
-#define CHECK_EOF() \
-  if (buf == buf_end) { \
-    *ret = -2; \
-    return NULL; \
-  }
-
-#define EXPECT_CHAR(ch) \
-  CHECK_EOF(); \
-  if (*buf++ != ch) { \
-    *ret = -1; \
-    return NULL; \
-  }
-
-#define ADVANCE_TOKEN(tok, toklen) do { \
-    const char* tok_start = buf; \
-    static const char ranges2[] __attribute__((aligned(16))) = "\000\040\177\177"; \
-    int found2; \
-    buf = findchar_fast(buf, buf_end, ranges2, sizeof(ranges2) - 1, &found2); \
-    if (! found2) { \
-      CHECK_EOF(); \
-    } \
-    while (1) { \
-      if (*buf == ' ') { \
-        break; \
-      } else if (unlikely(! IS_PRINTABLE_ASCII(*buf))) { \
-        if ((unsigned char)*buf < '\040' || *buf == '\177') { \
-          *ret = -1; \
-          return NULL; \
-        } \
-      } \
-      ++buf; \
-      CHECK_EOF(); \
-    } \
-    tok = tok_start; \
-    toklen = buf - tok_start; \
-  } while (0)
-
-static const char* token_char_map =
-  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
-  "\0\1\1\1\1\1\1\1\0\0\1\1\0\1\1\0\1\1\1\1\1\1\1\1\1\1\0\0\0\0\0\0"
-  "\0\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\1\1"
-  "\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\1\0\1\0"
-  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
-  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
-  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
-  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
-
-static const char* findchar_fast(const char* buf, const char* buf_end, const char *ranges, size_t ranges_size, int* found)
+#define IS_PRINTABLE_ASCII(c) ((unsigned char)(c)-040u < 0137u)
+
+#define CHECK_EOF()                                                                                                                \
+    if (buf == buf_end) {                                                                                                          \
+        *ret = -2;                                                                                                                 \
+        return NULL;                                                                                                               \
+    }
+
+#define EXPECT_CHAR(ch)                                                                                                            \
+    CHECK_EOF();                                                                                                                   \
+    if (*buf++ != ch) {                                                                                                            \
+        *ret = -1;                                                                                                                 \
+        return NULL;                                                                                                               \
+    }
+
+#define ADVANCE_TOKEN(tok, toklen)                                                                                                 \
+    do {                                                                                                                           \
+        const char *tok_start = buf;                                                                                               \
+        static const char ALIGNED(16) ranges2[] = "\000\040\177\177";                                                              \
+        int found2;                                                                                                                \
+        buf = findchar_fast(buf, buf_end, ranges2, sizeof(ranges2) - 1, &found2);                                                  \
+        if (!found2) {                                                                                                             \
+            CHECK_EOF();                                                                                                           \
+        }                                                                                                                          \
+        while (1) {                                                                                                                \
+            if (*buf == ' ') {                                                                                                     \
+                break;                                                                                                             \
+            } else if (unlikely(!IS_PRINTABLE_ASCII(*buf))) {                                                                      \
+                if ((unsigned char)*buf < '\040' || *buf == '\177') {                                                              \
+                    *ret = -1;                                                                                                     \
+                    return NULL;                                                                                                   \
+                }                                                                                                                  \
+            }                                                                                                                      \
+            ++buf;                                                                                                                 \
+            CHECK_EOF();                                                                                                           \
+        }                                                                                                                          \
+        tok = tok_start;                                                                                                           \
+        toklen = buf - tok_start;                                                                                                  \
+    } while (0)
+
+static const char *token_char_map = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+                                    "\0\1\1\1\1\1\1\1\0\0\1\1\0\1\1\0\1\1\1\1\1\1\1\1\1\1\0\0\0\0\0\0"
+                                    "\0\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\1\1"
+                                    "\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\1\0\1\0"
+                                    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+                                    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+                                    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+                                    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
+
+static const char *findchar_fast(const char *buf, const char *buf_end, const char *ranges, size_t ranges_size, int *found)
 {
-  *found = 0;
+    *found = 0;
 #if __SSE4_2__
-  if (likely(buf_end - buf >= 16)) {
-    __m128i ranges16 = _mm_loadu_si128((const __m128i*)ranges);
-
-    size_t left = (buf_end - buf) & ~15;
-    do {
-      __m128i b16 = _mm_loadu_si128((void*)buf);
-      int r = _mm_cmpestri(ranges16, ranges_size, b16, 16, _SIDD_LEAST_SIGNIFICANT | _SIDD_CMP_RANGES | _SIDD_UBYTE_OPS);
-      if (unlikely(r != 16)) {
-        buf += r;
-        *found = 1;
-        break;
-      }
-      buf += 16;
-      left -= 16;
-    } while (likely(left != 0));
-  }
+    if (likely(buf_end - buf >= 16)) {
+        __m128i ranges16 = _mm_loadu_si128((const __m128i *)ranges);
+
+        size_t left = (buf_end - buf) & ~15;
+        do {
+            __m128i b16 = _mm_loadu_si128((void *)buf);
+            int r = _mm_cmpestri(ranges16, ranges_size, b16, 16, _SIDD_LEAST_SIGNIFICANT | _SIDD_CMP_RANGES | _SIDD_UBYTE_OPS);
+            if (unlikely(r != 16)) {
+                buf += r;
+                *found = 1;
+                break;
+            }
+            buf += 16;
+            left -= 16;
+        } while (likely(left != 0));
+    }
+#else
+    /* suppress unused parameter warning */
+    (void)buf_end;
+    (void)ranges;
+    (void)ranges_size;
 #endif
-  return buf;
+    return buf;
 }
 
-static const char* get_token_to_eol(const char* buf, const char* buf_end,
-                                    const char** token, size_t* token_len,
-                                    int* ret)
+static const char *get_token_to_eol(const char *buf, const char *buf_end, const char **token, size_t *token_len, int *ret)
 {
-  const char* token_start = buf;
-  
+    const char *token_start = buf;
+
 #ifdef __SSE4_2__
-  static const char ranges1[] =
-    "\0\010"
-    /* allow HT */
-    "\012\037"
-    /* allow SP and up to but not including DEL */
-    "\177\177"
-    /* allow chars w. MSB set */
-    ;
-  int found;
-  buf = findchar_fast(buf, buf_end, ranges1, sizeof(ranges1) - 1, &found);
-  if (found)
-    goto FOUND_CTL;
+    static const char ranges1[] = "\0\010"
+                                  /* allow HT */
+                                  "\012\037"
+                                  /* allow SP and up to but not including DEL */
+                                  "\177\177"
+        /* allow chars w. MSB set */
+        ;
+    int found;
+    buf = findchar_fast(buf, buf_end, ranges1, sizeof(ranges1) - 1, &found);
+    if (found)
+        goto FOUND_CTL;
 #else
-  /* find non-printable char within the next 8 bytes, this is the hottest code; manually inlined */
-  while (likely(buf_end - buf >= 8)) {
-#define DOIT() if (unlikely(! IS_PRINTABLE_ASCII(*buf))) goto NonPrintable; ++buf
-    DOIT(); DOIT(); DOIT(); DOIT();
-    DOIT(); DOIT(); DOIT(); DOIT();
+    /* find non-printable char within the next 8 bytes, this is the hottest code; manually inlined */
+    while (likely(buf_end - buf >= 8)) {
+#define DOIT()                                                                                                                     \
+    do {                                                                                                                           \
+        if (unlikely(!IS_PRINTABLE_ASCII(*buf)))                                                                                   \
+            goto NonPrintable;                                                                                                     \
+        ++buf;                                                                                                                     \
+    } while (0)
+        DOIT();
+        DOIT();
+        DOIT();
+        DOIT();
+        DOIT();
+        DOIT();
+        DOIT();
+        DOIT();
 #undef DOIT
-    continue;
-  NonPrintable:
-    if ((likely((unsigned char)*buf < '\040') && likely(*buf != '\011')) || unlikely(*buf == '\177')) {
-      goto FOUND_CTL;
+        continue;
+    NonPrintable:
+        if ((likely((unsigned char)*buf < '\040') && likely(*buf != '\011')) || unlikely(*buf == '\177')) {
+            goto FOUND_CTL;
+        }
+        ++buf;
     }
-    ++buf;
-  }
 #endif
-  for (; ; ++buf) {
-    CHECK_EOF();
-    if (unlikely(! IS_PRINTABLE_ASCII(*buf))) {
-      if ((likely((unsigned char)*buf < '\040') && likely(*buf != '\011')) || unlikely(*buf == '\177')) {
-        goto FOUND_CTL;
-      }
+    for (;; ++buf) {
+        CHECK_EOF();
+        if (unlikely(!IS_PRINTABLE_ASCII(*buf))) {
+            if ((likely((unsigned char)*buf < '\040') && likely(*buf != '\011')) || unlikely(*buf == '\177')) {
+                goto FOUND_CTL;
+            }
+        }
     }
-  }
- FOUND_CTL:
-  if (likely(*buf == '\015')) {
-    ++buf;
-    EXPECT_CHAR('\012');
-    *token_len = buf - 2 - token_start;
-  } else if (*buf == '\012') {
-    *token_len = buf - token_start;
-    ++buf;
-  } else {
-    *ret = -1;
-    return NULL;
-  }
-  *token = token_start;
-  
-  return buf;
-}
-  
-static const char* is_complete(const char* buf, const char* buf_end,
-                               size_t last_len, int* ret)
-{
-  int ret_cnt = 0;
-  buf = last_len < 3 ? buf : buf + last_len - 3;
-  
-  while (1) {
-    CHECK_EOF();
-    if (*buf == '\015') {
-      ++buf;
-      CHECK_EOF();
-      EXPECT_CHAR('\012');
-      ++ret_cnt;
+FOUND_CTL:
+    if (likely(*buf == '\015')) {
+        ++buf;
+        EXPECT_CHAR('\012');
+        *token_len = buf - 2 - token_start;
     } else if (*buf == '\012') {
-      ++buf;
-      ++ret_cnt;
+        *token_len = buf - token_start;
+        ++buf;
     } else {
-      ++buf;
-      ret_cnt = 0;
+        *ret = -1;
+        return NULL;
     }
-    if (ret_cnt == 2) {
-      return buf;
+    *token = token_start;
+
+    return buf;
+}
+
+static const char *is_complete(const char *buf, const char *buf_end, size_t last_len, int *ret)
+{
+    int ret_cnt = 0;
+    buf = last_len < 3 ? buf : buf + last_len - 3;
+
+    while (1) {
+        CHECK_EOF();
+        if (*buf == '\015') {
+            ++buf;
+            CHECK_EOF();
+            EXPECT_CHAR('\012');
+            ++ret_cnt;
+        } else if (*buf == '\012') {
+            ++buf;
+            ++ret_cnt;
+        } else {
+            ++buf;
+            ret_cnt = 0;
+        }
+        if (ret_cnt == 2) {
+            return buf;
+        }
     }
-  }
-  
-  *ret = -2;
-  return NULL;
+
+    *ret = -2;
+    return NULL;
 }
 
 /* *_buf is always within [buf, buf_end) upon success */
-static const char* parse_int(const char* buf, const char* buf_end, int* value,
-                             int* ret)
+static const char *parse_int(const char *buf, const char *buf_end, int *value, int *ret)
 {
-  int v;
-  CHECK_EOF();
-  if (! ('0' <= *buf && *buf <= '9')) {
-    *ret = -1;
-    return NULL;
-  }
-  v = 0;
-  for (; ; ++buf) {
+    int v;
     CHECK_EOF();
-    if ('0' <= *buf && *buf <= '9') {
-      v = v * 10 + *buf - '0';
-    } else {
-      break;
+    if (!('0' <= *buf && *buf <= '9')) {
+        *ret = -1;
+        return NULL;
+    }
+    v = 0;
+    for (;; ++buf) {
+        CHECK_EOF();
+        if ('0' <= *buf && *buf <= '9') {
+            v = v * 10 + *buf - '0';
+        } else {
+            break;
+        }
     }
-  }
-  
-  *value = v;
-  return buf;
+
+    *value = v;
+    return buf;
 }
 
 /* returned pointer is always within [buf, buf_end), or null */
-static const char* parse_http_version(const char* buf, const char* buf_end,
-                                      int* minor_version, int* ret)
+static const char *parse_http_version(const char *buf, const char *buf_end, int *minor_version, int *ret)
 {
-  EXPECT_CHAR('H'); EXPECT_CHAR('T'); EXPECT_CHAR('T'); EXPECT_CHAR('P');
-  EXPECT_CHAR('/'); EXPECT_CHAR('1'); EXPECT_CHAR('.');
-  return parse_int(buf, buf_end, minor_version, ret);
+    EXPECT_CHAR('H');
+    EXPECT_CHAR('T');
+    EXPECT_CHAR('T');
+    EXPECT_CHAR('P');
+    EXPECT_CHAR('/');
+    EXPECT_CHAR('1');
+    EXPECT_CHAR('.');
+    return parse_int(buf, buf_end, minor_version, ret);
 }
 
-static const char* parse_headers(const char* buf, const char* buf_end,
-                                 struct phr_header* headers,
-                                 size_t* num_headers, size_t max_headers,
-                                 int* ret)
+static const char *parse_headers(const char *buf, const char *buf_end, struct phr_header *headers, size_t *num_headers,
+                                 size_t max_headers, int *ret)
 {
-  for (; ; ++*num_headers) {
+    for (;; ++*num_headers) {
+        CHECK_EOF();
+        if (*buf == '\015') {
+            ++buf;
+            EXPECT_CHAR('\012');
+            break;
+        } else if (*buf == '\012') {
+            ++buf;
+            break;
+        }
+        if (*num_headers == max_headers) {
+            *ret = -1;
+            return NULL;
+        }
+        if (!(*num_headers != 0 && (*buf == ' ' || *buf == '\t'))) {
+            static const char ALIGNED(16) ranges1[] = "::\x00\037";
+            int found;
+            if (!token_char_map[(unsigned char)*buf]) {
+                *ret = -1;
+                return NULL;
+            }
+            /* parsing name, but do not discard SP before colon, see
+             * http://www.mozilla.org/security/announce/2006/mfsa2006-33.html */
+            headers[*num_headers].name = buf;
+            buf = findchar_fast(buf, buf_end, ranges1, sizeof(ranges1) - 1, &found);
+            if (!found) {
+                CHECK_EOF();
+            }
+            while (1) {
+                if (*buf == ':') {
+                    break;
+                } else if (*buf < ' ') {
+                    *ret = -1;
+                    return NULL;
+                }
+                ++buf;
+                CHECK_EOF();
+            }
+            headers[*num_headers].name_len = buf - headers[*num_headers].name;
+            ++buf;
+            for (;; ++buf) {
+                CHECK_EOF();
+                if (!(*buf == ' ' || *buf == '\t')) {
+                    break;
+                }
+            }
+        } else {
+            headers[*num_headers].name = NULL;
+            headers[*num_headers].name_len = 0;
+        }
+        if ((buf = get_token_to_eol(buf, buf_end, &headers[*num_headers].value, &headers[*num_headers].value_len, ret)) == NULL) {
+            return NULL;
+        }
+    }
+    return buf;
+}
+
+static const char *parse_request(const char *buf, const char *buf_end, const char **method, size_t *method_len, const char **path,
+                                 size_t *path_len, int *minor_version, struct phr_header *headers, size_t *num_headers,
+                                 size_t max_headers, int *ret)
+{
+    /* skip first empty line (some clients add CRLF after POST content) */
     CHECK_EOF();
     if (*buf == '\015') {
-      ++buf;
-      EXPECT_CHAR('\012');
-      break;
+        ++buf;
+        EXPECT_CHAR('\012');
     } else if (*buf == '\012') {
-      ++buf;
-      break;
-    }
-    if (*num_headers == max_headers) {
-      *ret = -1;
-      return NULL;
+        ++buf;
     }
-    if (! (*num_headers != 0 && (*buf == ' ' || *buf == '\t'))) {
-      if (! token_char_map[(unsigned char)*buf]) {
-        *ret = -1;
+
+    /* parse request line */
+    ADVANCE_TOKEN(*method, *method_len);
+    ++buf;
+    ADVANCE_TOKEN(*path, *path_len);
+    ++buf;
+    if ((buf = parse_http_version(buf, buf_end, minor_version, ret)) == NULL) {
         return NULL;
-      }
-      /* parsing name, but do not discard SP before colon, see
-       * http://www.mozilla.org/security/announce/2006/mfsa2006-33.html */
-      headers[*num_headers].name = buf;
-      static const char ranges1[] __attribute__((aligned(16))) = "::\x00\037";
-      int found;
-      buf = findchar_fast(buf, buf_end, ranges1, sizeof(ranges1) - 1, &found);
-      if (! found) {
-        CHECK_EOF();
-      }
-      while (1) {
-        if (*buf == ':') {
-          break;
-        } else if (*buf < ' ') {
-          *ret = -1;
-          return NULL;
-        }
+    }
+    if (*buf == '\015') {
+        ++buf;
+        EXPECT_CHAR('\012');
+    } else if (*buf == '\012') {
         ++buf;
-        CHECK_EOF();
-      }
-      headers[*num_headers].name_len = buf - headers[*num_headers].name;
-      ++buf;
-      for (; ; ++buf) {
-        CHECK_EOF();
-        if (! (*buf == ' ' || *buf == '\t')) {
-          break;
-        }
-      }
     } else {
-      headers[*num_headers].name = NULL;
-      headers[*num_headers].name_len = 0;
+        *ret = -1;
+        return NULL;
+    }
+
+    return parse_headers(buf, buf_end, headers, num_headers, max_headers, ret);
+}
+
+int phr_parse_request(const char *buf_start, size_t len, const char **method, size_t *method_len, const char **path,
+                      size_t *path_len, int *minor_version, struct phr_header *headers, size_t *num_headers, size_t last_len)
+{
+    const char *buf = buf_start, *buf_end = buf_start + len;
+    size_t max_headers = *num_headers;
+    int r;
+
+    *method = NULL;
+    *method_len = 0;
+    *path = NULL;
+    *path_len = 0;
+    *minor_version = -1;
+    *num_headers = 0;
+
+    /* if last_len != 0, check if the request is complete (a fast countermeasure
+       againt slowloris */
+    if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) {
+        return r;
     }
-    if ((buf = get_token_to_eol(buf, buf_end, &headers[*num_headers].value,
-                                &headers[*num_headers].value_len, ret))
-        == NULL) {
-      return NULL;
+
+    if ((buf = parse_request(buf, buf_end, method, method_len, path, path_len, minor_version, headers, num_headers, max_headers,
+                             &r)) == NULL) {
+        return r;
     }
-  }
-  return buf;
+
+    return (int)(buf - buf_start);
 }
 
-const char* parse_request(const char* buf, const char* buf_end,
-                          const char** method, size_t* method_len,
-                          const char** path, size_t* path_len,
-                          int* minor_version, struct phr_header* headers,
-                          size_t* num_headers, size_t max_headers, int* ret)
+static const char *parse_response(const char *buf, const char *buf_end, int *minor_version, int *status, const char **msg,
+                                  size_t *msg_len, struct phr_header *headers, size_t *num_headers, size_t max_headers, int *ret)
 {
-  /* skip first empty line (some clients add CRLF after POST content) */
-  CHECK_EOF();
-  if (*buf == '\015') {
-    ++buf;
-    EXPECT_CHAR('\012');
-  } else if (*buf == '\012') {
-    ++buf;
-  }
-  
-  /* parse request line */
-  ADVANCE_TOKEN(*method, *method_len);
-  ++buf;
-  ADVANCE_TOKEN(*path, *path_len);
-  ++buf;
-  if ((buf = parse_http_version(buf, buf_end, minor_version, ret)) == NULL) {
-    return NULL;
-  }
-  if (*buf == '\015') {
-    ++buf;
-    EXPECT_CHAR('\012');
-  } else if (*buf == '\012') {
-    ++buf;
-  } else {
-    *ret = -1;
-    return NULL;
-  }
-  
-  return parse_headers(buf, buf_end, headers, num_headers, max_headers, ret);
+    /* parse "HTTP/1.x" */
+    if ((buf = parse_http_version(buf, buf_end, minor_version, ret)) == NULL) {
+        return NULL;
+    }
+    /* skip space */
+    if (*buf++ != ' ') {
+        *ret = -1;
+        return NULL;
+    }
+    /* parse status code */
+    if ((buf = parse_int(buf, buf_end, status, ret)) == NULL) {
+        return NULL;
+    }
+    /* skip space */
+    if (*buf++ != ' ') {
+        *ret = -1;
+        return NULL;
+    }
+    /* get message */
+    if ((buf = get_token_to_eol(buf, buf_end, msg, msg_len, ret)) == NULL) {
+        return NULL;
+    }
+
+    return parse_headers(buf, buf_end, headers, num_headers, max_headers, ret);
 }
 
-int phr_parse_request(const char* buf_start, size_t len, const char** method,
-                      size_t* method_len, const char** path, size_t* path_len,
-                      int* minor_version, struct phr_header* headers,
-                      size_t* num_headers, size_t last_len)
+int phr_parse_response(const char *buf_start, size_t len, int *minor_version, int *status, const char **msg, size_t *msg_len,
+                       struct phr_header *headers, size_t *num_headers, size_t last_len)
 {
-  const char * buf = buf_start, * buf_end = buf_start + len;
-  size_t max_headers = *num_headers;
-  int r;
-  
-  *method = NULL;
-  *method_len = 0;
-  *path = NULL;
-  *path_len = 0;
-  *minor_version = -1;
-  *num_headers = 0;
-  
-  /* if last_len != 0, check if the request is complete (a fast countermeasure
-     againt slowloris */
-  if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) {
-    return r;
-  }
-  
-  if ((buf = parse_request(buf, buf_end, method, method_len, path, path_len,
-                           minor_version, headers, num_headers, max_headers,
-                           &r))
-      == NULL) {
-    return r;
-  }
-  
-  return (int)(buf - buf_start);
+    const char *buf = buf_start, *buf_end = buf + len;
+    size_t max_headers = *num_headers;
+    int r;
+
+    *minor_version = -1;
+    *status = 0;
+    *msg = NULL;
+    *msg_len = 0;
+    *num_headers = 0;
+
+    /* if last_len != 0, check if the response is complete (a fast countermeasure
+       against slowloris */
+    if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) {
+        return r;
+    }
+
+    if ((buf = parse_response(buf, buf_end, minor_version, status, msg, msg_len, headers, num_headers, max_headers, &r)) == NULL) {
+        return r;
+    }
+
+    return (int)(buf - buf_start);
 }
 
-static const char* parse_response(const char* buf, const char* buf_end,
-                                  int* minor_version, int* status,
-                                  const char** msg, size_t* msg_len,
-                                  struct phr_header* headers,
-                                  size_t* num_headers, size_t max_headers,
-                                  int* ret)
+int phr_parse_headers(const char *buf_start, size_t len, struct phr_header *headers, size_t *num_headers, size_t last_len)
 {
-  /* parse "HTTP/1.x" */
-  if ((buf = parse_http_version(buf, buf_end, minor_version, ret)) == NULL) {
-    return NULL;
-  }
-  /* skip space */
-  if (*buf++ != ' ') {
-    *ret = -1;
-    return NULL;
-  }
-  /* parse status code */
-  if ((buf = parse_int(buf, buf_end, status, ret)) == NULL) {
-    return NULL;
-  }
-  /* skip space */
-  if (*buf++ != ' ') {
-    *ret = -1;
-    return NULL;
-  }
-  /* get message */
-  if ((buf = get_token_to_eol(buf, buf_end, msg, msg_len, ret)) == NULL) {
-    return NULL;
-  }
-  
-  return parse_headers(buf, buf_end, headers, num_headers, max_headers, ret);
+    const char *buf = buf_start, *buf_end = buf + len;
+    size_t max_headers = *num_headers;
+    int r;
+
+    *num_headers = 0;
+
+    /* if last_len != 0, check if the response is complete (a fast countermeasure
+       against slowloris */
+    if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) {
+        return r;
+    }
+
+    if ((buf = parse_headers(buf, buf_end, headers, num_headers, max_headers, &r)) == NULL) {
+        return r;
+    }
+
+    return (int)(buf - buf_start);
 }
 
-int phr_parse_response(const char* buf_start, size_t len, int* minor_version,
-                       int* status, const char** msg, size_t* msg_len,
-                       struct phr_header* headers, size_t* num_headers,
-                       size_t last_len)
+enum {
+    CHUNKED_IN_CHUNK_SIZE,
+    CHUNKED_IN_CHUNK_EXT,
+    CHUNKED_IN_CHUNK_DATA,
+    CHUNKED_IN_CHUNK_CRLF,
+    CHUNKED_IN_TRAILERS_LINE_HEAD,
+    CHUNKED_IN_TRAILERS_LINE_MIDDLE
+};
+
+static int decode_hex(int ch)
 {
-  const char * buf = buf_start, * buf_end = buf + len;
-  size_t max_headers = *num_headers;
-  int r;
-  
-  *minor_version = -1;
-  *status = 0;
-  *msg = NULL;
-  *msg_len = 0;
-  *num_headers = 0;
-  
-  /* if last_len != 0, check if the response is complete (a fast countermeasure
-     against slowloris */
-  if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) {
-    return r;
-  }
-  
-  if ((buf = parse_response(buf, buf_end, minor_version, status, msg, msg_len,
-                            headers, num_headers, max_headers, &r))
-      == NULL) {
-    return r;
-  }
-  
-  return (int)(buf - buf_start);
+    if ('0' <= ch && ch <= '9') {
+        return ch - '0';
+    } else if ('A' <= ch && ch <= 'F') {
+        return ch - 'A' + 0xa;
+    } else if ('a' <= ch && ch <= 'f') {
+        return ch - 'a' + 0xa;
+    } else {
+        return -1;
+    }
+}
+
+ssize_t phr_decode_chunked(struct phr_chunked_decoder *decoder, char *buf, size_t *_bufsz)
+{
+    size_t dst = 0, src = 0, bufsz = *_bufsz;
+    ssize_t ret = -2; /* incomplete */
+
+    while (1) {
+        switch (decoder->_state) {
+        case CHUNKED_IN_CHUNK_SIZE:
+            for (;; ++src) {
+                int v;
+                if (src == bufsz)
+                    goto Exit;
+                if ((v = decode_hex(buf[src])) == -1) {
+                    if (decoder->_hex_count == 0) {
+                        ret = -1;
+                        goto Exit;
+                    }
+                    break;
+                }
+                if (decoder->_hex_count == sizeof(size_t) * 2) {
+                    ret = -1;
+                    goto Exit;
+                }
+                decoder->bytes_left_in_chunk = decoder->bytes_left_in_chunk * 16 + v;
+                ++decoder->_hex_count;
+            }
+            decoder->_hex_count = 0;
+            decoder->_state = CHUNKED_IN_CHUNK_EXT;
+        /* fallthru */
+        case CHUNKED_IN_CHUNK_EXT:
+            /* RFC 7230 A.2 "Line folding in chunk extensions is disallowed" */
+            for (;; ++src) {
+                if (src == bufsz)
+                    goto Exit;
+                if (buf[src] == '\012')
+                    break;
+            }
+            ++src;
+            if (decoder->bytes_left_in_chunk == 0) {
+                if (decoder->consume_trailer) {
+                    decoder->_state = CHUNKED_IN_TRAILERS_LINE_HEAD;
+                    break;
+                } else {
+                    goto Complete;
+                }
+            }
+            decoder->_state = CHUNKED_IN_CHUNK_DATA;
+        /* fallthru */
+        case CHUNKED_IN_CHUNK_DATA: {
+            size_t avail = bufsz - src;
+            if (avail < decoder->bytes_left_in_chunk) {
+                if (dst != src)
+                    memmove(buf + dst, buf + src, avail);
+                src += avail;
+                dst += avail;
+                decoder->bytes_left_in_chunk -= avail;
+                goto Exit;
+            }
+            if (dst != src)
+                memmove(buf + dst, buf + src, decoder->bytes_left_in_chunk);
+            src += decoder->bytes_left_in_chunk;
+            dst += decoder->bytes_left_in_chunk;
+            decoder->bytes_left_in_chunk = 0;
+            decoder->_state = CHUNKED_IN_CHUNK_CRLF;
+        }
+        /* fallthru */
+        case CHUNKED_IN_CHUNK_CRLF:
+            for (;; ++src) {
+                if (src == bufsz)
+                    goto Exit;
+                if (buf[src] != '\015')
+                    break;
+            }
+            if (buf[src] != '\012') {
+                ret = -1;
+                goto Exit;
+            }
+            ++src;
+            decoder->_state = CHUNKED_IN_CHUNK_SIZE;
+            break;
+        case CHUNKED_IN_TRAILERS_LINE_HEAD:
+            for (;; ++src) {
+                if (src == bufsz)
+                    goto Exit;
+                if (buf[src] != '\015')
+                    break;
+            }
+            if (buf[src++] == '\012')
+                goto Complete;
+            decoder->_state = CHUNKED_IN_TRAILERS_LINE_MIDDLE;
+        /* fallthru */
+        case CHUNKED_IN_TRAILERS_LINE_MIDDLE:
+            for (;; ++src) {
+                if (src == bufsz)
+                    goto Exit;
+                if (buf[src] == '\012')
+                    break;
+            }
+            ++src;
+            decoder->_state = CHUNKED_IN_TRAILERS_LINE_HEAD;
+            break;
+        default:
+            assert(!"decoder is corrupt");
+        }
+    }
+
+Complete:
+    ret = bufsz - src;
+Exit:
+    if (dst != src)
+        memmove(buf + dst, buf + src, bufsz - src);
+    *_bufsz = dst;
+    return ret;
 }
 
 #undef CHECK_EOF