h1p 0.2 → 0.5

data/ext/h1p/h1p.c

@@ -16,17 +16,20 @@
 ID ID_arity;
 ID ID_backend_read;
 ID ID_backend_recv;
+ID ID_backend_send;
+ID ID_backend_splice;
+ID ID_backend_write;
 ID ID_call;
 ID ID_downcase;
 ID ID_eof_p;
 ID ID_eq;
-ID ID_parser_read_method;
+ID ID_read_method;
 ID ID_read;
 ID ID_readpartial;
 ID ID_to_i;
 ID ID_upcase;
+ID ID_write_method;
 
-static VALUE mPolyphony = Qnil;
 static VALUE cError;
 
 VALUE NUM_max_headers_read_length;
@@ -37,6 +40,8 @@ VALUE STR_pseudo_method;
 VALUE STR_pseudo_path;
 VALUE STR_pseudo_protocol;
 VALUE STR_pseudo_rx;
+VALUE STR_pseudo_status;
+VALUE STR_pseudo_status_message;
 
 VALUE STR_chunked;
 VALUE STR_content_length;
@@ -44,27 +49,47 @@ VALUE STR_transfer_encoding;
 
 VALUE SYM_backend_read;
 VALUE SYM_backend_recv;
+VALUE SYM_backend_send;
+VALUE SYM_backend_write;
 VALUE SYM_stock_readpartial;
 
+VALUE SYM_client;
+VALUE SYM_server;
+
 enum read_method {
-  method_readpartial,       // receiver.readpartial(len, buf, pos, raise_on_eof: false) (Polyphony-specific)
-  method_backend_read,      // Polyphony.backend_read (Polyphony-specific)
-  method_backend_recv,      // Polyphony.backend_recv (Polyphony-specific)
-  method_call,              // receiver.call(len) (Universal)
-  method_stock_readpartial  // receiver.readpartial(len)
+  RM_READPARTIAL,       // receiver.readpartial(len, buf, pos, raise_on_eof: false) (Polyphony-specific)
+  RM_BACKEND_READ,      // Polyphony.backend_read (Polyphony-specific)
+  RM_BACKEND_RECV,      // Polyphony.backend_recv (Polyphony-specific)
+  RM_CALL,              // receiver.call(len) (Universal)
+  RM_STOCK_READPARTIAL  // receiver.readpartial(len)
+};
+
+enum write_method {
+  WM_BACKEND_WRITE,
+  WM_BACKEND_SEND
+};
+
+enum parser_mode {
+  mode_server,
+  mode_client
 };
 
 typedef struct parser {
+  enum  parser_mode mode;
   VALUE io;
   VALUE buffer;
   VALUE headers;
-  int   pos;
   int   current_request_rx;
 
   enum  read_method read_method;
   int   body_read_mode;
   int   body_left;
   int   request_completed;
+
+  char *buf_ptr;
+  int   buf_len;
+  int   buf_pos;
+
 } Parser_t;
 
 VALUE cParser = Qnil;
