pico_http_parser 0.0.1

data/Rakefile

@@ -0,0 +1,19 @@
+require "bundler/gem_tasks"
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new "pico_http_parser" do |ext|
+  ext.lib_dir = "lib/pico_http_parser"
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/*_spec.rb'
+  # spec.rspec_opts = ['-cfs']
+end
+
+task :test do
+  Rake::Task["clobber"].invoke
+  Rake::Task["compile"].invoke
+  Rake::Task["spec"].invoke
+end
+

data/benchmark/bench_helper.rb

@@ -0,0 +1,5 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rubygems'
+require 'benchmark'

data/benchmark/benchmark.pl

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + '/bench_helper')
+
+require 'pico_http_parser'
+
+request_body = <<REQ
+GET /blakjsdfkas HTTP/1.1\r
+Host: blooperblorp\r
+Cookie: blah=woop\r
+\r
+REQ
+loop = 300000
+
+#File.read(File.expand_path(File.dirname(__FILE__) + '/sample_request.http'))
+
+Benchmark.bmbm(20) do |bm|
+  bm.report("PicoHTTPParser") do
+    0.upto(loop) do
+      env = {}
+      PicoHTTPParser.parse_http_request(request_body,env)
+    end
+  end
+  begin
+    require 'unicorn'
+    include Unicorn
+    bm.report("HttpParser") do
+      0.upto(loop) do
+        parser = HttpParser.new
+        parser.buf << request_body
+        parser.parse
+      end
+    end
+  rescue LoadError
+    puts("Can't benchmark unicorn as it couldn't be loaded.")
+  end
+end

data/ext/pico_http_parser/extconf.rb

@@ -0,0 +1,2 @@
+require "mkmf"
+create_makefile("pico_http_parser/pico_http_parser")

data/ext/pico_http_parser/pico_http_parser.c

@@ -0,0 +1,167 @@
+#include <ruby.h>
+#include <ctype.h>
+#include "picohttpparser/picohttpparser.c"
+
+#define MAX_HEADER_NAME_LEN 1024
+#define MAX_HEADERS         128
+#define TOU(ch) (('a' <= ch && ch <= 'z') ? ch - ('a' - 'A') : ch)
+
+VALUE cPicoHTTPParser;
+
+static
+size_t find_ch(const char* s, size_t len, char ch)
+{
+  size_t i;
+  for (i = 0; i != len; ++i, ++s)
+    if (*s == ch)
+      break;
+  return i;
+}
+
+static
+int header_is(const struct phr_header* header, const char* name,
+                    size_t len)
+{
+  const char* x, * y;
+  if (header->name_len != len)
+    return 0;
+  for (x = header->name, y = name; len != 0; --len, ++x, ++y)
+    if (TOU(*x) != *y)
+      return 0;
+  return 1;
+}
+
+
+static
+int store_path_info(VALUE envref, const char* src, size_t src_len) {
+  size_t dlen = 0, i = 0;
+  char *d;
+  char s2, s3;
+
+  d = (char*)malloc(src_len * 3 + 1);
+  for (i = 0; i < src_len; i++ ) {
+    if ( src[i] == '%' ) {
+      if ( !isxdigit(src[i+1]) || !isxdigit(src[i+2]) ) {
+        free(d);
+        return -1;
+      }
+      s2 = src[i+1];
+      s3 = src[i+2];
+      s2 -= s2 <= '9' ? '0'
+          : s2 <= 'F' ? 'A' - 10
+          : 'a' - 10;
+      s3 -= s3 <= '9' ? '0'
+          : s3 <= 'F' ? 'A' - 10
+          : 'a' - 10;
+       d[dlen++] = s2 * 16 + s3;
+       i += 2;
+    }
+    else {
+      d[dlen++] = src[i];
+    }
+  }
+  d[dlen]='0';
+  rb_hash_aset(envref, rb_str_new2("PATH_INFO"), rb_str_new(d, dlen));
+  free(d);
+  return dlen;
+}
+
+
+static
+VALUE phr_parse_http_request(VALUE self, VALUE buf, VALUE envref)
+{
+  const char* buf_str;
+  size_t buf_len;
+  const char* method;
+  size_t method_len;
+  const char* path;
+  size_t path_len;
+  size_t o_path_len;
+  int minor_version;
+  struct phr_header headers[MAX_HEADERS];
+  size_t num_headers, question_at;
+  size_t i;
+  int ret;
+  char tmp[MAX_HEADER_NAME_LEN + sizeof("HTTP_") - 1];
+  VALUE last_value;
+
+  buf_str = StringValuePtr(buf);
+  buf_len = strlen(buf_str);
+  num_headers = MAX_HEADERS;
+  ret = phr_parse_request(buf_str, buf_len, &method, &method_len, &path,
+                          &path_len, &minor_version, headers, &num_headers, 0);
+  if (ret < 0)
+    goto done;
+
+  rb_hash_aset(envref, rb_str_new2("REQUEST_METHOD"), rb_str_new(method,method_len));
+  rb_hash_aset(envref, rb_str_new2("REQUEST_URI"), rb_str_new(path, path_len));
+  rb_hash_aset(envref, rb_str_new2("SCRIPT_NAME"), rb_str_new2(""));
+  i = sprintf(tmp,"HTTP/1.%d",minor_version);
+  rb_hash_aset(envref, rb_str_new2("SERVER_PROTOCOL"), rb_str_new(tmp, i));
+
+  /* PATH_INFO QUERY_STRING */
+  path_len = find_ch(path, path_len, '#'); /* strip off all text after # after storing request_uri */
+  question_at = find_ch(path, path_len, '?');
+  if ( store_path_info(envref, path, question_at) < 0 ) {
+    rb_hash_clear(envref);
+    ret = -1;
+    goto done;
+  }
+  if (question_at != path_len) ++question_at;
+  rb_hash_aset(envref, rb_str_new2("QUERY_STRING"), 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) {
+      const char* name;
+      size_t name_len;
+      VALUE slot;
+      if (header_is(headers + i, "CONTENT-TYPE", sizeof("CONTENT-TYPE") - 1)) {
+        name = "CONTENT_TYPE";
+        name_len = sizeof("CONTENT_TYPE") - 1;
+      } else if (header_is(headers + i, "CONTENT-LENGTH", sizeof("CONTENT-LENGTH") - 1)) {
+        name = "CONTENT_LENGTH";
+        name_len = sizeof("CONTENT_LENGTH") - 1;
+      } else {
+        const char* s;
+        char* d;
+        size_t n;
+        if (sizeof(tmp) - 5 < headers[i].name_len) {
+          rb_hash_clear(envref);
+          ret = -1;
+          goto done;
+        }
+        strcpy(tmp, "HTTP_");
+        for (s = headers[i].name, n = headers[i].name_len, d = tmp + 5;
+          n != 0;
+          s++, --n, d++) {
+            *d = *s == '-' ? '_' : TOU(*s);
+            name = tmp;
+            name_len = headers[i].name_len + 5;
+        }
+      }
+      slot = rb_hash_aref(envref, rb_str_new(name, name_len));
+      if ( slot != Qnil ) {
+        rb_str_cat2(slot, ", ");
+        rb_str_cat(slot, headers[i].value, headers[i].value_len);
+      } else {
+        slot = rb_str_new(headers[i].value, headers[i].value_len);
+        rb_hash_aset(envref, rb_str_new(name, name_len), slot);
+        last_value = slot;
+      }
+    } else {
+      /* continuing lines of a mulitiline header */
+      rb_str_cat(last_value, headers[i].value, headers[i].value_len);
+    }
+  }
+
+ done:
+  return rb_int_new(ret);
+}
+
+void Init_pico_http_parser()
+{
+
+  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/.gitattributes

@@ -0,0 +1 @@
+picohttpparser.*       ident

data/ext/pico_http_parser/picohttpparser/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "picotest"]
+	path = picotest
+	url = https://github.com/h2o/picotest.git