@@ -100,39 +125,55 @@ static VALUE Parser_allocate(VALUE klass) {
 #define GetParser(obj, parser) \
   TypedData_Get_Struct((obj), Parser_t, &Parser_type, (parser))
 
-static inline void get_polyphony() {
-  if (mPolyphony != Qnil) return;
-
-  mPolyphony = rb_const_get(rb_cObject, rb_intern("Polyphony"));
-  rb_gc_register_mark_object(mPolyphony);
+static inline VALUE Polyphony() {
+  static VALUE mPolyphony = Qnil;
+  if (mPolyphony == Qnil) {
+    mPolyphony = rb_const_get(rb_cObject, rb_intern("Polyphony"));
+    rb_gc_register_mark_object(mPolyphony);
+  }
+  return mPolyphony;
 }
 
-enum read_method detect_read_method(VALUE io) {
-  if (rb_respond_to(io, ID_parser_read_method)) {
-    VALUE method = rb_funcall(io, ID_parser_read_method, 0);
-    if (method == SYM_stock_readpartial) return method_stock_readpartial;
+static enum read_method detect_read_method(VALUE io) {
+  if (rb_respond_to(io, ID_read_method)) {
+    VALUE method = rb_funcall(io, ID_read_method, 0);
+    if (method == SYM_stock_readpartial) return RM_STOCK_READPARTIAL;
+    if (method == SYM_backend_read)      return RM_BACKEND_READ;
+    if (method == SYM_backend_recv)      return RM_BACKEND_RECV;
 
-    get_polyphony();
-    if (method == SYM_backend_read)      return method_backend_read;
-    if (method == SYM_backend_recv)      return method_backend_recv;
-
-    return method_readpartial;
+    return RM_READPARTIAL;
   }
   else if (rb_respond_to(io, ID_call)) {
-    return method_call;
+    return RM_CALL;
   }
   else
-    rb_raise(rb_eRuntimeError, "Provided reader should be a callable or respond to #__parser_read_method__");
+    rb_raise(rb_eRuntimeError, "Provided reader should be a callable or respond to #__read_method__");
+}
+
+static enum write_method detect_write_method(VALUE io) {
+  if (rb_respond_to(io, ID_write_method)) {
+    VALUE method = rb_funcall(io, ID_write_method, 0);
+    if (method == SYM_backend_write)  return WM_BACKEND_WRITE;
+    if (method == SYM_backend_send)   return WM_BACKEND_SEND;
+  }
+  rb_raise(rb_eRuntimeError, "Provided io should respond to #__write_method__");
+}
+
+enum parser_mode parse_parser_mode(VALUE mode) {
+  if (mode == SYM_server) return mode_server;
+  if (mode == SYM_client) return mode_client;
+
+  rb_raise(rb_eRuntimeError, "Invalid parser mode specified");
 }
 
-VALUE Parser_initialize(VALUE self, VALUE io) {
+VALUE Parser_initialize(VALUE self, VALUE io, VALUE mode) {
   Parser_t *parser;
   GetParser(self, parser);
 
+  parser->mode = parse_parser_mode(mode);
   parser->io = io;
   parser->buffer = rb_str_new_literal("");
   parser->headers = Qnil;
-  parser->pos = 0;
 
   // pre-allocate the buffer
   rb_str_modify_expand(parser->buffer, INITIAL_BUFFER_SIZE);
@@ -140,6 +181,11 @@ VALUE Parser_initialize(VALUE self, VALUE io) {
   parser->read_method = detect_read_method(io);
   parser->body_read_mode = BODY_READ_MODE_UNKNOWN;
   parser->body_left = 0;
+
+  parser->buf_ptr = 0;
+  parser->buf_len = 0;
+  parser->buf_pos = 0;
+
   return self;
 }
 
@@ -148,95 +194,96 @@ VALUE Parser_initialize(VALUE self, VALUE io) {
 #define str_downcase(str) (rb_funcall((str), ID_downcase, 0))
 #define str_upcase(str) (rb_funcall((str), ID_upcase, 0))
 
-#define FILL_BUFFER_OR_GOTO_EOF(state) { if (!fill_buffer(state)) goto eof; }
+#define FILL_BUFFER_OR_GOTO_EOF(parser) { if (!fill_buffer(parser)) goto eof; }
 
-#define BUFFER_POS(state) ((state)->parser->pos)
-#define BUFFER_LEN(state) ((state)->len)
-#define BUFFER_CUR(state) ((state)->ptr[(state)->parser->pos])
-#define BUFFER_AT(state, pos) ((state)->ptr[pos])
-#define BUFFER_PTR(state, pos) ((state)->ptr + pos)
-#define BUFFER_STR(state, pos, len) (rb_obj_freeze(rb_utf8_str_new((state)->ptr + pos, len)))
-#define BUFFER_STR_DOWNCASE(state, pos, len) (rb_obj_freeze(str_downcase(rb_utf8_str_new((state)->ptr + pos, len))))
-#define BUFFER_STR_UPCASE(state, pos, len) (rb_obj_freeze(str_upcase(rb_utf8_str_new((state)->ptr + pos, len))))
+#define BUFFER_POS(parser) ((parser)->buf_pos)
+#define BUFFER_LEN(parser) ((parser)->buf_len)
+#define BUFFER_CUR(parser) ((parser)->buf_ptr[(parser)->buf_pos])
+#define BUFFER_AT(parser, pos) ((parser)->buf_ptr[pos])
+#define BUFFER_PTR(parser, pos) ((parser)->buf_ptr + pos)
+#define BUFFER_STR(parser, pos, len) (rb_obj_freeze(rb_utf8_str_new((parser)->buf_ptr + pos, len)))
+#define BUFFER_STR_DOWNCASE(parser, pos, len) (rb_obj_freeze(str_downcase(rb_utf8_str_new((parser)->buf_ptr + pos, len))))
+#define BUFFER_STR_UPCASE(parser, pos, len) (rb_obj_freeze(str_upcase(rb_utf8_str_new((parser)->buf_ptr + pos, len))))
 
-#define INC_BUFFER_POS(state) { \
-  BUFFER_POS(state)++; \
-  if (BUFFER_POS(state) == BUFFER_LEN(state)) FILL_BUFFER_OR_GOTO_EOF(state); \
+#define INC_BUFFER_POS(parser) { \
+  BUFFER_POS(parser)++; \
+  if (BUFFER_POS(parser) == BUFFER_LEN(parser)) FILL_BUFFER_OR_GOTO_EOF(parser); \
 }
 
-#define INC_BUFFER_POS_NO_FILL(state) BUFFER_POS(state)++;
+#define INC_BUFFER_POS_NO_FILL(parser) BUFFER_POS(parser)++;
 
-#define INC_BUFFER_POS_UTF8(state, len) { \
-  unsigned char c = BUFFER_CUR(state); \
+#define INC_BUFFER_POS_UTF8(parser, len) { \
+  unsigned char c = BUFFER_CUR(parser); \
   if ((c & 0xf0) == 0xf0) { \
-    while (BUFFER_LEN(state) - BUFFER_POS(state) < 4) FILL_BUFFER_OR_GOTO_EOF(state); \
-    BUFFER_POS(state) += 4; \
+    while (BUFFER_LEN(parser) - BUFFER_POS(parser) < 4) FILL_BUFFER_OR_GOTO_EOF(parser); \
+    BUFFER_POS(parser) += 4; \
     len += 4; \
   } \
   else if ((c & 0xe0) == 0xe0) { \
-    while (BUFFER_LEN(state) - BUFFER_POS(state) < 3) FILL_BUFFER_OR_GOTO_EOF(state); \
-    BUFFER_POS(state) += 3; \
+    while (BUFFER_LEN(parser) - BUFFER_POS(parser) < 3) FILL_BUFFER_OR_GOTO_EOF(parser); \
+    BUFFER_POS(parser) += 3; \
     len += 3; \
   } \
   else if ((c & 0xc0) == 0xc0) { \
-    while (BUFFER_LEN(state) - BUFFER_POS(state) < 2) FILL_BUFFER_OR_GOTO_EOF(state); \
-    BUFFER_POS(state) += 2; \
+    while (BUFFER_LEN(parser) - BUFFER_POS(parser) < 2) FILL_BUFFER_OR_GOTO_EOF(parser); \
+    BUFFER_POS(parser) += 2; \
     len += 2; \
   } \
   else { \
-    BUFFER_POS(state)++; \
+    BUFFER_POS(parser)++; \
     len ++; \
-    if (BUFFER_POS(state) == BUFFER_LEN(state)) FILL_BUFFER_OR_GOTO_EOF(state); \
+    if (BUFFER_POS(parser) == BUFFER_LEN(parser)) FILL_BUFFER_OR_GOTO_EOF(parser); \
   } \
 }
 
-#define INIT_PARSER_STATE(state) { \
-  (state)->len = RSTRING_LEN((state)->parser->buffer); \
-  if (BUFFER_POS(state) == BUFFER_LEN(state)) \
-    FILL_BUFFER_OR_GOTO_EOF(state) \
+#define INIT_PARSER_STATE(parser) { \
+  (parser)->buf_len = RSTRING_LEN((parser)->buffer); \
+  if (BUFFER_POS(parser) == BUFFER_LEN(parser)) \
+    FILL_BUFFER_OR_GOTO_EOF(parser) \
   else \
-    (state)->ptr = RSTRING_PTR((state)->parser->buffer); \
+    (parser)->buf_ptr = RSTRING_PTR((parser)->buffer); \
 }
 
 #define RAISE_BAD_REQUEST(msg) rb_raise(cError, msg)
 
-#define SET_HEADER_VALUE_FROM_BUFFER(state, headers, key, pos, len) { \
-  VALUE value = BUFFER_STR(state, pos, len); \
-  rb_hash_aset(headers, key, value); \
+#define SET_HEADER_VALUE_FROM_BUFFER(parser, key, pos, len) { \
+  VALUE value = BUFFER_STR(parser, pos, len); \
+  rb_hash_aset(parser->headers, key, value); \
   RB_GC_GUARD(value); \
 }
 
-#define SET_HEADER_DOWNCASE_VALUE_FROM_BUFFER(state, headers, key, pos, len) { \
-  VALUE value = BUFFER_STR_DOWNCASE(state, pos, len); \
-  rb_hash_aset(headers, key, value); \
+#define SET_HEADER_DOWNCASE_VALUE_FROM_BUFFER(parser, key, pos, len) { \
+  VALUE value = BUFFER_STR_DOWNCASE(parser, pos, len); \
+  rb_hash_aset(parser->headers, key, value); \
   RB_GC_GUARD(value); \
 }
 
-#define SET_HEADER_UPCASE_VALUE_FROM_BUFFER(state, headers, key, pos, len) { \
-  VALUE value = BUFFER_STR_UPCASE(state, pos, len); \
-  rb_hash_aset(headers, key, value); \
+#define SET_HEADER_UPCASE_VALUE_FROM_BUFFER(parser, key, pos, len) { \
+  VALUE value = BUFFER_STR_UPCASE(parser, pos, len); \
+  rb_hash_aset(parser->headers, key, value); \
   RB_GC_GUARD(value); \
 }
 
-#define CONSUME_CRLF(state) { \
-  INC_BUFFER_POS(state); \
-  if (BUFFER_CUR(state) != '\n') goto bad_request; \
-  INC_BUFFER_POS(state); \
+#define SET_HEADER_VALUE_INT(parser, key, value) { \
+  rb_hash_aset(parser->headers, key, INT2FIX(value)); \
 }
 
-#define CONSUME_CRLF_NO_FILL(state) { \
-  INC_BUFFER_POS(state); \
-  if (BUFFER_CUR(state) != '\n') goto bad_request; \
-  INC_BUFFER_POS_NO_FILL(state); \
+#define CONSUME_CRLF(parser) { \
+  INC_BUFFER_POS(parser); \
+  if (BUFFER_CUR(parser) != '\n') goto bad_request; \
+  INC_BUFFER_POS(parser); \
+}
+
+#define CONSUME_CRLF_NO_FILL(parser) { \
+  INC_BUFFER_POS(parser); \
+  if (BUFFER_CUR(parser) != '\n') goto bad_request; \
+  INC_BUFFER_POS_NO_FILL(parser); \
 }
 
 #define GLOBAL_STR(v, s) v = rb_str_new_literal(s); rb_global_variable(&v); rb_obj_freeze(v)
 
-struct parser_state {
-  struct parser *parser;
-  char *ptr;
-  int len;
-};
+// case-insensitive compare
+#define CMP_CI(parser, down, up) ((BUFFER_CUR(parser) == down) || (BUFFER_CUR(parser) == up))
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -266,52 +313,68 @@ static inline VALUE io_stock_readpartial(VALUE io, VALUE maxlen, VALUE buf, VALU
 
 static inline VALUE parser_io_read(Parser_t *parser, VALUE maxlen, VALUE buf, VALUE buf_pos) {
   switch (parser->read_method) {
-    case method_backend_read:
-      return rb_funcall(mPolyphony, ID_backend_read, 5, parser->io, buf, maxlen, Qfalse, buf_pos);
-    case method_backend_recv:
-      return rb_funcall(mPolyphony, ID_backend_recv, 4, parser->io, buf, maxlen, buf_pos);
-    case method_readpartial:    
-      return rb_funcall(parser->    io, ID_readpartial, 4, maxlen, buf, buf_pos, Qfalse);
-    case method_call:   
-      return io_call(parser    ->io, maxlen, buf, buf_pos);
-    case method_stock_readpartial:
+    case RM_BACKEND_READ:
+      return rb_funcall(Polyphony(), ID_backend_read, 5, parser->io, buf, maxlen, Qfalse, buf_pos);
+    case RM_BACKEND_RECV:
+      return rb_funcall(Polyphony(), ID_backend_recv, 4, parser->io, buf, maxlen, buf_pos);
+    case RM_READPARTIAL:
+      return rb_funcall(parser->io, ID_readpartial, 4, maxlen, buf, buf_pos, Qfalse);
+    case RM_CALL:
+      return io_call(parser->io, maxlen, buf, buf_pos);
+    case RM_STOCK_READPARTIAL:
       return io_stock_readpartial(parser->io, maxlen, buf, buf_pos);
     default:
       return Qnil;
   }
 }
 
-static inline int fill_buffer(struct parser_state *state) {
-  VALUE ret = parser_io_read(state->parser, NUM_max_headers_read_length, state->parser->buffer, NUM_buffer_end);
+static inline VALUE parser_io_write(VALUE io, VALUE buf, enum write_method method) {
+  switch (method) {
+    case WM_BACKEND_WRITE:
+      return rb_funcall(Polyphony(), ID_backend_write, 2, io, buf);
+    case WM_BACKEND_SEND:
+      return rb_funcall(Polyphony(), ID_backend_send, 3, io, buf, INT2FIX(0));
+    default:
+      return Qnil;
+  }
+}
+
+static inline int parser_io_splice(VALUE src, VALUE dest, int len) {
+  VALUE ret = rb_funcall(Polyphony(), ID_backend_splice, 3, src, dest, INT2FIX(len));
+  return FIX2INT(ret);
+}
+
+static inline int fill_buffer(Parser_t *parser) {
+  VALUE ret = parser_io_read(parser, NUM_max_headers_read_length, parser->buffer, NUM_buffer_end);
   if (ret == Qnil) return 0;
 
-  state->parser->buffer = ret;
-  int len = RSTRING_LEN(state->parser->buffer);
-  int read_bytes = len - state->len;
+  parser->buffer = ret;
+  int len = RSTRING_LEN(parser->buffer);
+  int read_bytes = len - parser->buf_len;
   if (!read_bytes) return 0;
-  
-  state->ptr = RSTRING_PTR(state->parser->buffer);
-  state->len = len;
+
+  parser->buf_ptr = RSTRING_PTR(parser->buffer);
+  parser->buf_len = len;
   return read_bytes;
 }
 
-static inline void buffer_trim(struct parser_state *state) {
-  int len = RSTRING_LEN(state->parser->buffer);
-  int pos = state->parser->pos;
+static inline void buffer_trim(Parser_t *parser) {
+  int len = RSTRING_LEN(parser->buffer);
+  int pos = parser->buf_pos;
   int left = len - pos;
 
   // The buffer is trimmed only if length and position thresholds are passed,
-  // *and* position is past the halfway point. 
-  if (len < BUFFER_TRIM_MIN_LEN || 
+  // *and* position is past the halfway point.
+  if (len < BUFFER_TRIM_MIN_LEN ||
       pos < BUFFER_TRIM_MIN_POS ||
       left >= pos) return;
 
   if (left > 0) {
-    char *ptr = RSTRING_PTR(state->parser->buffer);
+    char *ptr = RSTRING_PTR(parser->buffer);
     memcpy(ptr, ptr + pos, left);
   }
-  rb_str_set_len(state->parser->buffer, left);
-  state->parser->pos = 0;
+  rb_str_set_len(parser->buffer, left);
+  parser->buf_pos = 0;
 }
 
 static inline void str_append_from_buffer(VALUE str, char *ptr, int len) {
@@ -323,28 +386,28 @@ static inline void str_append_from_buffer(VALUE str, char *ptr, int len) {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-static inline int parse_method(struct parser_state *state, VALUE headers) {
-  int pos = BUFFER_POS(state);
+static inline int parse_request_line_method(Parser_t *parser) {
+  int pos = BUFFER_POS(parser);
   int len = 0;
 
   while (1) {
-    switch (BUFFER_CUR(state)) {
+    switch (BUFFER_CUR(parser)) {
       case ' ':
         if (len < 1 || len > MAX_METHOD_LENGTH) goto bad_request;
-        INC_BUFFER_POS(state);
+        INC_BUFFER_POS(parser);
         goto done;
       case '\r':
       case '\n':
         goto bad_request;
       default:
-        INC_BUFFER_POS(state);
+        INC_BUFFER_POS(parser);
         len++;
-        // INC_BUFFER_POS_UTF8(state, len);
+        // INC_BUFFER_POS_UTF8(parser, len);
         if (len > MAX_METHOD_LENGTH) goto bad_request;
     }
   }
 done:
-  SET_HEADER_UPCASE_VALUE_FROM_BUFFER(state, headers, STR_pseudo_method, pos, len);
+  SET_HEADER_UPCASE_VALUE_FROM_BUFFER(parser, STR_pseudo_method, pos, len);
   return 1;
 bad_request:
   RAISE_BAD_REQUEST("Invalid method");
@@ -352,28 +415,28 @@ eof:
   return 0;
 }
 
-static int parse_request_target(struct parser_state *state, VALUE headers) {
-  while (BUFFER_CUR(state) == ' ') INC_BUFFER_POS(state);
-  int pos = BUFFER_POS(state);
+static int parse_request_line_target(Parser_t *parser) {
+  while (BUFFER_CUR(parser) == ' ') INC_BUFFER_POS(parser);
+  int pos = BUFFER_POS(parser);
   int len = 0;
   while (1) {
-    switch (BUFFER_CUR(state)) {
+    switch (BUFFER_CUR(parser)) {
       case ' ':
         if (len < 1 || len > MAX_PATH_LENGTH) goto bad_request;
-        INC_BUFFER_POS(state);
+        INC_BUFFER_POS(parser);
         goto done;
       case '\r':
       case '\n':
         goto bad_request;
       default:
-        INC_BUFFER_POS(state);
+        INC_BUFFER_POS(parser);
         len++;
-        // INC_BUFFER_POS_UTF8(state, len);
+        // INC_BUFFER_POS_UTF8(parser, len);
         if (len > MAX_PATH_LENGTH) goto bad_request;
     }
   }
 done:
-  SET_HEADER_VALUE_FROM_BUFFER(state, headers, STR_pseudo_path, pos, len);
+  SET_HEADER_VALUE_FROM_BUFFER(parser, STR_pseudo_path, pos, len);
   return 1;
 bad_request:
   RAISE_BAD_REQUEST("Invalid request target");
@@ -381,34 +444,31 @@ eof:
   return 0;
 }
 
-// case-insensitive compare
-#define CMP_CI(state, down, up) ((BUFFER_CUR(state) == down) || (BUFFER_CUR(state) == up))
-
-static int parse_protocol(struct parser_state *state, VALUE headers) {
-  while (BUFFER_CUR(state) == ' ') INC_BUFFER_POS(state);
-  int pos = BUFFER_POS(state);
+static int parse_request_line_protocol(Parser_t *parser) {
+  while (BUFFER_CUR(parser) == ' ') INC_BUFFER_POS(parser);
+  int pos = BUFFER_POS(parser);
   int len = 0;
 
-  if (CMP_CI(state, 'H', 'h')) INC_BUFFER_POS(state) else goto bad_request;
-  if (CMP_CI(state, 'T', 't')) INC_BUFFER_POS(state) else goto bad_request;
-  if (CMP_CI(state, 'T', 't')) INC_BUFFER_POS(state) else goto bad_request;
-  if (CMP_CI(state, 'P', 'p')) INC_BUFFER_POS(state) else goto bad_request;
-  if (BUFFER_CUR(state) == '/') INC_BUFFER_POS(state) else goto bad_request;
-  if (BUFFER_CUR(state) == '1') INC_BUFFER_POS(state) else goto bad_request;
+  if (CMP_CI(parser, 'H', 'h')) INC_BUFFER_POS(parser) else goto bad_request;
+  if (CMP_CI(parser, 'T', 't')) INC_BUFFER_POS(parser) else goto bad_request;
+  if (CMP_CI(parser, 'T', 't')) INC_BUFFER_POS(parser) else goto bad_request;
+  if (CMP_CI(parser, 'P', 'p')) INC_BUFFER_POS(parser) else goto bad_request;
+  if (BUFFER_CUR(parser) == '/') INC_BUFFER_POS(parser) else goto bad_request;
+  if (BUFFER_CUR(parser) == '1') INC_BUFFER_POS(parser) else goto bad_request;
   len = 6;
   while (1) {
-    switch (BUFFER_CUR(state)) {
+    switch (BUFFER_CUR(parser)) {
       case '\r':
-        CONSUME_CRLF(state);
+        CONSUME_CRLF(parser);
         goto done;
       case '\n':
-        INC_BUFFER_POS(state);
+        INC_BUFFER_POS(parser);
         goto done;
       case '.':
-        INC_BUFFER_POS(state);
-        char c = BUFFER_CUR(state);
+        INC_BUFFER_POS(parser);
+        char c = BUFFER_CUR(parser);
         if (c == '0' || c == '1') {
-          INC_BUFFER_POS(state);
+          INC_BUFFER_POS(parser);
           len += 2;
           continue;
         }
@@ -419,7 +479,7 @@ static int parse_protocol(struct parser_state *state, VALUE headers) {
   }
 done:
   if (len < 6 || len > 8) goto bad_request;
-  SET_HEADER_DOWNCASE_VALUE_FROM_BUFFER(state, headers, STR_pseudo_protocol, pos, len);
+  SET_HEADER_DOWNCASE_VALUE_FROM_BUFFER(parser, STR_pseudo_protocol, pos, len);
   return 1;
 bad_request:
   RAISE_BAD_REQUEST("Invalid protocol");
@@ -427,48 +487,159 @@ eof:
   return 0;
 }
 
-int parse_request_line(struct parser_state *state, VALUE headers) {
-  if (!parse_method(state, headers)) goto eof;
-  if (!parse_request_target(state, headers)) goto eof;
-  if (!parse_protocol(state, headers)) goto eof;
+static inline int parse_request_line(Parser_t *parser) {
+  if (!parse_request_line_method(parser)) goto eof;
+  if (!parse_request_line_target(parser)) goto eof;
+  if (!parse_request_line_protocol(parser)) goto eof;
 
   return 1;
 eof:
   return 0;
 }
 
-static inline int parse_header_key(struct parser_state *state, VALUE *key) {
-  int pos = BUFFER_POS(state);
+static inline int parse_status_line_protocol(Parser_t *parser) {
+  int pos = BUFFER_POS(parser);
   int len = 0;
 
+  if (CMP_CI(parser, 'H', 'h')) INC_BUFFER_POS(parser) else goto bad_request;
+  if (CMP_CI(parser, 'T', 't')) INC_BUFFER_POS(parser) else goto bad_request;
+  if (CMP_CI(parser, 'T', 't')) INC_BUFFER_POS(parser) else goto bad_request;
+  if (CMP_CI(parser, 'P', 'p')) INC_BUFFER_POS(parser) else goto bad_request;
+  if (BUFFER_CUR(parser) == '/') INC_BUFFER_POS(parser) else goto bad_request;
+  if (BUFFER_CUR(parser) == '1') INC_BUFFER_POS(parser) else goto bad_request;
+  len = 6;
   while (1) {
-    switch (BUFFER_CUR(state)) {
+    switch (BUFFER_CUR(parser)) {
+      case '.':
+        INC_BUFFER_POS(parser);
+        char c = BUFFER_CUR(parser);
+        if (c == '0' || c == '1') {
+          INC_BUFFER_POS(parser);
+          len += 2;
+          continue;
+        }
+        goto bad_request;
+      case ' ':
+        INC_BUFFER_POS(parser);
+        goto done;
+      default:
+        goto bad_request;
+    }
+  }
+done:
+  if (len < 6 || len > 8) goto bad_request;
+  SET_HEADER_DOWNCASE_VALUE_FROM_BUFFER(parser, STR_pseudo_protocol, pos, len);
+  return 1;
+bad_request:
+  RAISE_BAD_REQUEST("Invalid protocol");
+eof:
+  return 0;
+}
+
+static inline int parse_status_line_status(Parser_t *parser) {
+  while (BUFFER_CUR(parser) == ' ') INC_BUFFER_POS(parser);
+  int len = 0;
+  int status = 0;
+  while (1) {
+    if (len > 4) goto bad_request;
+    
+    char c = BUFFER_CUR(parser);
+    if (c >= '0' && c <= '9') {
+      status = status * 10 + (c - '0');
+      len += 1;
+      INC_BUFFER_POS(parser);
+      continue;
+    }
+    switch (c) {
+      case ' ':
+        INC_BUFFER_POS(parser);
+        goto done;
+      case '\r':
+      case '\n':
+        goto done;
+      default:
+        goto bad_request;
+    }
+  }
+done:
+  SET_HEADER_VALUE_INT(parser, STR_pseudo_status, status);
+  return 1;
+bad_request:
+  RAISE_BAD_REQUEST("Invalid response status");
+eof:
+  return 0;
+}
+
+static inline int parse_status_line_status_message(Parser_t *parser) {
+  while (BUFFER_CUR(parser) == ' ') INC_BUFFER_POS(parser);
+  int pos = BUFFER_POS(parser);
+  int len = 0;
+  while (1) {
+    switch (BUFFER_CUR(parser)) {
+      case '\r':
+        CONSUME_CRLF(parser);
+        goto done;
+      case '\n':
+        INC_BUFFER_POS(parser);
+        goto done;
+      default:
+        INC_BUFFER_POS(parser);
+        len++;
+        if (len > MAX_STATUS_MESSAGE_LENGTH) goto bad_request;
+    }
+  }
+done:
+  SET_HEADER_VALUE_FROM_BUFFER(parser, STR_pseudo_status_message, pos, len);
+  return 1;
+bad_request:
+  RAISE_BAD_REQUEST("Invalid request target");
+eof:
+  return 0;
+}
+
+
+static inline int parse_status_line(Parser_t *parser) {
+  if (!parse_status_line_protocol(parser)) goto eof;
+  if (!parse_status_line_status(parser)) goto eof;
+  if (!parse_status_line_status_message(parser)) goto eof;
+
+  return 1;
+eof:
+  return 0;
+}
+
+static inline int parse_header_key(Parser_t *parser, VALUE *key) {
+  int pos = BUFFER_POS(parser);
+  int len = 0;
+
+  while (1) {
+    switch (BUFFER_CUR(parser)) {
       case ' ':
         goto bad_request;
       case ':':
         if (len < 1 || len > MAX_HEADER_KEY_LENGTH)
           goto bad_request;
-        INC_BUFFER_POS(state);
+        INC_BUFFER_POS(parser);
         goto done;
       case '\r':
-        if (BUFFER_POS(state) > pos) goto bad_request;
-        CONSUME_CRLF_NO_FILL(state);
+        if (BUFFER_POS(parser) > pos) goto bad_request;
+        CONSUME_CRLF_NO_FILL(parser);
         goto done;
       case '\n':
-        if (BUFFER_POS(state) > pos) goto bad_request;
+        if (BUFFER_POS(parser) > pos) goto bad_request;
 
-        INC_BUFFER_POS_NO_FILL(state);
+        INC_BUFFER_POS_NO_FILL(parser);
         goto done;
       default:
-        INC_BUFFER_POS(state);
+        INC_BUFFER_POS(parser);
         len++;
-        // INC_BUFFER_POS_UTF8(state, len);
+        // INC_BUFFER_POS_UTF8(parser, len);
         if (len > MAX_HEADER_KEY_LENGTH) goto bad_request;
     }
   }
 done:
   if (len == 0) return -1;
-  (*key) = BUFFER_STR_DOWNCASE(state, pos, len);
+  (*key) = BUFFER_STR_DOWNCASE(parser, pos, len);
   return 1;
 bad_request:
   RAISE_BAD_REQUEST("Invalid header key");
@@ -476,28 +647,28 @@ eof:
   return 0;
 }
 
-static inline int parse_header_value(struct parser_state *state, VALUE *value) {
-  while (BUFFER_CUR(state) == ' ') INC_BUFFER_POS(state);
+static inline int parse_header_value(Parser_t *parser, VALUE *value) {
+  while (BUFFER_CUR(parser) == ' ') INC_BUFFER_POS(parser);
 
-  int pos = BUFFER_POS(state);
+  int pos = BUFFER_POS(parser);
   int len = 0;
 
   while (1) {
-    switch (BUFFER_CUR(state)) {
+    switch (BUFFER_CUR(parser)) {
       case '\r':
-        CONSUME_CRLF(state);
+        CONSUME_CRLF(parser);
         goto done;
       case '\n':
-        INC_BUFFER_POS(state);
+        INC_BUFFER_POS(parser);
         goto done;
       default:
-        INC_BUFFER_POS_UTF8(state, len);
+        INC_BUFFER_POS_UTF8(parser, len);
         if (len > MAX_HEADER_VALUE_LENGTH) goto bad_request;
     }
   }
 done:
   if (len < 1 || len > MAX_HEADER_VALUE_LENGTH) goto bad_request;
-  (*value) = BUFFER_STR(state, pos, len);
+  (*value) = BUFFER_STR(parser, pos, len);
   return 1;
 bad_request:
   RAISE_BAD_REQUEST("Invalid header value");
@@ -505,27 +676,27 @@ eof:
   return 0;
 }
 
-static inline int parse_header(struct parser_state *state, VALUE headers) {
+static inline int parse_header(Parser_t *parser) {
   VALUE key, value;
 
-  switch (parse_header_key(state, &key)) {
+  switch (parse_header_key(parser, &key)) {
     case -1: return -1;
     case 0: goto eof;
   }
 
-  if (!parse_header_value(state, &value)) goto eof;
+  if (!parse_header_value(parser, &value)) goto eof;
 
-  VALUE existing = rb_hash_aref(headers, key);
+  VALUE existing = rb_hash_aref(parser->headers, key);
   if (existing != Qnil) {
     if (TYPE(existing) != T_ARRAY) {
       existing = rb_ary_new3(2, existing, value);
-      rb_hash_aset(headers, key, existing);
+      rb_hash_aset(parser->headers, key, existing);
     }
     else
       rb_ary_push(existing, value);
   }
   else
-    rb_hash_aset(headers, key, value);
+    rb_hash_aset(parser->headers, key, value);
 
   RB_GC_GUARD(existing);
   RB_GC_GUARD(key);
@@ -536,36 +707,41 @@ eof:
 }
 
 VALUE Parser_parse_headers(VALUE self) {
-  struct parser_state state;
-  GetParser(self, state.parser);
-  state.parser->headers = rb_hash_new();
+  Parser_t *parser;
+  GetParser(self, parser);
+  parser->headers = rb_hash_new();
 
-  buffer_trim(&state);
-  int initial_pos = state.parser->pos;
-  INIT_PARSER_STATE(&state);
-  state.parser->current_request_rx = 0;
+  buffer_trim(parser);
+  int initial_pos = parser->buf_pos;
+  INIT_PARSER_STATE(parser);
+  parser->current_request_rx = 0;
 
-  if (!parse_request_line(&state, state.parser->headers)) goto eof;
+  if (parser->mode == mode_server) {
+    if (!parse_request_line(parser)) goto eof;
+  }
+  else {
+    if (!parse_status_line(parser)) goto eof;
+  }
 
   int header_count = 0;
   while (1) {
     if (header_count > MAX_HEADER_COUNT) RAISE_BAD_REQUEST("Too many headers");
-    switch (parse_header(&state, state.parser->headers)) {
+    switch (parse_header(parser)) {
       case -1: goto done; // empty header => end of headers
       case 0: goto eof;
     }
     header_count++;
   }
 eof:
-  state.parser->headers = Qnil;
+  parser->headers = Qnil;
 done:
-  state.parser->body_read_mode = BODY_READ_MODE_UNKNOWN;
-  int read_bytes = BUFFER_POS(&state) - initial_pos;
+  parser->body_read_mode = BODY_READ_MODE_UNKNOWN;
+  int read_bytes = BUFFER_POS(parser) - initial_pos;
 
-  state.parser->current_request_rx += read_bytes;
-  if (state.parser->headers != Qnil)
-    rb_hash_aset(state.parser->headers, STR_pseudo_rx, INT2NUM(read_bytes));
-  return state.parser->headers;
+  parser->current_request_rx += read_bytes;
+  if (parser->headers != Qnil)
+    rb_hash_aset(parser->headers, STR_pseudo_rx, INT2FIX(read_bytes));
+  return parser->headers;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -594,13 +770,13 @@ VALUE read_body_with_content_length(Parser_t *parser, int read_entire_body, int
   VALUE body = Qnil;
 
   int len = RSTRING_LEN(parser->buffer);
-  int pos = parser->pos;
+  int pos = BUFFER_POS(parser);
 
   if (pos < len) {
     int available = len - pos;
     if (available > parser->body_left) available = parser->body_left;
     body = rb_str_new(RSTRING_PTR(parser->buffer) + pos, available);
-    parser->pos += available;
+    BUFFER_POS(parser) += available;
     parser->current_request_rx += available;
     parser->body_left -= available;
     if (!parser->body_left) parser->request_completed = 1;
@@ -610,10 +786,10 @@ VALUE read_body_with_content_length(Parser_t *parser, int read_entire_body, int
     len = 0;
   }
   if (buffered_only) return body;
-  
+
   while (parser->body_left) {
     int maxlen = parser->body_left <= MAX_BODY_READ_LENGTH ? parser->body_left : MAX_BODY_READ_LENGTH;
-    VALUE tmp_buf = parser_io_read(parser, INT2NUM(maxlen), Qnil, NUM_buffer_start);
+    VALUE tmp_buf = parser_io_read(parser, INT2FIX(maxlen), Qnil, NUM_buffer_start);
     if (tmp_buf == Qnil) goto eof;
     if (body != Qnil)
       rb_str_append(body, tmp_buf);
@@ -627,7 +803,7 @@ VALUE read_body_with_content_length(Parser_t *parser, int read_entire_body, int
     if (!read_entire_body) goto done;
   }
 done:
-  rb_hash_aset(parser->headers, STR_pseudo_rx, INT2NUM(parser->current_request_rx));
+  rb_hash_aset(parser->headers, STR_pseudo_rx, INT2FIX(parser->current_request_rx));
   RB_GC_GUARD(body);
   return body;
 eof:
@@ -639,34 +815,34 @@ int chunked_encoding_p(VALUE transfer_encoding) {
   return rb_funcall(str_downcase(transfer_encoding), ID_eq, 1, STR_chunked) == Qtrue;
 }
 
-int parse_chunk_size(struct parser_state *state, int *chunk_size) {
+int parse_chunk_size(Parser_t *parser, int *chunk_size) {
   int len = 0;
   int value = 0;
-  int initial_pos = BUFFER_POS(state);
+  int initial_pos = BUFFER_POS(parser);
 
   while (1) {
-    char c = BUFFER_CUR(state);
+    char c = BUFFER_CUR(parser);
     if ((c >= '0') && (c <= '9'))       value = (value << 4) + (c - '0');
     else if ((c >= 'a') && (c <= 'f'))  value = (value << 4) + (c - 'a' + 10);
     else if ((c >= 'A') && (c <= 'F'))  value = (value << 4) + (c - 'A' + 10);
     else switch (c) {
       case '\r':
-        CONSUME_CRLF_NO_FILL(state);
+        CONSUME_CRLF_NO_FILL(parser);
         goto done;
       case '\n':
-        INC_BUFFER_POS_NO_FILL(state);
+        INC_BUFFER_POS_NO_FILL(parser);
         goto done;
       default:
         goto bad_request;
     }
-    INC_BUFFER_POS(state);
+    INC_BUFFER_POS(parser);
     len++;
     if (len >= MAX_CHUNKED_ENCODING_CHUNK_SIZE_LENGTH) goto bad_request;
   }
 done:
   if (len == 0) goto bad_request;
   (*chunk_size) = value;
-  state->parser->current_request_rx += BUFFER_POS(state) - initial_pos;
+  parser->current_request_rx += BUFFER_POS(parser) - initial_pos;
   return 1;
 bad_request:
   RAISE_BAD_REQUEST("Invalid chunk size");
@@ -674,20 +850,20 @@ eof:
   return 0;
 }
 
-int read_body_chunk_with_chunked_encoding(struct parser_state *state, VALUE *body, int chunk_size, int buffered_only) {
-  int len = RSTRING_LEN(state->parser->buffer);
-  int pos = state->parser->pos;
+int read_body_chunk_with_chunked_encoding(Parser_t *parser, VALUE *body, int chunk_size, int buffered_only) {
+  int len = RSTRING_LEN(parser->buffer);
+  int pos = BUFFER_POS(parser);
   int left = chunk_size;
 
   if (pos < len) {
     int available = len - pos;
     if (available > left) available = left;
     if (*body != Qnil)
-      str_append_from_buffer(*body, RSTRING_PTR(state->parser->buffer) + pos, available);
+      str_append_from_buffer(*body, RSTRING_PTR(parser->buffer) + pos, available);
     else
-      *body = rb_str_new(RSTRING_PTR(state->parser->buffer) + pos, available);
-    state->parser->pos += available;
-    state->parser->current_request_rx += available;
+      *body = rb_str_new(RSTRING_PTR(parser->buffer) + pos, available);
+    BUFFER_POS(parser) += available;
+    parser->current_request_rx += available;
     left -= available;
   }
   if (buffered_only) return 1;
@@ -695,14 +871,14 @@ int read_body_chunk_with_chunked_encoding(struct parser_state *state, VALUE *bod
   while (left) {
     int maxlen = left <= MAX_BODY_READ_LENGTH ? left : MAX_BODY_READ_LENGTH;
 
-    VALUE tmp_buf = parser_io_read(state->parser, INT2NUM(maxlen), Qnil, NUM_buffer_start);
+    VALUE tmp_buf = parser_io_read(parser, INT2FIX(maxlen), Qnil, NUM_buffer_start);
     if (tmp_buf == Qnil) goto eof;
     if (*body != Qnil)
       rb_str_append(*body, tmp_buf);
     else
       *body = tmp_buf;
     int read_bytes = RSTRING_LEN(tmp_buf);
-    state->parser->current_request_rx += read_bytes;
+    parser->current_request_rx += read_bytes;
     left -= read_bytes;
     RB_GC_GUARD(tmp_buf);
   }
@@ -711,46 +887,71 @@ eof:
   return 0;
 }
 
-static inline int parse_chunk_postfix(struct parser_state *state) {
-  int initial_pos = BUFFER_POS(state);
-  if (initial_pos == BUFFER_LEN(state)) FILL_BUFFER_OR_GOTO_EOF(state);
-  switch (BUFFER_CUR(state)) {
+int splice_body_chunk_with_chunked_encoding(Parser_t *parser, VALUE dest, int chunk_size, enum write_method method) {
+  int len = RSTRING_LEN(parser->buffer);
+  int pos = BUFFER_POS(parser);
+  int left = chunk_size;
+
+  if (pos < len) {
+    int available = len - pos;
+    if (available > left) available = left;
+    VALUE buf = rb_str_new(RSTRING_PTR(parser->buffer) + pos, available);
+    BUFFER_POS(parser) += available;
+    parser->current_request_rx += available;
+    parser_io_write(dest, buf, method);
+    RB_GC_GUARD(buf);
+    left -= available;
+  }
+
+  while (left) {
+    int spliced = parser_io_splice(parser->io, dest, left);
+    if (!spliced) goto eof;
+    parser->current_request_rx += spliced;
+    left -= spliced;
+  }
+  return 1;
+eof:
+  return 0;
+}
+
+static inline int parse_chunk_postfix(Parser_t *parser) {
+  int initial_pos = BUFFER_POS(parser);
+  if (initial_pos == BUFFER_LEN(parser)) FILL_BUFFER_OR_GOTO_EOF(parser);
+  switch (BUFFER_CUR(parser)) {
     case '\r':
-      CONSUME_CRLF_NO_FILL(state);
+      CONSUME_CRLF_NO_FILL(parser);
       goto done;
     case '\n':
-      INC_BUFFER_POS_NO_FILL(state);
+      INC_BUFFER_POS_NO_FILL(parser);
       goto done;
     default:
       goto bad_request;
   }
 done:
-  state->parser->current_request_rx += BUFFER_POS(state) - initial_pos;
+  parser->current_request_rx += BUFFER_POS(parser) - initial_pos;
   return 1;
 bad_request:
-  RAISE_BAD_REQUEST("Invalid protocol");
+  RAISE_BAD_REQUEST("Invalid chunk");
 eof:
   return 0;
 }
 
 VALUE read_body_with_chunked_encoding(Parser_t *parser, int read_entire_body, int buffered_only) {
-  struct parser_state state;
-  state.parser = parser;
-  buffer_trim(&state);
-  INIT_PARSER_STATE(&state);
+  buffer_trim(parser);
+  INIT_PARSER_STATE(parser);
   VALUE body = Qnil;
 
   while (1) {
     int chunk_size = 0;
-    if (BUFFER_POS(&state) == BUFFER_LEN(&state)) FILL_BUFFER_OR_GOTO_EOF(&state);
-    if (!parse_chunk_size(&state, &chunk_size)) goto bad_request;
-    
+    if (BUFFER_POS(parser) == BUFFER_LEN(parser)) FILL_BUFFER_OR_GOTO_EOF(parser);
+    if (!parse_chunk_size(parser, &chunk_size)) goto bad_request;
+
     if (chunk_size) {
-      if (!read_body_chunk_with_chunked_encoding(&state, &body, chunk_size, buffered_only)) goto bad_request;
+      if (!read_body_chunk_with_chunked_encoding(parser, &body, chunk_size, buffered_only)) goto bad_request;
     }
     else parser->request_completed = 1;
 
-    if (!parse_chunk_postfix(&state)) goto bad_request;
+    if (!parse_chunk_postfix(parser)) goto bad_request;
     if (!chunk_size || !read_entire_body) goto done;
   }
 bad_request:
@@ -758,11 +959,70 @@ bad_request:
 eof:
   RAISE_BAD_REQUEST("Incomplete request body");
 done:
-  rb_hash_aset(parser->headers, STR_pseudo_rx, INT2NUM(state.parser->current_request_rx));
+  rb_hash_aset(parser->headers, STR_pseudo_rx, INT2FIX(parser->current_request_rx));
   RB_GC_GUARD(body);
   return body;
 }
 
+void splice_body_with_chunked_encoding(Parser_t *parser, VALUE dest, enum write_method method) {
+  buffer_trim(parser);
+  INIT_PARSER_STATE(parser);
+
+  while (1) {
+    int chunk_size = 0;
+    if (BUFFER_POS(parser) == BUFFER_LEN(parser)) FILL_BUFFER_OR_GOTO_EOF(parser);
+    if (!parse_chunk_size(parser, &chunk_size)) goto bad_request;
+
+    if (chunk_size) {
+      if (!splice_body_chunk_with_chunked_encoding(parser, dest, chunk_size, method))
+        goto bad_request;
+    }
+    else
+      parser->request_completed = 1;
+
+    // read post-chunk delimiter ("\r\n")
+    if (!parse_chunk_postfix(parser)) goto bad_request;
+    if (!chunk_size) goto done;
+  }
+bad_request:
+  RAISE_BAD_REQUEST("Malformed request body");
+eof:
+  RAISE_BAD_REQUEST("Incomplete request body");
+done:
+  rb_hash_aset(parser->headers, STR_pseudo_rx, INT2FIX(parser->current_request_rx));
+}
+
+void splice_body_with_content_length(Parser_t *parser, VALUE dest, enum write_method method)  {
+  if (parser->body_left <= 0) return;
+
+  int len = RSTRING_LEN(parser->buffer);
+  int pos = BUFFER_POS(parser);
+
+  if (pos < len) {
+    int available = len - pos;
+    if (available > parser->body_left) available = parser->body_left;
+    VALUE buf = rb_str_new(RSTRING_PTR(parser->buffer) + pos, available);
+    BUFFER_POS(parser) += available;
+    parser_io_write(dest, buf, method);
+    RB_GC_GUARD(buf);
+    parser->current_request_rx += available;
+    parser->body_left -= available;
+    if (!parser->body_left) parser->request_completed = 1;
+  }
+
+  while (parser->body_left) {
+    int spliced = parser_io_splice(parser->io, dest, parser->body_left);
+    if (!spliced) goto eof;
+    parser->current_request_rx += spliced;
+    parser->body_left -= spliced;
+  }
+done:
+  rb_hash_aset(parser->headers, STR_pseudo_rx, INT2FIX(parser->current_request_rx));
+  return;
+eof:
+  RAISE_BAD_REQUEST("Incomplete body");
+}
+
 static inline void detect_body_read_mode(Parser_t *parser) {
   VALUE content_length = rb_hash_aref(parser->headers, STR_content_length);
   if (content_length != Qnil) {
@@ -772,7 +1032,7 @@ static inline void detect_body_read_mode(Parser_t *parser) {
     parser->request_completed = 0;
     return;
   }
-  
+
   VALUE transfer_encoding = rb_hash_aref(parser->headers, STR_transfer_encoding);
   if (chunked_encoding_p(transfer_encoding)) {
     parser->body_read_mode = BODY_READ_MODE_CHUNKED;
@@ -792,7 +1052,8 @@ static inline VALUE read_body(VALUE self, int read_entire_body, int buffered_onl
 
   if (parser->body_read_mode == BODY_READ_MODE_CHUNKED)
     return read_body_with_chunked_encoding(parser, read_entire_body, buffered_only);
-  return read_body_with_content_length(parser, read_entire_body, buffered_only);
+  else
+    return read_body_with_content_length(parser, read_entire_body, buffered_only);
 }
 
 VALUE Parser_read_body(VALUE self) {
@@ -803,6 +1064,22 @@ VALUE Parser_read_body_chunk(VALUE self, VALUE buffered_only) {
   return read_body(self, 0, buffered_only == Qtrue);
 }
 
+VALUE Parser_splice_body_to(VALUE self, VALUE dest) {
+  Parser_t *parser;
+  GetParser(self, parser);
+  enum write_method method = detect_write_method(dest);
+
+  if (parser->body_read_mode == BODY_READ_MODE_UNKNOWN)
+    detect_body_read_mode(parser);
+
+  if (parser->body_read_mode == BODY_READ_MODE_CHUNKED)
+    splice_body_with_chunked_encoding(parser, dest, method);
+  else
+    splice_body_with_content_length(parser, dest, method);
+  
+  return self;
+}
+
 VALUE Parser_complete_p(VALUE self) {
   Parser_t *parser;
   GetParser(self, parser);
@@ -826,41 +1103,54 @@ void Init_H1P() {
   rb_gc_register_mark_object(cError);
 
   // backend methods
-  rb_define_method(cParser, "initialize", Parser_initialize, 1);
+  rb_define_method(cParser, "initialize", Parser_initialize, 2);
   rb_define_method(cParser, "parse_headers", Parser_parse_headers, 0);
   rb_define_method(cParser, "read_body", Parser_read_body, 0);
   rb_define_method(cParser, "read_body_chunk", Parser_read_body_chunk, 1);
+  rb_define_method(cParser, "splice_body_to", Parser_splice_body_to, 1);
   rb_define_method(cParser, "complete?", Parser_complete_p, 0);
 
   ID_arity                  = rb_intern("arity");
   ID_backend_read           = rb_intern("backend_read");
   ID_backend_recv           = rb_intern("backend_recv");
+  ID_backend_send           = rb_intern("backend_send");
+  ID_backend_splice         = rb_intern("backend_splice");
+  ID_backend_write          = rb_intern("backend_write");
   ID_call                   = rb_intern("call");
   ID_downcase               = rb_intern("downcase");
   ID_eof_p                  = rb_intern("eof?");
   ID_eq                     = rb_intern("==");
-  ID_parser_read_method     = rb_intern("__parser_read_method__");
+  ID_read_method            = rb_intern("__read_method__");
   ID_read                   = rb_intern("read");
   ID_readpartial            = rb_intern("readpartial");
   ID_to_i                   = rb_intern("to_i");
   ID_upcase                 = rb_intern("upcase");
+  ID_write_method           = rb_intern("__write_method__");
 
-  NUM_max_headers_read_length = INT2NUM(MAX_HEADERS_READ_LENGTH);
-  NUM_buffer_start = INT2NUM(0);
-  NUM_buffer_end = INT2NUM(-1);
+  NUM_max_headers_read_length = INT2FIX(MAX_HEADERS_READ_LENGTH);
+  NUM_buffer_start = INT2FIX(0);
+  NUM_buffer_end = INT2FIX(-1);
 
-  GLOBAL_STR(STR_pseudo_method,       ":method");
-  GLOBAL_STR(STR_pseudo_path,         ":path");
-  GLOBAL_STR(STR_pseudo_protocol,     ":protocol");
-  GLOBAL_STR(STR_pseudo_rx,           ":rx");
+  GLOBAL_STR(STR_pseudo_method,         ":method");
+  GLOBAL_STR(STR_pseudo_path,           ":path");
+  GLOBAL_STR(STR_pseudo_protocol,       ":protocol");
+  GLOBAL_STR(STR_pseudo_rx,             ":rx");
+  GLOBAL_STR(STR_pseudo_status,         ":status");
+  GLOBAL_STR(STR_pseudo_status_message, ":status_message");
 
-  GLOBAL_STR(STR_chunked,             "chunked");
-  GLOBAL_STR(STR_content_length,      "content-length");
-  GLOBAL_STR(STR_transfer_encoding,   "transfer-encoding");
+  GLOBAL_STR(STR_chunked,               "chunked");
+  GLOBAL_STR(STR_content_length,        "content-length");
+  GLOBAL_STR(STR_transfer_encoding,     "transfer-encoding");
+
+  SYM_backend_read  = ID2SYM(ID_backend_read);
+  SYM_backend_recv  = ID2SYM(ID_backend_recv);
+  SYM_backend_send  = ID2SYM(ID_backend_send);
+  SYM_backend_write = ID2SYM(ID_backend_write);
 
-  SYM_backend_read = ID2SYM(ID_backend_read);
-  SYM_backend_recv = ID2SYM(ID_backend_recv);
   SYM_stock_readpartial = ID2SYM(rb_intern("stock_readpartial"));
+  
+  SYM_client = ID2SYM(rb_intern("client"));
+  SYM_server = ID2SYM(rb_intern("server"));
 
   rb_global_variable(&mH1P);
 }