data/ext/pico_http_parser/picohttpparser/.travis.yml

@@ -0,0 +1,6 @@
+language: c
+compiler:
+  - gcc
+  - clang
+script:
+  - make test

data/ext/pico_http_parser/picohttpparser/Makefile

@@ -0,0 +1,39 @@
+#
+# Copyright (c) 2009-2014 Kazuho Oku, Tokuhiro Matsuno, Daisuke Murase
+#
+# The software is licensed under either the MIT License (below) or the Perl
+# license.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+CC?=gcc
+PROVE?=prove
+
+all:
+
+test: test-bin
+	$(PROVE) -v ./test-bin
+
+test-bin: picohttpparser.c picotest/picotest.c test.c
+	$(CC) -Wall $(CFLAGS) $(LDFLAGS) -o $@ $^
+
+clean:
+	rm -f test-bin
+
+.PHONY: test

data/ext/pico_http_parser/picohttpparser/README.md

@@ -0,0 +1,24 @@
+PicoHTTPParser
+=============
+
+Copyright (c) 2009-2014 [Kazuho Oku](https://github.com/kazuho), [Tokuhiro Matsuno](https://github.com/tokuhirom), [Daisuke Murase](https://github.com/typester)
+
+PicoHTTPParser is a tiny, primitive, fast HTTP request/response parser.
+
+Unlike most parsers, it is stateless and does not allocate memory by itself.
+All it does is accept pointer to buffer and the output structure, and setups the pointers in the latter to point at the necessary portions of the buffer.
+
+The code is widely deployed within Perl applications through popular modules that use it, including [Plack](https://metacpan.org/pod/Plack), [Starman](https://metacpan.org/pod/Starman), [Starlet](https://metacpan.org/pod/Starlet), [Furl](https://metacpan.org/pod/Furl).  It is also the HTTP/1 parser of [H2O](https://github.com/h2o/h2o).
+
+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.
+
+Benchmark
+---------
+
+![benchmark results](http://i.gyazo.com/7e098703c29128d69d02c9a216bfb6fb.png)
+
+The benchmark code is from [fukamachi/fast-http](https://github.com/fukamachi/fast-http/).
+
+The internals of picohttpparser has been described to some extent in [my blog entry]( http://blog.kazuhooku.com/2014/11/the-internals-h2o-or-how-to-write-fast.html).

data/ext/pico_http_parser/picohttpparser/bench.c

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2009-2014 Kazuho Oku, Tokuhiro Matsuno, Daisuke Murase
+ *
+ * The software is licensed under either the MIT License (below) or the Perl
+ * license.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include <assert.h>
+#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"
+
+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 < 1000000; 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

@@ -0,0 +1,377 @@
+/*
+ * Copyright (c) 2009-2014 Kazuho Oku, Tokuhiro Matsuno, Daisuke Murase
+ *
+ * The software is licensed under either the MIT License (below) or the Perl
+ * license.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include <stddef.h>
+#include "picohttpparser.h"
+
+/* $Id$ */
+
+#if __GNUC__ >= 3
+# define likely(x) __builtin_expect(!!(x), 1)
+# define unlikely(x) __builtin_expect(!!(x), 0)
+#else
+# define likely(x) (x)
+# define unlikely(x) (x)
+#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; \
+    for (; ; ++buf) { \
+      CHECK_EOF(); \
+      if (*buf == ' ') { \
+        break; \
+      } else if (unlikely(! IS_PRINTABLE_ASCII(*buf))) { \
+        if ((unsigned char)*buf < '\040' || *buf == '\177') { \
+          *ret = -1; \
+          return NULL; \
+        } \
+      } \
+    } \
+    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* 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;
+  
+  /* 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();
+#undef DOIT
+    continue;
+  NonPrintable:
+    if ((likely((unsigned char)*buf < '\040') && likely(*buf != '\011')) || unlikely(*buf == '\177')) {
+      goto FOUND_CTL;
+    }
+    ++buf;
+  }
+  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;
+    } else if (*buf == '\012') {
+      ++buf;
+      ++ret_cnt;
+    } else {
+      ++buf;
+      ret_cnt = 0;
+    }
+    if (ret_cnt == 2) {
+      return buf;
+    }
+  }
+  
+  *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)
+{
+  int v;
+  CHECK_EOF();
+  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;
+}
+
+/* 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)
+{
+  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)
+{
+  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'))) {
+      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;
+      for (; ; ++buf) {
+        CHECK_EOF();
+        if (*buf == ':') {
+          break;
+        } else if (*buf < ' ') {
+          *ret = -1;
+          return NULL;
+        }
+      }
+      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;
+}
+
+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');
+  } 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);
+}
+
+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 = 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);
+}
+
+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)
+{
+  /* 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_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 + 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);
+}
+
+#undef CHECK_EOF
+#undef EXPECT_CHAR
+#undef ADVANCE_TOKEN