bossan 0.3.0 → 0.4.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZjFiOTYwNTUwMTUwNGFkYmJjOWQwYzdiMjA3NzVlOGI0NDhkNjMxNg==
-  data.tar.gz: !binary |-
-    ODU1NGExMjUxYzVmOTQ2NDE3Y2U3ZDg1YzMwNzY0OTliYjE4ZjU1OA==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    OTUxMWUwMGIxYmM0ZWUwODNjYzNlMTVlYjk5MmE2YTJjMmQ0YzMxMmQ1N2Uz
-    NjM5ZjA3MmE4NTAzM2JmNjNmZWQxYjY5MTdiYWMxZjUzYzE5NGNkODRhODlm
-    NzhlZjVkNDAwYjhkMDE2MTRiNzdiMzJmMWRkMGVhMjY1YzMwMDM=
-  data.tar.gz: !binary |-
-    ZjNhZjE4ZDgxZmNmOWQ5M2UyMWVjOTI3OGZiNWU1ZmUyYzg1ZGMxMzQ4OWRk
-    ODg4OGE1YWQ1YzU0YmE3Y2FhOTkxZWNhY2YxYzcxYTAzYjFiNTA1NTMwNDYw
-    MTU5YTk5MWQ3Y2ZiNzUwOGFlMzRjM2I5NzgyY2FlYjBjMmVmZDg=
+SHA1:
+  metadata.gz: a6c9a88db061e6810d579b2bbd96d1883353e0dc
+  data.tar.gz: 2b24f8d88a989cf4f6bb388297f7aca5d79d93bf
+SHA512:
+  metadata.gz: dbe2c03e817dae7af733fbd451e211a5ec04288a4a472c4cc3782844145f344640c9f6752ca594c5be7aa285fe96c5072c37818c3dabc62c04f59e2975fec600
+  data.tar.gz: 825ce88118370976ef9ca6c3f1161ee402a3c3fcf2e5faa6d2b513285f84f35da6bf708a49e4b433abaf954d2209049351a2393ee42a06f3a9a494ebdb8c164f

data/.travis.yml

@@ -1,4 +1,5 @@
 language: ruby
 rvm:
   - 1.9.2
-  - 1.9.3
+  - 1.9.3
+  - 2.0.0

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # CHANGELOG
 
+### v0.4.0
+
+(New Feature release. release 2013-0X-XX)
+
+* Support RFC2616(HTTP/1.1)
+
+* fix reason phrase
+
+### v0.3.0
+
+(New Feature release. release 2013-06-28)
+
+* Add Bossan.listen method, for supporting pre-fork server
+
+* change API Bossan.run
+
 ### v0.2.0
 
 (New Feature release. release 2013-05-22)

data/README.md

@@ -31,14 +31,16 @@ simple rack app:
 ``` ruby
 require 'bossan'
 
-Bossan.run('127.0.0.1', 8000, proc {|env|
+Bossan.listen('127.0.0.1', 8000)
+Bossan.run(proc {|env|
+  body = ['hello, world!']        # Response body
   [
    200,          # Status code
    {             # Response headers
      'Content-Type' => 'text/html',
-     'Content-Length' => '13',
+     'Content-Length' => body.join.size.to_s,
    },
-   ['hello, world!']        # Response body
+   body
   ]
 })
 ```

data/examples/fork_sample.rb

@@ -13,6 +13,6 @@ app = ->(env){
 
 Bossan.set_keepalive(10)
 Bossan.listen('localhost', 8000)
-workers = Parallel.each([0,1,2,3]) {|i|
+Parallel.each([0,1,2,3]) {
   Bossan.run(app)
 }

data/examples/hello.rb

@@ -1,14 +1,14 @@
 require_relative '../lib/bossan'
 
 Bossan.listen('127.0.0.1', 8000)
-Bossn.run(proc {|env|
-            body = 'hello, world!'
-            [
-             200,          # Status code
-             {             # Response headers
-               'Content-Type' => 'text/html',
-               'Content-Length' => body.size.to_s,
-             },
-             [body]        # Response body
-            ]
-          })
+Bossan.run(proc {|env|
+             body = ['hello, world!']
+             [
+              200,          # Status code
+              {             # Response headers
+                'Content-Type' => 'text/html',
+                'Content-Length' => body.join.size.to_s,
+              },
+              body        # Response body
+             ]
+           })

data/examples/uploads.rb

@@ -4,9 +4,6 @@ require 'tempfile'
 
 
 def view_file req
-  # p req
-  # p req.env['rack.input']
-
   tempfile = Tempfile.new('raw-upload.')
   req.env['rack.input'].each do |chunk|
     if chunk.respond_to?(:force_encoding)
@@ -21,11 +18,10 @@ def view_file req
   tempfile.flush
   tempfile.rewind
 
-  # return Rack::File.new(tempfile)
-  return Rack::Multipart::UploadedFile.new(tempfile, req.content_type, true)
-  # return Rack::Response.new(req.env["rack.input"],
-  #                           200,
-  #                           {"Content-Type" => req.content_type})
+  return Rack::Response.new(tempfile,
+                            200,
+                            { "Content-Length" => req.env["CONTENT_LENGTH"],
+                              "Content-Type" => 'image/jpeg'})
 end
 
 
@@ -38,7 +34,7 @@ def upload_file req
 EOF
                             ],
                             200,
-                            ).to_a
+                            )
 end
 
 
@@ -55,5 +51,5 @@ app = ->(env) {
 
 
 Bossan.set_max_content_length(1024 * 1024 * 1024)
-Bossan.run('localhost', 8000)
-Bossan.listen(app)
+Bossan.listen('localhost', 8000)
+Bossan.run(app)

data/ext/bossan/bossan.h

@@ -3,8 +3,9 @@
 
 #include "ruby.h"
 #include <assert.h>
-#include <fcntl.h>   
-#include <stddef.h> 
+#include <fcntl.h> 
+#include <stddef.h>
+#include <stdlib.h>
 #include <unistd.h>
 #include <errno.h>
 #include <arpa/inet.h>
@@ -26,36 +27,36 @@
 /* #define DEVELOP */
 
 #ifdef DEVELOP
-#define DEBUG(...) \
-    do { \
-        printf("%-40s %-26s%4u: ", __FILE__, __func__, __LINE__); \
-        printf(__VA_ARGS__); \
-        printf("\n"); \
-    } while(0)
-#define RDEBUG(...) \
-    do { \
-        printf("\x1B[31m%-40s %-26s%4u: ", __FILE__, __func__, __LINE__); \
-        printf(__VA_ARGS__); \
-        printf("\x1B[0m\n"); \
-    } while(0)
-#define GDEBUG(...) \
-    do { \
-        printf("\x1B[32m%-40s %-26s%4u: ", __FILE__, __func__, __LINE__); \
-        printf(__VA_ARGS__); \
-        printf("\x1B[0m\n"); \
-    } while(0)
-#define BDEBUG(...) \
-    do { \
-        printf("\x1B[1;34m%-40s %-26s%4u: ", __FILE__, __func__, __LINE__); \
-        printf(__VA_ARGS__); \
-        printf("\x1B[0m\n"); \
-    } while(0)
-#define YDEBUG(...) \
-    do { \
-        printf("\x1B[1;33m%-40s %-26s%4u: ", __FILE__, __func__, __LINE__); \
-        printf(__VA_ARGS__); \
-        printf("\x1B[0m\n"); \
-    } while(0)
+#define DEBUG(...)						\
+  do {								\
+    printf("%-40s %-26s%4u: ", __FILE__, __func__, __LINE__);	\
+    printf(__VA_ARGS__);					\
+    printf("\n");						\
+  } while(0)
+#define RDEBUG(...)							\
+  do {									\
+    printf("\x1B[31m%-40s %-26s%4u: ", __FILE__, __func__, __LINE__);	\
+    printf(__VA_ARGS__);						\
+    printf("\x1B[0m\n");						\
+  } while(0)
+#define GDEBUG(...)							\
+  do {									\
+    printf("\x1B[32m%-40s %-26s%4u: ", __FILE__, __func__, __LINE__);	\
+    printf(__VA_ARGS__);						\
+    printf("\x1B[0m\n");						\
+  } while(0)
+#define BDEBUG(...)							\
+  do {									\
+    printf("\x1B[1;34m%-40s %-26s%4u: ", __FILE__, __func__, __LINE__); \
+    printf(__VA_ARGS__);						\
+    printf("\x1B[0m\n");						\
+  } while(0)
+#define YDEBUG(...)							\
+  do {									\
+    printf("\x1B[1;33m%-40s %-26s%4u: ", __FILE__, __func__, __LINE__); \
+    printf(__VA_ARGS__);						\
+    printf("\x1B[0m\n");						\
+  } while(0)
 #else
 #define DEBUG(...) do{}while(0)
 #define RDEBUG(...) do{}while(0)

data/ext/bossan/bossan_ext.c

@@ -6,6 +6,7 @@
 #include "buffer.h"
 #include "client.h"
 
+
 #define ACCEPT_TIMEOUT_SECS 1
 #define SHORT_TIMEOUT_SECS 2
 #define WRITE_TIMEOUT_SECS 5
@@ -16,18 +17,42 @@
 
 #define LIMIT_SIZE 1024 * 512
 
+#define READ_TIMEOUT_SECS 30
+#define READ_BUF_SIZE 1024 * 64
+
 #define CRLF "\r\n"
 #define DELIM ": "
 
-#define MSG_500 ("HTTP/1.0 500 Internal Server Error\r\nContent-Type: text/html\r\nServer:  " SERVER "\r\n\r\n<html><head><title>500 Internal Server Error</title></head><h1>Internal Server Error</h1><p>The server encountered an internal error and was unable to complete your request.  Either the server is overloaded or there is an error in the application.</p></html>\n")
+#define SERVER "bossan/0.4.0"
+
+#define H_MSG_500 "HTTP/1.0 500 Internal Server Error\r\nContent-Type: text/html\r\nServer:  " SERVER "\r\n\r\n"
+
+#define H_MSG_503 "HTTP/1.0 503 Service Unavailable\r\nContent-Type: text/html\r\nServer: " SERVER "\r\n\r\n"
+
+#define H_MSG_400 "HTTP/1.0 400 Bad Request\r\nContent-Type: text/html\r\nServer: " SERVER "\r\n\r\n"
+
+#define H_MSG_408 "HTTP/1.0 408 Request Timeout\r\nContent-Type: text/html\r\nServer: " SERVER "\r\n\r\n"
+
+#define H_MSG_411 "HTTP/1.0 411 Length Required\r\nContent-Type: text/html\r\nServer: " SERVER "\r\n\r\n"
+
+#define H_MSG_413 "HTTP/1.0 413 Request Entity Too Large\r\nContent-Type: text/html\r\nServer: " SERVER "\r\n\r\n"
+
+#define H_MSG_417 "HTTP/1.1 417 Expectation Failed\r\nContent-Type: text/html\r\nServer: " SERVER "\r\n\r\n"
+
+
+#define MSG_500 H_MSG_500 "<html><head><title>500 Internal Server Error</title></head><body><h1>Internal Server Error</h1><p>The server encountered an internal error and was unable to complete your request.  Either the server is overloaded or there is an error in the application.</p></body></html>"
 
-#define MSG_400 ("HTTP/1.0 400 Bad Request\r\nContent-Type: text/html\r\nServer: " SERVER "\r\n\r\n<html><head><title>Bad Request</title></head><body><p>Bad Request.</p></body></html>")
+#define MSG_503 H_MSG_503 "<html><head><title>Service Unavailable</title></head><body><p>Service Unavailable.</p></body></html>"
 
-#define MSG_411 ("HTTP/1.0 411 Length Required\r\nContent-Type: text/html\r\nServer: " SERVER "\r\n\r\n<html><head><title>Length Required</title></head><body><p>Length Required.</p></body></html>")
+#define MSG_400 H_MSG_400 "<html><head><title>Bad Request</title></head><body><p>Bad Request.</p></body></html>"
 
-#define MSG_413 ("HTTP/1.0 413 Request Entity Too Large\r\nContent-Type: text/html\r\nServer: " SERVER "\r\n\r\n<html><head><title>Request Entity Too Large</title></head><body><p>Request Entity Too Large.</p></body></html>")
+#define MSG_408 H_MSG_408 "<html><head><title>Request Timeout</title></head><body><p>Request Timeout.</p></body></html>"
 
-#define SERVER "bossan/0.3.0"
+#define MSG_411 H_MSG_411 "<html><head><title>Length Required</title></head><body><p>Length Required.</p></body></html>"
+
+#define MSG_413 H_MSG_413 "<html><head><title>Request Entity Too Large</title></head><body><p>Request Entity Too Large.</p></body></html>"
+
+#define MSG_417 H_MSG_417 "<html><head><title>Expectation Failed</title></head><body><p>Expectation Failed.</p></body></html>"
 
 VALUE server; // Bossan
 
@@ -62,23 +87,60 @@ static VALUE rb_remote_port;
 static VALUE rack_input;
 static VALUE http_connection;
 
+static VALUE content_type;
+static VALUE content_length;
+
+static VALUE h_content_type;
+static VALUE h_content_length;
+
 static VALUE empty_string;
 
+static VALUE http_10;
+static VALUE http_11;
+
+static VALUE http_delete;
+static VALUE http_get;
+static VALUE http_head;
+static VALUE http_post;
+static VALUE http_put;
+static VALUE http_connect;
+static VALUE http_options;
+static VALUE http_trace;
+static VALUE http_copy;
+static VALUE http_lock;
+static VALUE http_mkcol;
+static VALUE http_move;
+static VALUE http_propfind;
+static VALUE http_proppatch;
+static VALUE http_unlock;
+static VALUE http_report;
+static VALUE http_mkactivity;
+static VALUE http_checkout;
+static VALUE http_merge;
+
 static VALUE http_user_agent;
 static VALUE http_referer;
 
-static VALUE i_keys;
-static VALUE i_call;
-static VALUE i_new;
-static VALUE i_key;
-static VALUE i_each;
-static VALUE i_close;
-static VALUE i_write;
-static VALUE i_seek;
+static VALUE http_expect;
+
+static ID i_keys;
+static ID i_call;
+static ID i_new;
+static ID i_each;
+static ID i_toenum;
+static ID i_close;
+static ID i_write;
+static ID i_seek;
+static ID i_toa;
+static ID i_next;
+
+static VALUE default_path_string;
 
 static const char *server_name = "127.0.0.1";
 static short server_port = 8000;
 
+static int prefix_len = 0;
+
 static int listen_sock;  // listen socket
 
 static char *unix_sock_name = NULL;
@@ -89,8 +151,6 @@ static VALUE rack_app; //rack app
 
 static char *log_path = NULL; //access log path
 static int log_fd = -1; //access log
-/* static char *error_log_path = NULL; //error log path */
-/* static int err_log_fd = -1; //error log */
 
 static int is_keep_alive = 0; //keep alive support
 static int keep_alive_timeout = 5;
@@ -110,15 +170,30 @@ typedef struct {
   uint32_t iov_size;
   uint32_t total;
   uint32_t total_size;
+  uint8_t sended;
+  VALUE temp1; //keep origin pointer
+  VALUE chunk_data; //keep chunk_data origin pointer
 } write_bucket;
 
 
+typedef enum {
+  STATUS_OK = 0,
+  STATUS_SUSPEND,
+  STATUS_ERROR 
+} response_status;
+
+
 static void
 r_callback(picoev_loop* loop, int fd, int events, void* cb_arg);
 
 static void
 w_callback(picoev_loop* loop, int fd, int events, void* cb_arg);
 
+static void
+call_rack_app(client_t *client);
+
+static void
+prepare_call_rack(client_t *client);
 
 int
 open_log_file(const char *path)
@@ -176,43 +251,45 @@ write_log(const char *new_path, int fd, const char *data, size_t len)
 }
 
 
-int 
+static int
 write_access_log(client_t *cli, int log_fd, const char *log_path)
 {
+  request *req = (cli);
+
   char buf[1024*4];
   if(log_fd > 0){
     VALUE obj;
     char *method, *path, *version, *ua, *referer;
         
-    obj = rb_hash_aref(cli->environ, request_method);
+    obj = rb_hash_aref(req->environ, request_method);
     if(obj != Qnil){
       method = StringValuePtr(obj);
     }else{
       method = "-";
     }
                 
-    obj = rb_hash_aref(cli->environ, path_info);
+    obj = rb_hash_aref(req->environ, path_info);
     if(obj != Qnil){
       path = StringValuePtr(obj);
     }else{
       path = "-";
     }
     
-    obj = rb_hash_aref(cli->environ, server_protocol);
+    obj = rb_hash_aref(req->environ, server_protocol);
     if(obj != Qnil){
       version = StringValuePtr(obj);
     }else{
       version = "-";
     }
 
-    obj = rb_hash_aref(cli->environ, http_user_agent);
+    obj = rb_hash_aref(req->environ, http_user_agent);
     if(obj != Qnil){
       ua = StringValuePtr(obj);
     }else{
       ua = "-";
     }
 
-    obj = rb_hash_aref(cli->environ, http_referer);
+    obj = rb_hash_aref(req->environ, http_referer);
     if(obj != Qnil){
       referer = StringValuePtr(obj);
     }else{
@@ -278,38 +355,52 @@ blocking_write(client_t *client, char *data, size_t len)
     default:
       data += (int)r;
       len -= r;
-      client->content_length += r;
+      client->write_bytes += r;
     }
   }
   return 1;
 }
 
 
-void
+static void
 send_error_page(client_t *client)
 {
   shutdown(client->fd, SHUT_RD);
-  if(client->header_done){
+  if(client->header_done || client->response_closed){
     //already sended response data
     //close connection
     return;
   }
-  int status = client->bad_request_code;
-  int r = status < 0 ? status * -1 : status;
-  client->status_code = r;
-  switch(r){
+
+  switch(client->status_code){
   case 400:
     blocking_write(client, MSG_400, sizeof(MSG_400) -1);
+    client->write_bytes -= sizeof(H_MSG_400) -1;
+    break;
+  case 408:
+    blocking_write(client, MSG_408, sizeof(MSG_408) -1);
+    client->write_bytes -= sizeof(H_MSG_408) -1;
     break;
   case 411:
     blocking_write(client, MSG_411, sizeof(MSG_411) -1);
+    client->write_bytes -= sizeof(H_MSG_411) -1;
     break;
   case 413:
     blocking_write(client, MSG_413, sizeof(MSG_413) -1);
+    client->write_bytes -= sizeof(H_MSG_413) -1;
+    break;
+  case 417:
+    blocking_write(client, MSG_417, sizeof(MSG_417) -1);
+    client->write_bytes -= sizeof(H_MSG_417) -1;
+    break;
+  case 503:
+    blocking_write(client, MSG_503, sizeof(MSG_503) -1);
+    client->write_bytes -= sizeof(H_MSG_503) -1;
     break;
   default:
     //Internal Server Error
     blocking_write(client, MSG_500, sizeof(MSG_500) -1);
+    client->write_bytes -= sizeof(H_MSG_500) -1;
     break;
   }
   client->keep_alive = 0;
@@ -318,29 +409,21 @@ send_error_page(client_t *client)
 }
 
 
-static void
-enable_cork(client_t *client)
-{
-  int on = 1, r;
-#ifdef linux
-  r = setsockopt(client->fd, IPPROTO_TCP, TCP_CORK, &on, sizeof(on));
-#elif defined(__APPLE__) || defined(__FreeBSD__)
-  r = setsockopt(client->fd, IPPROTO_TCP, TCP_NOPUSH, &on, sizeof(on));
-#endif
-  assert(r == 0);
-}
-
-
 static write_bucket *
 new_write_bucket(int fd, int cnt)
 {
   write_bucket *bucket;
+  iovec_t *iov;
+
   bucket = ruby_xmalloc(sizeof(write_bucket));
   memset(bucket, 0, sizeof(write_bucket));
 
   bucket->fd = fd;
-  bucket->iov = (iovec_t *)ruby_xmalloc(sizeof(iovec_t) * cnt);
+  iov = (iovec_t *)ruby_xmalloc(sizeof(iovec_t) * cnt);
+  memset(iov, 0, sizeof(iovec_t));
+  bucket->iov = iov;
   bucket->iov_size = cnt;
+  GDEBUG("allocate %p", bucket);
   return bucket;
 }
 
@@ -348,6 +431,7 @@ new_write_bucket(int fd, int cnt)
 static void
 free_write_bucket(write_bucket *bucket)
 {
+  GDEBUG("free %p", bucket);
   ruby_xfree(bucket->iov);
   ruby_xfree(bucket);
 }
@@ -364,6 +448,25 @@ set2bucket(write_bucket *bucket, char *buf, size_t len)
 }
 
 
+static void
+set_chunked_data(write_bucket *bucket, char *lendata, size_t lenlen, char *data, size_t datalen)
+{
+  set2bucket(bucket, lendata, lenlen);
+  set2bucket(bucket, CRLF, 2);
+  set2bucket(bucket, data, datalen);
+  set2bucket(bucket, CRLF, 2);
+}
+
+
+static void
+set_last_chunked_data(write_bucket *bucket)
+{
+  set2bucket(bucket, "0", 1);
+  set2bucket(bucket, CRLF, 2);
+  set2bucket(bucket, CRLF, 2);
+}
+
+
 static void
 add_header(write_bucket *bucket, char *key, size_t keylen, char *val, size_t vallen)
 {
@@ -374,28 +477,50 @@ add_header(write_bucket *bucket, char *key, size_t keylen, char *val, size_t val
 }
 
 
-static int
+#ifdef DEVELOP
+static void
+writev_log(write_bucket *data)
+{
+  int i = 0;
+  char *c;
+  size_t len;
+  for(; i < data->iov_cnt; i++){
+    c = data->iov[i].iov_base;
+    len = data->iov[i].iov_len;
+    printf("%.*s", (int)len, c); 
+  }
+}
+#endif
+
+
+static response_status
 writev_bucket(write_bucket *data)
 {
-  ssize_t w;
+  size_t w;
   int i = 0;
+#ifdef DEVELOP
+  BDEBUG("\nwritev_bucket fd:%d", data->fd);
+  printf("\x1B[34m");
+  writev_log(data);
+  printf("\x1B[0m\n");
+#endif
   w = writev(data->fd, data->iov, data->iov_cnt);
+  BDEBUG("writev fd:%d ret:%d total_size:%d", data->fd, (int)w, data->total);
   if(w == -1){
     //error
     if (errno == EAGAIN || errno == EWOULDBLOCK) { 
       // try again later
-      return 0;
+      return STATUS_SUSPEND;
     }else{
       //ERROR
 
       // TODO:
-      // raise exception from errno
-      /* rb_raise(rb_eIOError); */
-      write_error_log(__FILE__, __LINE__);
-      return -1;
+      /* write_error_log(__FILE__, __LINE__); */
+      return STATUS_ERROR;
     }
   }if(w == 0){
-    return 1;
+    data->sended = 1;
+    return STATUS_OK;
   }else{
     if(data->total > w){
       for(; i < data->iov_cnt;i++){
@@ -409,23 +534,54 @@ writev_bucket(write_bucket *data)
 	  break;
 	}
       }
-      data->total = data->total -w;
+      data->total = data->total - w;
       DEBUG("writev_bucket write %d progeress %d/%d \n", w, data->total, data->total_size);
       //resume
       // again later
       return writev_bucket(data);
     }
   }
-  return 1;
+  data->sended = 1;
+  return STATUS_OK;
 }
 
 
-static int
-write_headers(client_t *client)
+static VALUE
+get_chunk_data(size_t datalen)
 {
-  if(client->header_done){
-    return 1;
+  char lendata[32];
+  int i = 0;
+  i = snprintf(lendata, 32, "%zx", datalen);
+  DEBUG("Transfer-Encoding chunk_size %s", lendata);
+  return rb_str_new(lendata, i);
+}
+
+
+static void
+set_first_body_data(client_t *client, char *data, size_t datalen)
+{
+  write_bucket *bucket = client->bucket;
+  if(data){
+    if(client->chunked_response){
+      char *lendata  = NULL;
+      ssize_t len = 0;
+
+      VALUE chunk_data = get_chunk_data(datalen);
+      //TODO CHECK ERROR
+      lendata = StringValuePtr(chunk_data);
+      len = RSTRING_LEN(chunk_data);
+      set_chunked_data(bucket, lendata, len, data, datalen);
+      bucket->chunk_data = chunk_data;
+    }else{
+      set2bucket(bucket, data, datalen);
+    }
   }
+}
+
+
+static response_status
+write_headers(client_t *client, char *data, size_t datalen)
+{
   write_bucket *bucket;
   uint32_t i = 0, hlen = 0;
 
@@ -435,22 +591,24 @@ write_headers(client_t *client)
   ssize_t namelen;
   char *value = NULL;
   long valuelen;
+  response_status ret;
 
-  if(client->headers){
-    if (TYPE(client->headers) != T_HASH) {
-      return -1;
-    }
-    arr = rb_funcall(client->headers, i_keys, 0);
-    hlen = RARRAY_LEN(arr);
+  DEBUG("header write? %d", client->header_done);
+  if(client->header_done){
+    return STATUS_OK;
   }
+
+  if (TYPE(client->headers) != T_HASH) {
+    return STATUS_ERROR;
+  }
+
+  arr = rb_funcall(client->headers, i_keys, 0);
+  hlen = RARRAY_LEN(arr);
+
   bucket = new_write_bucket(client->fd, ( hlen * 4 * 2) + 32 );
   
   object = client->http_status;
 
-  if(TYPE(object) != T_STRING){
-    return -1;
-  }
-
   if(object){
     value = StringValuePtr(object);
     valuelen = RSTRING_LEN(object);
@@ -458,71 +616,77 @@ write_headers(client_t *client)
     set2bucket(bucket, value, valuelen);
 
     add_header(bucket, "Server", 6,  SERVER, sizeof(SERVER) -1);
-    cache_time_update();
     add_header(bucket, "Date", 4, (char *)http_time, 29);
-    if(client->keep_alive == 1){
-      // Keep-Alive
-      add_header(bucket, "Connection", 10, "Keep-Alive", 10);
-    } else {
-      add_header(bucket, "Connection", 10, "close", 5);
-    }
   }
 
   VALUE object1, object2;
   
   //write header
-  if(client->headers){
-    for(i=0; i < hlen; i++){
-      object1 = rb_ary_entry(arr, i);
-      Check_Type(object1, T_STRING);
-
-      if (TYPE(client->headers)!=T_HASH){
-	goto error;
-      }
-      VALUE tmp = rb_funcall(client->headers, i_key, 1, object1);
-      if (tmp == Qfalse){
-	goto error;
-      }
-      object2 = rb_hash_aref(client->headers, object1);
+  for(i=0; i < hlen; i++){
+    object1 = rb_ary_entry(arr, i);
+    /* Check_Type(object1, T_STRING); */
 
-      Check_Type(object2, T_STRING);
+    object2 = rb_hash_aref(client->headers, object1);
+    /* Check_Type(object2, T_STRING); */
       
-      name = StringValuePtr(object1);
-      namelen = RSTRING_LEN(object1);
+    name = StringValuePtr(object1);
+    namelen = RSTRING_LEN(object1);
   
-      value = StringValuePtr(object2);
-      valuelen = RSTRING_LEN(object2);
+    value = StringValuePtr(object2);
+    valuelen = RSTRING_LEN(object2);
 
-      if (strchr(name, '\n') != 0 || strchr(value, '\n') != 0) {
-	rb_raise(rb_eArgError, "embedded newline in response header and value");
-      }
+    if (strchr(name, ':') != 0) {
+      goto error;
+    }
+
+    if (strchr(name, '\n') != 0 || strchr(value, '\n') != 0) {
+      goto error;
+    }
       
-      if (!strcasecmp(name, "Server") || !strcasecmp(name, "Date")) {
- 	continue;
-      }
+    if (!strcasecmp(name, "Server") || !strcasecmp(name, "Date")) {
+      continue;
+    }
       
-      if (!strcasecmp(name, "Content-Length")) {
-	char *v = value;
-	long l = 0;
+    if (client->content_length_set != 1 && !strcasecmp(name, "Content-Length")) {
+      char *v = value;
+      long l = 0;
 	
-	errno = 0;
-	l = strtol(v, &v, 10);
-	if (*v || errno == ERANGE || l < 0) {
-	  rb_raise(rb_eArgError, "invalid content length");
-	  goto error;
-	}
-	client->content_length_set = 1;
-	client->content_length = l;
+      errno = 0;
+      l = strtol(v, &v, 10);
+      if (*v || errno == ERANGE || l < 0) {
+	goto error;
       }
-    add_header(bucket, name, namelen, value, valuelen);
+      client->content_length_set = 1;
+      client->content_length = l;
     }
+    add_header(bucket, name, namelen, value, valuelen);
+  }
+
+  // check content_length_set
+  if(data && !client->content_length_set && client->http_parser->http_minor == 1){
+    //Transfer-Encoding chunked
+    add_header(bucket, "Transfer-Encoding", 17, "chunked", 7);
+    client->chunked_response = 1;
+  }
+
+  if(client->keep_alive == 1){
+    // Keep-Alive
+    add_header(bucket, "Connection", 10, "Keep-Alive", 10);
+  } else {
+    add_header(bucket, "Connection", 10, "close", 5);
   }
   set2bucket(bucket, CRLF, 2);
 
+  // write_body
   client->bucket = bucket;
-  int ret = writev_bucket(bucket);
-  if(ret != 0){
+  set_first_body_data(client, data, datalen);
+
+  ret = writev_bucket(bucket);
+  if(ret != STATUS_SUSPEND){
     client->header_done = 1;
+    if(ret == STATUS_OK && data){
+      client->write_bytes += datalen;
+    }
     // clear
     free_write_bucket(bucket);
     client->bucket = NULL;
@@ -534,9 +698,9 @@ write_headers(client_t *client)
     free_write_bucket(bucket);
     client->bucket = NULL;
   }
-  return -1;
+  return STATUS_ERROR;
 }
-  
+
 
 static void
 close_response(client_t *client)
@@ -548,21 +712,23 @@ close_response(client_t *client)
 
 
 static VALUE
-collect_body(VALUE i, VALUE str, int argc, VALUE *argv)
+rb_body_iterator(VALUE iterator)
+{
+  return rb_funcall(iterator, i_next, 0);
+}
+
+
+static VALUE
+ret_qnil(void)
 {
-  if(argc < 1) {
-    return Qnil;
-  }
-  rb_str_concat(str, argv[0]);
   return Qnil;
 }
 
 
-static int
+static response_status
 processs_write(client_t *client)
 {
   VALUE iterator;
-  VALUE v_body;
   VALUE item;
   char *buf;
   size_t buflen;
@@ -570,112 +736,132 @@ processs_write(client_t *client)
   int ret;
 
   // body
+  DEBUG("process_write start");
   iterator = client->response_iter;
 
-  if(iterator != Qnil){
-    if (TYPE(iterator) != T_ARRAY || RARRAY_LEN(iterator) != 3){
-      return -1;
-    }
+  while ( (item = rb_rescue(rb_body_iterator, iterator, ret_qnil, NULL)) != Qnil ) {
 
-    v_body = rb_ary_entry(iterator, 2);
+    buf = StringValuePtr(item);
+    buflen = RSTRING_LEN(item);
 
-    if(!rb_respond_to(v_body, i_each)){
-      return -1;
-    }
+    //write
+    if(client->chunked_response){
+      bucket = new_write_bucket(client->fd, 4);
+      if(bucket == NULL){
+	return STATUS_ERROR;
+      }
+      char *lendata = NULL;
+      ssize_t len = 0;
 
-    VALUE v_body_str = rb_str_new2("");
-    rb_block_call(v_body, i_each, 0, NULL, collect_body, v_body_str);
-    if(rb_respond_to(v_body, i_close)) {
-      rb_funcall(v_body, i_close, 0);
-    }
+      VALUE chunk_data = get_chunk_data(buflen);
+      //TODO CHECK ERROR
+      lendata = StringValuePtr(chunk_data);
+      len = RSTRING_LEN(chunk_data);
 
-    buf = StringValuePtr(v_body_str);
-    buflen = RSTRING_LEN(v_body_str);
+      set_chunked_data(bucket, lendata, len, buf, buflen);
+      bucket->chunk_data = chunk_data;
+    } else {
+      bucket = new_write_bucket(client->fd, 1);
+      if(bucket == NULL){
+	return STATUS_ERROR;
+      }
+      set2bucket(bucket, buf, buflen);
+    }
+    bucket->temp1 = item;
 
-    bucket = new_write_bucket(client->fd, 1);
-    set2bucket(bucket, buf, buflen);
     ret = writev_bucket(bucket);
-    if(ret <= 0){
+    if(ret != STATUS_OK){
+      client->bucket = bucket;
       return ret;
     }
+
+    free_write_bucket(bucket);
     //mark
     client->write_bytes += buflen;
     //check write_bytes/content_length
     if(client->content_length_set){
       if(client->content_length <= client->write_bytes){
 	// all done
-	/* break; */
+	break;
       }
     }
+
+    if(client->chunked_response){
+      DEBUG("write last chunk");
+      //last packet
+      bucket = new_write_bucket(client->fd, 3);
+      if(bucket == NULL){
+	return STATUS_ERROR;
+      }
+      set_last_chunked_data(bucket);
+      writev_bucket(bucket);
+      free_write_bucket(bucket);
+    }
     close_response(client);
   }
-  return 1;
+  return STATUS_OK;
 }
 
 
-int
+static response_status
 process_body(client_t *client)
 {
-  int ret;
+  response_status ret;
   write_bucket *bucket;
   if(client->bucket){
     bucket = (write_bucket *)client->bucket;
     //retry send
     ret = writev_bucket(bucket);
     
-    if(ret != 0){
+    if(ret == STATUS_OK){
       client->write_bytes += bucket->total_size;
       //free
       free_write_bucket(bucket);
       client->bucket = NULL;
+    }else if(ret == STATUS_ERROR){
+      free_write_bucket(bucket);
+      client->bucket = NULL;
+      return ret;
     }else{
-      return 0;
+      return ret;
     }
   }
-  ret = processs_write(client);
-  return ret;
+  return processs_write(client);
 }
 
 
-static int
+static response_status
 start_response_write(client_t *client)
 {
-  VALUE iterator;
-  VALUE dict;
   VALUE item;
   char *buf;
   ssize_t buflen;
     
-  iterator = client->response;
-  client->response_iter = iterator;
-
-  if (TYPE(iterator) != T_ARRAY){
-    return -1;
-  }
-  assert(3 == RARRAY_LEN(iterator));
+  item = rb_funcall(client->response_iter, i_next, 0);
+  /* Check_Type(item, T_STRING); */
+  DEBUG("client %p :fd %d", client, client->fd);
 
-  dict = rb_ary_entry(iterator, 1);
+  //write string only
+  buf = StringValuePtr(item);
+  buflen = RSTRING_LEN(item);
 
-  if (TYPE(dict) != T_HASH){
-    return -1;
-  }
-
-  /* DEBUG("start_response_write buflen %d \n", buflen); */
-  return write_headers(client);
+  /* DEBUG("status_code %d body:%.*s", client->status_code, (int)buflen, buf); */
+  return write_headers(client, buf, buflen);
 }
 
 
-int
+response_status
 response_start(client_t *client)
 {
-  int ret;
-  enable_cork(client);
+  response_status ret;
+
   if(client->status_code == 304){
-    return write_headers(client);
+    return write_headers(client, NULL, 0);
   }
   ret = start_response_write(client);
-  DEBUG("start_response_write ret = %d \n", ret);
-  if(ret > 0){
+  DEBUG("start_response_write ret = %d :fd = %d\n", ret, client->fd);
+
+  if(ret == STATUS_OK){
     // sended header
     ret = processs_write(client);
   }
@@ -704,259 +890,342 @@ key_upper(char *s, const char *key, size_t len)
 
 
 static int
-write_body2mem(client_t *client, const char *buffer, size_t buffer_len)
+write_body2mem(request *req, const char *buffer, size_t buf_len)
 {
-  VALUE obj;
-
-  rb_funcall((VALUE)client->body, i_write, 1, rb_str_new(buffer, buffer_len));
-  client->body_readed += buffer_len;
-  DEBUG("write_body2mem %d bytes \n", buffer_len);
-  return client->body_readed;
+  rb_funcall((VALUE)req->body, i_write, 1, rb_str_new(buffer, buf_len));
+  req->body_readed += buf_len;
+  DEBUG("write_body2mem %d bytes \n", buf_len);
+  return req->body_readed;
 }
 
 
 static int
-write_body(client_t *cli, const char *buffer, size_t buffer_len)
+write_body(request *req, const char *buffer, size_t buffer_len)
 {
-  return write_body2mem(cli, buffer, buffer_len);
+  return write_body2mem(req, buffer, buffer_len);
 }
 
 
-typedef enum{
-  CONTENT_TYPE,
-  CONTENT_LENGTH,
-  OTHER
-} rack_header_type;
+static client_t *
+get_client(http_parser *p)
+{
+  return (client_t *)p->data;
+}
 
 
-static  rack_header_type
-check_header_type(const char *buf)
+static request *
+get_current_request(http_parser *p)
 {
-  if(*buf++ != 'C'){
-    return OTHER;
-  }
-  if(*buf++ != 'O'){
-    return OTHER;
-  }
-  if(*buf++ != 'N'){
-    return OTHER;
-  }
-  if(*buf++ != 'T'){
-    return OTHER;
-  }
-  if(*buf++ != 'E'){
-    return OTHER;
-  }
-  if(*buf++ != 'N'){
-    return OTHER;
-  }
-  if(*buf++ != 'T'){
-    return OTHER;
-  }
-  if(*buf++ != '_'){
-    return OTHER;
+  client_t *client = (client_t *)p->data;
+  return client->current_req;
+}
+
+
+static VALUE
+new_environ(client_t *client)
+{
+  VALUE object, environ;
+  char r_port[7];
+
+  environ = rb_hash_new();
+
+  rb_hash_aset(environ, version_key, version_val);
+  rb_hash_aset(environ, scheme_key, scheme_val);
+  rb_hash_aset(environ, errors_key, errors_val);
+  rb_hash_aset(environ, multithread_key, multithread_val);
+  rb_hash_aset(environ, multiprocess_key, multiprocess_val);
+  rb_hash_aset(environ, run_once_key, run_once_val);
+  rb_hash_aset(environ, script_key, empty_string);
+  rb_hash_aset(environ, server_name_key, server_name_val);
+  rb_hash_aset(environ, server_port_key, server_port_val);
+
+  object = rb_str_new2(client->remote_addr);
+  rb_hash_aset(environ, rb_remote_addr, object);
+
+  sprintf(r_port, "%d", client->remote_port);
+  object = rb_str_new2(r_port);
+  rb_hash_aset(environ, rb_remote_port, object);
+  return environ;
+}
+
+
+static int
+hex2int(int i)
+{
+  i = toupper(i);
+  i = i - '0';
+  if(i > 9){
+    i = i - 'A' + '9' + 1;
   }
-  char c = *buf++;
-  if(c == 'L'){
-    return CONTENT_LENGTH;
-  }else if(c == 'T'){
-    return CONTENT_TYPE;
+  return i;
+}
+
+
+static int
+urldecode(char *buf, int len)
+{
+  int c, c1;
+  char *s0, *t;
+  t = s0 = buf;
+  while(len >0){
+    c = *buf++;
+    if(c == '%' && len > 2){
+      c = *buf++;
+      c1 = c;
+      c = *buf++;
+      c = hex2int(c1) * 16 + hex2int(c);
+      len -= 2;
+    }
+    *t++ = c;
+    len--;
   }
-  return OTHER;
+  *t = 0;
+  return t - s0;
 }
 
 
-static client_t *
-get_client(http_parser *p)
+static VALUE
+concat_string(VALUE o, const char *buf, size_t len)
 {
-  return (client_t *)p->data;
+  VALUE ret;
+  size_t l;
+  char *dest, *origin;
+    
+  l = RSTRING_LEN(o);
+
+  ret = rb_str_new((char*)0, l + len);
+  if(ret == NULL){
+    return ret;
+  }
+  dest = StringValuePtr(ret);
+  origin = StringValuePtr(o);
+  memcpy(dest, origin, l);
+  memcpy(dest + l, buf, len);
+  return ret;
 }
 
 
-int
-message_begin_cb(http_parser *p)
+static int
+replace_env_key(VALUE dict, VALUE old_key, VALUE new_key)
 {
-  return 0;
+  int ret = 1;
+
+  VALUE value = rb_hash_aref(dict, old_key);
+  if(value != Qnil) {
+    rb_hash_aset(dict, old_key, Qnil);
+    ret = rb_hash_aset(dict, new_key, value);
+  }
+  return ret;
 }
 
 
-int
-header_field_cb (http_parser *p, const char *buf, size_t len, char partial)
+static int
+set_query(VALUE env, char *buf, int len)
 {
-  uint32_t i;
-  header *h;
-  client_t *client = get_client(p);
-  request *req = client->req;
-  char temp[len];
-  
-  buffer_result ret = MEMORY_ERROR;
-  if (req->last_header_element != FIELD){
-    if(LIMIT_REQUEST_FIELDS <= req->num_headers){
-      client->bad_request_code = 400;
-      return -1;
+  int c, slen = 0;
+  char *s0;
+  VALUE obj;
+
+  s0 = buf;
+  while(len > 0){
+    c = *buf++;
+    if(c == '#'){
+      slen++;
+      break;
     }
-    req->num_headers++;
+    len--;
+    slen++;
   }
-  i = req->num_headers;
-  h = req->headers[i];
-  
-  key_upper(temp, buf, len);
-  if(h){
-    ret = write2buf(h->field, temp, len);
-  }else{
-    req->headers[i] = h = new_header(128, LIMIT_REQUEST_FIELD_SIZE, 1024, LIMIT_REQUEST_FIELD_SIZE);
-    rack_header_type type = check_header_type(temp);
-    if(type == OTHER){
-      ret = write2buf(h->field, "HTTP_", 5);
+
+  if(slen > 1){
+    obj = rb_str_new(s0, slen-1);
+    rb_hash_aset(env, query_string, obj);
+  }
+  return 1; 
+}
+
+
+static int
+set_path(VALUE env, char *buf, int len)
+{
+  int c, c1, slen;
+  char *s0, *t;
+  VALUE obj;
+
+  t = s0 = buf;
+  while(len > 0){
+    c = *buf++;
+    if(c == '%' && len > 2){
+      c = *buf++;
+      c1 = c;
+      c = *buf++;
+      c = hex2int(c1) * 16 + hex2int(c);
+      len -= 2;
+    }else if(c == '?'){
+      //stop
+      if(set_query(env, buf, len) == -1){
+	//Error
+	return -1;
+      }
+      break;
+    }else if(c == '#'){
+      //stop 
+      //ignore fragment
+      break;
     }
-    ret = write2buf(h->field, temp, len);
-    //printf("%s \n", getString(h->field));
+    *t++ = c;
+    len--;
   }
-  switch(ret){
-  case MEMORY_ERROR:
-    client->bad_request_code = 500;
-    return -1;
-  case LIMIT_OVER:
-    client->bad_request_code = 400;
-    return -1;
-  default:
-    break;
+  slen = t - s0;
+  slen = urldecode(s0, slen);
+
+  obj = rb_str_new(s0, slen);
+
+  rb_hash_aset(env, path_info, obj);
+
+  if (rb_hash_aref(env, query_string) == Qnil) {
+    rb_hash_aset(env, query_string, empty_string);
   }
-  req->last_header_element = FIELD;
-  return 0;
+  return slen;
 }
 
 
-int
-header_value_cb (http_parser *p, const char *buf, size_t len, char partial)
+static VALUE
+get_http_header_key(const char *s, int len)
 {
-  uint32_t i;
-  header *h;
-  client_t *client = get_client(p);
-  request *req = client->req;
-    
-  buffer_result ret = MEMORY_ERROR;
-  i = req->num_headers;
-  h = req->headers[i];
-  
-  if(h){
-    ret = write2buf(h->value, buf, len);
-  }
-  switch(ret){
-  case MEMORY_ERROR:
-    client->bad_request_code = 500;
-    return -1;
-  case LIMIT_OVER:
-    client->bad_request_code = 400;
-    return -1;
-  default:
-    break;
+  VALUE obj;
+  char *dest;
+  char c;
+
+  obj = rb_str_new("", len + prefix_len);
+  dest = (char*)StringValuePtr(obj);
+
+  *dest++ = 'H';
+  *dest++ = 'T';
+  *dest++ = 'T';
+  *dest++ = 'P';
+  *dest++ = '_';
+
+  while(len--) {
+    c = *s++;
+    if(c == '-'){
+      *dest++ = '_';
+    }else if(c >= 'a' && c <= 'z'){
+      *dest++ = c - ('a'-'A');
+    }else{
+      *dest++ = c;
+    }
   }
-  req->last_header_element = VAL;
-  return 0;
+  return obj;
 }
 
 
-int
-request_path_cb (http_parser *p, const char *buf, size_t len, char partial)
+static int
+message_begin_cb(http_parser *p)
 {
+  request *req;
+
+  DEBUG("message_begin_cb");
+    
   client_t *client = get_client(p);
-  request *req = client->req;
-  buffer_result ret = MEMORY_ERROR;
-  
-  if(req->path){
-    ret = write2buf(req->path, buf, len);
-  }else{
-    req->path = new_buffer(1024, LIMIT_PATH);
-    ret = write2buf(req->path, buf, len);
-  }
-  switch(ret){
-  case MEMORY_ERROR:
-    client->bad_request_code = 500;
-    return -1;
-  case LIMIT_OVER:
-    client->bad_request_code = 400;
-    return -1;
-  default:
-    break;
-  }
+
+  req = new_request();
+  req->start_msec = current_msec;
+  client->current_req = req;
+  client->complete = 0;
+  req->environ = new_environ(client);
+  rb_gc_register_address(&req->environ);
+  push_request(client->request_queue, client->current_req);
   return 0;
 }
 
 
-int
-request_uri_cb (http_parser *p, const char *buf, size_t len, char partial)
+static int
+header_field_cb(http_parser *p, const char *buf, size_t len)
 {
-  client_t *client = get_client(p);
-  request *req = client->req;
-  buffer_result ret = MEMORY_ERROR;
-    
-  if(req->uri){
-    ret = write2buf(req->uri, buf, len);
+  VALUE env, obj;
+  request *req = get_current_request(p);
+  
+  if (req->last_header_element != FIELD){
+    env = req->environ;
+    if(LIMIT_REQUEST_FIELDS <= req->num_headers){
+      req->bad_request_code = 400;
+      return -1;
+    }
+    rb_hash_aset(env, req->field, req->value);
+    req->field = NULL;
+    req->value = NULL;
+    req->num_headers++;
+  }
+  
+  if(likely(req->field == NULL)){
+    obj = get_http_header_key(buf, len);
   }else{
-    req->uri = new_buffer(1024, LIMIT_URI);
-    ret = write2buf(req->uri, buf, len);
+    char temp[len];
+    key_upper(temp, buf, len);
+    obj = concat_string(req->field, temp, len);
   }
-  switch(ret){
-  case MEMORY_ERROR:
-    client->bad_request_code = 500;
+
+  if(unlikely(obj == NULL)){
+    req->bad_request_code = 500;
     return -1;
-  case LIMIT_OVER:
-    client->bad_request_code = 400;
+  }
+
+  if(unlikely(RSTRING_LEN(obj) > LIMIT_REQUEST_FIELD_SIZE)){
+    req->bad_request_code = 400;
     return -1;
-  default:
-    break;
   }
+
+  req->field = obj;
+  req->last_header_element = FIELD;
   return 0;
 }
 
-
-int
-query_string_cb (http_parser *p, const char *buf, size_t len, char partial)
-{
-  client_t *client = get_client(p);
-  request *req = client->req;
-  buffer_result ret = MEMORY_ERROR;
-
-  if(req->query_string){
-    ret = write2buf(req->query_string, buf, len);
+
+static int
+header_value_cb(http_parser *p, const char *buf, size_t len)
+{
+  request *req = get_current_request(p);
+  VALUE obj;
+    
+  if(likely(req->value == NULL)){
+    obj = rb_str_new(buf, len);
   }else{
-    req->query_string = new_buffer(1024*2, LIMIT_QUERY_STRING);
-    ret = write2buf(req->query_string, buf, len);
+    obj = concat_string(req->value, buf, len);
   }
-  switch(ret){
-  case MEMORY_ERROR:
-    client->bad_request_code = 500;
-    return -1;
-  case LIMIT_OVER:
-    client->bad_request_code = 400;
+  
+  if(unlikely(obj == NULL)){
+    req->bad_request_code = 500;
+    return -1; 
+  }
+  if(unlikely(RSTRING_LEN(obj) > LIMIT_REQUEST_FIELD_SIZE)){
+    req->bad_request_code = 400;
     return -1;
-  default:
-    break;
   }
+  req->value = obj;
+  req->last_header_element = VAL;
   return 0;
 }
 
 
-int
-fragment_cb (http_parser *p, const char *buf, size_t len, char partial)
+static int
+request_uri_cb(http_parser *p, const char *buf, size_t len)
 {
-  client_t *client = get_client(p);
-  request *req = client->req;
+  request *req = get_current_request(p);
   buffer_result ret = MEMORY_ERROR;
-  
-  if(req->fragment){
-    ret = write2buf(req->fragment, buf, len);
+    
+  if(req->path){
+    ret = write2buf(req->path, buf, len);
   }else{
-    req->fragment = new_buffer(1024, LIMIT_FRAGMENT);
-    ret = write2buf(req->fragment, buf, len);
+    req->path = new_buffer(1024, LIMIT_URI);
+    ret = write2buf(req->path, buf, len);
   }
   switch(ret){
   case MEMORY_ERROR:
-    client->bad_request_code = 500;
+    req->bad_request_code = 500;
     return -1;
   case LIMIT_OVER:
-    client->bad_request_code = 400;
+    req->bad_request_code = 400;
     return -1;
   default:
     break;
@@ -965,27 +1234,28 @@ fragment_cb (http_parser *p, const char *buf, size_t len, char partial)
 }
 
 
-int
-body_cb (http_parser *p, const char *buf, size_t len, char partial)
+static int
+body_cb(http_parser *p, const char *buf, size_t len)
 {
-  client_t *client = get_client(p);
-  if(max_content_length <= client->body_readed + len){
-    client->bad_request_code = 413;
+  request *req = get_current_request(p);
+
+  if(max_content_length <= req->body_readed + len){
+    req->bad_request_code = 413;
     return -1;
   }
-  if(client->body_type == BODY_TYPE_NONE){
-    if(client->body_length == 0){
+  if(req->body_type == BODY_TYPE_NONE){
+    if(req->body_length == 0){
       //Length Required
-      client->bad_request_code = 411;
+      req->bad_request_code = 411;
       return -1;
     }
     //default memory stream
-    DEBUG("client->body_length %d \n", client->body_length);
-    client->body = rb_funcall(StringIO, i_new, 1, rb_str_new2(""));
-    client->body_type = BODY_TYPE_BUFFER;
+    DEBUG("client->body_length %d \n", req->body_length);
+    req->body = rb_funcall(StringIO, i_new, 1, rb_str_new2(""));
+    req->body_type = BODY_TYPE_BUFFER;
     DEBUG("BODY_TYPE_BUFFER \n");
   }
-  write_body(client, buf, len);
+  write_body(req, buf, len);
   return 0;
 }
 
@@ -993,129 +1263,134 @@ body_cb (http_parser *p, const char *buf, size_t len, char partial)
 int
 headers_complete_cb(http_parser *p)
 {
-  VALUE obj, key;
+  VALUE obj = NULL;
   client_t *client = get_client(p);
-  request *req = client->req;
-  VALUE env = client->environ;
-  uint32_t i = 0;
-  header *h;
-  
-  if(max_content_length < p->content_length){
-    client->bad_request_code = 413;
-    return -1;
+  request *req = client->current_req;
+  VALUE env = req->environ;
+  int ret;
+  uint64_t content_length = 0;
+
+  DEBUG("should keep alive %d", http_should_keep_alive(p));
+  client->keep_alive = http_should_keep_alive(p);
+
+  if(p->content_length != ULLONG_MAX){
+    content_length = p->content_length;
+    if(max_content_length < p->content_length){
+      RDEBUG("max_content_length over %d/%d", (int)content_length, (int)max_content_length);
+      DEBUG("set request code %d", 413);
+      req->bad_request_code = 413;
+      return -1;
+    }
   }
 
   if (p->http_minor == 1) {
-    obj = rb_str_new2("HTTP/1.1");
+    obj = http_11;
   } else {
-    obj = rb_str_new2("HTTP/1.0");
-  }    
+    obj = http_10;
+  }
   rb_hash_aset(env, server_protocol, obj);
-    
-  if(req->path){
-    obj = getRbString(req->path);
-    rb_hash_aset(env, path_info, obj);
-    req->path = NULL;
+
+  if(likely(req->path)){
+    ret = set_path(env, req->path->buf, req->path->len);
+    free_buffer(req->path);
+    if(unlikely(ret == -1)){
+      //TODO Error
+      return -1;
+    }
+  }else{
+    rb_hash_aset(env, path_info, default_path_string);
   }
-  if(req->uri){
-    obj = getRbString(req->uri);
-    rb_hash_aset(env, request_uri, obj);
-    req->uri = NULL;
+  req->path = NULL;
+
+  //Last header
+  if(likely(req->field && req->value)){
+    rb_hash_aset(env, req->field, req->value);
+
+    req->field = NULL;
+    req->value = NULL;
   }
-  if(req->query_string){
-    obj = getRbString(req->query_string);
-    rb_hash_aset(env, query_string, obj);
-    req->query_string = NULL;
-  }
-  if(req->fragment){
-    obj = getRbString(req->fragment);
-    rb_hash_aset(env, http_fragment, obj);
-    req->fragment = NULL;
-  }
-  for(i = 0; i < req->num_headers+1; i++){
-    h = req->headers[i];
-    if(h){
-      key = getRbString(h->field);
-      obj = getRbString(h->value);
-      rb_hash_aset(env, key, obj);
-      free_header(h);
-      req->headers[i] = NULL;
-    }
+
+  ret = replace_env_key(env, h_content_type, content_type);
+  if(unlikely(ret == -1)){
+    return -1;
+  }
+  ret = replace_env_key(env, h_content_length, content_length);
+  if(unlikely(ret == -1)){
+    return -1;
   }
      
   switch(p->method){
   case HTTP_DELETE:
-    obj = rb_str_new("DELETE", 6);
+    obj = http_delete;
     break;
   case HTTP_GET:
-    obj = rb_str_new("GET", 3);
+    obj = http_get;
     break;
   case HTTP_HEAD:
-    obj = rb_str_new("HEAD", 4);
+    obj = http_head;
     break;
   case HTTP_POST:
-    obj = rb_str_new("POST", 4);
+    obj = http_post;
     break;
   case HTTP_PUT:
-    obj = rb_str_new("PUT", 3);
+    obj = http_put;
     break;
   case HTTP_CONNECT:
-    obj = rb_str_new("CONNECT", 7);
+    obj = http_connect;
     break;
   case HTTP_OPTIONS:
-    obj = rb_str_new("OPTIONS", 7);
+    obj = http_options;
     break;
   case  HTTP_TRACE:
-    obj = rb_str_new("TRACE", 5);
+    obj = http_trace;
     break;
   case HTTP_COPY:
-    obj = rb_str_new("COPY", 4);
+    obj = http_copy;
     break;
   case HTTP_LOCK:
-    obj = rb_str_new("LOCK", 4);
+    obj = http_lock;
     break;
   case HTTP_MKCOL:
-    obj = rb_str_new("MKCOL", 5);
+    obj = http_mkcol;
     break;
   case HTTP_MOVE:
-    obj = rb_str_new("MOVE", 4);
+    obj = http_move;
     break;
   case HTTP_PROPFIND:
-    obj = rb_str_new("PROPFIND", 8);
+    obj = http_propfind;
     break;
   case HTTP_PROPPATCH:
-    obj = rb_str_new("PROPPATCH", 9);
+    obj = http_proppatch;
     break;
   case HTTP_UNLOCK:
-    obj = rb_str_new("UNLOCK", 6);
+    obj = http_unlock;
     break;
   case HTTP_REPORT:
-    obj = rb_str_new("REPORT", 6);
+    obj = http_report;
     break;
   case HTTP_MKACTIVITY:
-    obj = rb_str_new("MKACTIVITY", 10);
+    obj = http_mkactivity;
     break;
   case HTTP_CHECKOUT:
-    obj = rb_str_new("CHECKOUT", 8);
+    obj = http_checkout;
     break;
   case HTTP_MERGE:
-    obj = rb_str_new("MERGE", 5);
+    obj = http_merge;
     break;
   default:
-    obj = rb_str_new("GET", 3);
+    obj = http_get;
     break;
   }
     
   rb_hash_aset(env, request_method, obj);
+  req->body_length = p->content_length;
 
-  ruby_xfree(req);
-  client->req = NULL;
-  client->body_length = p->content_length;
+  DEBUG("fin headers_complete_cb");
   return 0;
 }
 
 
-int
+static int
 message_complete_cb (http_parser *p)
 {
   client_t *client = get_client(p);
@@ -1128,73 +1403,46 @@ static http_parser_settings settings =
   {.on_message_begin = message_begin_cb
   ,.on_header_field = header_field_cb
   ,.on_header_value = header_value_cb
-  ,.on_path = request_path_cb
   ,.on_url = request_uri_cb
-  ,.on_fragment = fragment_cb
-  ,.on_query_string = query_string_cb
   ,.on_body = body_cb
   ,.on_headers_complete = headers_complete_cb
   ,.on_message_complete = message_complete_cb
   };
 
 
-int
+static int
 init_parser(client_t *cli, const char *name, const short port)
 {
-  VALUE object;
-  char r_port[7];
-
-  cli->http = (http_parser*)ruby_xmalloc(sizeof(http_parser));
-  memset(cli->http, 0, sizeof(http_parser));
-    
-  cli->environ = rb_hash_new();
-
-  rb_hash_aset(cli->environ, version_key, version_val);
-  rb_hash_aset(cli->environ, scheme_key, scheme_val);
-  rb_hash_aset(cli->environ, errors_key, errors_val);
-  rb_hash_aset(cli->environ, multithread_key, multithread_val);
-  rb_hash_aset(cli->environ, multiprocess_key, multiprocess_val);
-  rb_hash_aset(cli->environ, run_once_key, run_once_val);
-  rb_hash_aset(cli->environ, script_key, script_val);
-  rb_hash_aset(cli->environ, server_name_key, server_name_val);
-  rb_hash_aset(cli->environ, server_port_key, server_port_val);
-
-  // query_string
-  rb_hash_aset(cli->environ, query_string, empty_string);
-
-  object = rb_str_new2(cli->remote_addr);
-  rb_hash_aset(cli->environ, rb_remote_addr, object);
-
-  sprintf(r_port, "%d", cli->remote_port);
-  object = rb_str_new2(r_port);
-  rb_hash_aset(cli->environ, rb_remote_port, object);
-
-  http_parser_init(cli->http, HTTP_REQUEST);
-  cli->http->data = cli;
+  cli->http_parser = (http_parser*)ruby_xmalloc(sizeof(http_parser));
+  memset(cli->http_parser, 0, sizeof(http_parser));
+  http_parser_init(cli->http_parser, HTTP_REQUEST);
+  cli->http_parser->data = cli;
 
   return 0;
 }
 
 
-size_t
+static size_t
 execute_parse(client_t *cli, const char *data, size_t len)
 {
-  return http_parser_execute(cli->http, &settings, data, len);
+  return http_parser_execute(cli->http_parser, &settings, data, len);
 }
 
 
-int
+static int
 parser_finish(client_t *cli)
 {
   return cli->complete;
 }
 
 
-void
+static void
 setup_static_env(char *name, int port)
 {
   char vport[7];
 
+  prefix_len = strlen("HTTP_");
+
   version_val = rb_obj_freeze(rb_ary_new3(2, INT2FIX(1), INT2FIX(1)));
   version_key = rb_obj_freeze(rb_str_new2("rack.version"));
   
@@ -1234,8 +1482,39 @@ setup_static_env(char *name, int port)
   rack_input = rb_obj_freeze(rb_str_new2("rack.input"));
   http_connection = rb_obj_freeze(rb_str_new2("HTTP_CONNECTION"));
 
+  content_type = rb_obj_freeze(rb_str_new2("CONTENT_TYPE"));
+  content_length = rb_obj_freeze(rb_str_new2("CONTENT_LENGTH"));
+
+  h_content_type = rb_obj_freeze(rb_str_new2("HTTP_CONTENT_TYPE"));
+  h_content_length = rb_obj_freeze(rb_str_new2("HTTP_CONTENT_LENGTH"));
+
+  http_10 = rb_obj_freeze(rb_str_new2("HTTP/1.0"));
+  http_11 = rb_obj_freeze(rb_str_new2("HTTP/1.1"));
+
+  http_delete = rb_obj_freeze(rb_str_new2("DELETE"));
+  http_get = rb_obj_freeze(rb_str_new2("GET"));
+  http_head = rb_obj_freeze(rb_str_new2("HEAD"));
+  http_post = rb_obj_freeze(rb_str_new2("POST"));
+  http_put = rb_obj_freeze(rb_str_new2("PUT"));
+  http_connect = rb_obj_freeze(rb_str_new2("CONNECT"));
+  http_options = rb_obj_freeze(rb_str_new2("OPTIONS"));
+  http_trace = rb_obj_freeze(rb_str_new2("TRACE"));
+  http_copy = rb_obj_freeze(rb_str_new2("COPY"));
+  http_lock = rb_obj_freeze(rb_str_new2("LOCK"));
+  http_mkcol = rb_obj_freeze(rb_str_new2("MKCOL"));
+  http_move = rb_obj_freeze(rb_str_new2("MOVE"));
+  http_propfind= rb_obj_freeze(rb_str_new2("PROPFIND"));
+  http_proppatch = rb_obj_freeze(rb_str_new2("PROPPATCH"));
+  http_unlock = rb_obj_freeze(rb_str_new2("UNLOCK"));
+  http_report = rb_obj_freeze(rb_str_new2("REPORT"));
+  http_mkactivity = rb_obj_freeze(rb_str_new2("MKACTIVITY"));
+  http_checkout = rb_obj_freeze(rb_str_new2("CHECKOUT"));
+  http_merge = rb_obj_freeze(rb_str_new2("MERGE"));
+
   http_user_agent = rb_obj_freeze(rb_str_new2("HTTP_USER_AGENT"));
   http_referer = rb_obj_freeze(rb_str_new2("HTTP_REFERER"));
+
+  http_expect = rb_obj_freeze(rb_str_new2("HTTP_EXPECT"));
 }
 
 
@@ -1250,10 +1529,10 @@ setsig(int sig, void* handler)
 }
 
 
-void 
+static void
 setup_listen_sock(int fd)
 {
-  int on = 1, r;
+  int on = 1, r = -1;
   r = setsockopt(fd, IPPROTO_TCP, TCP_DEFER_ACCEPT, &on, sizeof(on));
   assert(r == 0);
   r = fcntl(fd, F_SETFL, O_NONBLOCK);
@@ -1261,42 +1540,30 @@ setup_listen_sock(int fd)
 }
 
 
-static void
+static int
 setup_sock(int fd)
 {
-  int on = 1, r;
+  int r;
+  int on = 1;
   r = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on));
-  assert(r == 0);
 
   // 60 + 30 * 4
-  on = 300;
-  r = setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &on, sizeof(on));
-  assert(r == 0);
-  on = 30;
-  r = setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &on, sizeof(on));
-  assert(r == 0);
-  on = 4;
-  r = setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &on, sizeof(on));
-  assert(r == 0);
-
+  /* on = 300; */
+  /* r = setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &on, sizeof(on)); */
+  /* assert(r == 0); */
+  /* on = 30; */
+  /* r = setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &on, sizeof(on)); */
+  /* assert(r == 0); */
+  /* on = 4; */
+  /* r = setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &on, sizeof(on)); */
+  /* assert(r == 0); */
+#if linux
+  r = 0; // Use accept4() on Linux
+#else
   r = fcntl(fd, F_SETFL, O_NONBLOCK);
   assert(r == 0);
-}
-
-
-static void
-disable_cork(client_t *client)
-{
-  int off = 0;
-  int on = 1, r;
-#ifdef linux
-  r = setsockopt(client->fd, IPPROTO_TCP, TCP_CORK, &off, sizeof(off));
-#elif defined(__APPLE__) || defined(__FreeBSD__)
-  r = setsockopt(client->fd, IPPROTO_TCP, TCP_NOPUSH, &off, sizeof(off));
 #endif
-  assert(r == 0);
-  r = setsockopt(client->fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on));
-  assert(r == 0);
+  return r;
 }
 
 
@@ -1311,98 +1578,255 @@ new_client_t(int client_fd, char *remote_addr, uint32_t remote_port)
   client->fd = client_fd;
   client->remote_addr = remote_addr;
   client->remote_port = remote_port;
-  client->req = new_request();
-  client->body_type = BODY_TYPE_NONE;
+  client->request_queue = new_request_queue();
   return client;
 }
 
 
 static void
-clean_cli(client_t *client)
+clean_client(client_t *client)
 {
-  write_access_log(client, log_fd, log_path); 
-  if(client->req){
-    free_request(client->req);
-    client->req = NULL;
+  VALUE environ;
+  uintptr_t end, delta_msec = 0;
+
+  request *req = client->current_req;
+
+  if(log_fd) {
+    write_access_log(client, log_fd, log_path);
+    if(req){
+      environ = req->environ;
+      end = current_msec;
+      if (req->start_msec > 0){
+	delta_msec = end - req->start_msec;
+    }
+    } else {
+      if (client->status_code != 408) {
+	environ = new_environ(client);
+      }
+    }
   }
-  DEBUG("close environ %p \n", client->environ);
 
-  // force clear
-  client->environ = rb_hash_new();
+  if (req == NULL) {
+    goto init;
+  }
 
-  if(client->http != NULL){
-    ruby_xfree(client->http);
-    client->http = NULL;
+  DEBUG("status_code:%d env:%p", client->status_code, req->environ);
+  if (req->body) {
+    req->body = NULL;
   }
+  free_request(req);
+ init:
+  client->current_req = NULL;
+  client->header_done = 0;
+  client->response_closed = 0;
+  client->chunked_response = 0;
+  client->content_length_set = 0;
+  client->content_length = 0;
+  client->write_bytes = 0;
 }
 
 
 static void
-close_conn(client_t *cli, picoev_loop* loop)
+close_client(client_t *client)
 {
-  client_t *new_client;
-  if(!cli->response_closed){
-    close_response(cli);
+  client_t *new_client = NULL;
+
+  if (!client->response_closed) {
+    close_response(client);
   }
-  picoev_del(loop, cli->fd);
+  DEBUG("start close client:%p fd:%d status_code %d", client, client->fd, client->status_code);
 
-  DEBUG("picoev_del client:%p fd:%d \n", cli, cli->fd);
-  clean_cli(cli);
-  if(!cli->keep_alive){
-    close(cli->fd);
-    DEBUG("close client:%p fd:%d \n", cli, cli->fd);
-  }else{
-    disable_cork(cli);
-    new_client = new_client_t(cli->fd, cli->remote_addr, cli->remote_port);
-    rb_gc_register_address(&new_client->environ);
+  if (picoev_is_active(main_loop, client->fd)) {
+    picoev_del(main_loop, client->fd);
+    DEBUG("picoev_del client:%p fd:%d", client, client->fd);
+  }
+
+  clean_client(client);
+
+  DEBUG("remain http pipeline size :%d", client->request_queue->size);
+  if (client->request_queue->size > 0) {
+    /* if (check_status_code(client) > 0) { */
+    //process pipeline
+    prepare_call_rack(client);
+    call_rack_app(client);
+    /* } */
+    return;
+  }
+
+  if (client->http_parser != NULL) {
+    ruby_xfree(client->http_parser);
+  }
+
+  free_request_queue(client->request_queue);
+  if (!client->keep_alive) {
+    close(client->fd);
+    BDEBUG("close client:%p fd:%d", client, client->fd);
+  } else {
+    BDEBUG("keep alive client:%p fd:%d", client, client->fd);
+    new_client = new_client_t(client->fd, client->remote_addr, client->remote_port);
     new_client->keep_alive = 1;
     init_parser(new_client, server_name, server_port);
     picoev_add(main_loop, new_client->fd, PICOEV_READ, keep_alive_timeout, r_callback, (void *)new_client);
   }
-  ruby_xfree(cli);
+  //clear old client
+  ruby_xfree(client);
+}
+
+
+static void
+init_main_loop(void)
+{
+  if (main_loop == NULL) {
+    /* init picoev */
+    picoev_init(max_fd);
+    /* create loop */
+    main_loop = picoev_create_loop(60);
+  }
+}
+
+static char*
+get_reason_phrase(int status_code)
+{
+  if (status_code == 200) {
+    return "OK";
+  } else if (status_code == 201) {
+    return "Created";
+  } else if (status_code == 202) {
+    return "Accepted";
+  } else if (status_code == 203) {
+    return "Non-Authoritative Information";
+  } else if (status_code == 204) {
+    return "No Content";
+  } else if (status_code == 205) {
+    return "Reset Content";
+  } else if (status_code == 206) {
+    return "Partial Content";
+  } else if (status_code == 300) {
+    return "Multiple Choices";
+  } else if (status_code == 301) {
+     return "Moved Permanently";
+  } else if (status_code == 302) {
+     return "Found";
+  } else if (status_code == 303) {
+     return "See Other";
+  } else if (status_code == 304) {
+     return "Not Modified";
+  } else if (status_code == 305) {
+     return "Use Proxy";
+  } else if (status_code == 307) {
+     return "Temporary Redirect";
+  } else if (status_code == 400) {
+     return "Bad Request";
+  } else if (status_code == 401) {
+     return "Unauthorized";
+  } else if (status_code == 402) {
+     return "Payment Required";
+  } else if (status_code == 403) {
+    return "Forbidden";
+  } else if (status_code == 404) {
+    return "Not Found";
+  } else if (status_code == 405) {
+    return "Method Not Allowed";
+  } else if (status_code == 406) {
+    return "Not Acceptable";
+  } else if (status_code == 407) {
+    return "Proxy Authentication Required";
+  } else if (status_code == 408) {
+    return "Request Time-out";
+  } else if (status_code == 409) {
+    return "Conflict";
+  } else if (status_code == 410) {
+    return "Gone";
+  } else if (status_code == 411) {
+    return "Length Required";
+  } else if (status_code == 412) {
+    return "Precondition Failed";
+  } else if (status_code == 413) {
+    return " Request Entity Too Large";
+  } else if (status_code == 414) {
+    return "Request-URI Too Large";
+  } else if (status_code == 415) {
+    return "Unsupported Media Type";
+  } else if (status_code == 416) {
+    return "Requested range not satisfiable";
+  } else if (status_code == 417) {
+    return "Expectation Failed";
+  } else if (status_code == 500) {
+    return "Internal Server Error";
+  } else if (status_code == 501) {
+    return "Not Implemented";
+  } else if (status_code == 502) {
+    return "Bad Gateway";
+  } else if (status_code == 503) {
+    return "Service Unavailable";
+  } else if (status_code == 504) {
+    return "Gateway Time-out";
+  } else if (status_code == 505) {
+    return "HTTP Version not supported";
+  } else {
+    return "Unknown";
+  }
 }
 
 
 static int
 process_rack_app(client_t *cli)
 {
-  VALUE args;
-  char *status;
+  VALUE env, response_arr, status_code, headers, response_body;
+  request *req = cli->current_req;
 
-  args = cli->environ;
+  env = req->environ;
 
   // cli->response = [200, {}, []]
-  cli->response = rb_funcall(rack_app, i_call, 1, args);
+  response_arr = rb_funcall(rack_app, i_call, 1, env);
+
+  // to_arr
+  if (TYPE(response_arr) != T_ARRAY) {
+    response_arr = rb_funcall(response_arr, i_toa, 0);
+  }
 
-  if(TYPE(cli->response) != T_ARRAY || RARRAY_LEN(cli->response) < 3) {
+  if(RARRAY_LEN(response_arr) < 3) {
     return 0;
   }
   
-  VALUE* response_ary = RARRAY_PTR(cli->response);
-
-  /* rb_p(cli->response); */
+  status_code = rb_ary_entry(response_arr, 0);
+  headers = rb_ary_entry(response_arr, 1);
+  response_body = rb_ary_entry(response_arr, 2);
 
-  if (TYPE(response_ary[0]) != T_FIXNUM ||
-      TYPE(response_ary[1]) != T_HASH) {
+  if (TYPE(status_code) != T_FIXNUM ||
+      TYPE(headers) != T_HASH       ||
+      rb_respond_to(response_body, i_each) == 0) {
     return 0;
   }
 
-  cli->status_code = NUM2INT(response_ary[0]);
-  cli->headers = response_ary[1];
+  cli->status_code = NUM2INT(status_code);
+  cli->headers = headers;
+  cli->response_iter = rb_funcall(response_body, i_toenum, 0);
+
+  rb_gc_register_address(&cli->headers);
+  rb_gc_register_address(&cli->response_iter);
+
+  if (cli->response_closed) {
+    //closed
+    close_client(cli);
+    return 1;
+  }
 
   errno = 0;
   /* printf("status code: %d\n", cli->status_code); */
 
+  char* reason_phrase;
+  reason_phrase = get_reason_phrase(cli->status_code);
+
   char buff[256];
-  sprintf(buff, "HTTP/1.1 %d\r\n", cli->status_code);
+  sprintf(buff, "HTTP/1.%d %d %s\r\n", cli->http_parser->http_minor, cli->status_code, reason_phrase);
   cli->http_status = rb_str_new(buff, strlen(buff));
 
   //check response
   if(cli->response && cli->response == Qnil){
     write_error_log(__FILE__, __LINE__);
-    rb_raise(rb_eException, "response must be a iter or sequence object");
+    return 0;
   }
-
   return 1;
 }
 
@@ -1417,85 +1841,256 @@ w_callback(picoev_loop* loop, int fd, int events, void* cb_arg)
     YDEBUG("** w_callback timeout ** \n");
     //timeout
     client->keep_alive = 0;
-    close_conn(client, loop);
+    close_client(client);
 
   } else if ((events & PICOEV_WRITE) != 0) {
     ret = process_body(client);
-    picoev_set_timeout(loop, client->fd, WRITE_TIMEOUT_SECS);
+    /* picoev_set_timeout(loop, client->fd, WRITE_TIMEOUT_SECS); */
     DEBUG("process_body ret %d \n", ret);
     if(ret != 0){
       //ok or die
-      close_conn(client, loop);
+      close_client(client);
     }
   }
 }
 
 
-static void
-call_rack_app(client_t *client, picoev_loop* loop)
+static int
+check_http_expect(client_t *client)
 {
+  VALUE c;
+  char *val = NULL;
   int ret;
+  request *req = client->current_req;
+
+  if (client->http_parser->http_minor == 1) {
+    ///TODO CHECK
+    c = rb_hash_aref(req->environ, http_expect); 
+    if (c != Qnil) {
+      val = StringValuePtr(c);
+      if (!strncasecmp(val, "100-continue", 12)) {
+	ret = write(client->fd, "HTTP/1.1 100 Continue\r\n\r\n", 25);
+	if (ret < 0) {
+	  //fail
+	  client->keep_alive = 0;
+	  client->status_code = 500;
+	  send_error_page(client);
+	  close_client(client);
+	  return -1;
+	}
+      } else {
+	//417
+	client->keep_alive = 0;
+	client->status_code = 417;
+	send_error_page(client);
+	close_client(client);
+	return -1;
+      }
+    }
+    return 1;
+  }
+  return 0;
+}
+
+
+static void
+call_rack_app(client_t *client)
+{
+  response_status ret;
+  request *req = client->current_req;
+
   if(!process_rack_app(client)){
     //Internal Server Error
-    client->bad_request_code = 500;
+    req->bad_request_code = 500;
     send_error_page(client);
-    close_conn(client, loop);
+    close_client(client);
     return;
   }
 
   ret = response_start(client);
   switch(ret){
-  case -1:
+  case STATUS_ERROR:
     // Internal Server Error
-    client->bad_request_code = 500;
+    client->status_code = 500;
     send_error_page(client);
-    close_conn(client, loop);
+    close_client(client);
     return;
-  case 0:
+  case STATUS_SUSPEND:
     // continue
     // set callback
     DEBUG("set write callback %d \n", ret);
     //clear event
-    picoev_del(loop, client->fd);
-    picoev_add(loop, client->fd, PICOEV_WRITE, WRITE_TIMEOUT_SECS, w_callback, (void *)client);
+    picoev_del(main_loop, client->fd);
+    picoev_add(main_loop, client->fd, PICOEV_WRITE, WRITE_TIMEOUT_SECS, w_callback, (void *)client);
     return;
   default:
     // send OK
-    close_conn(client, loop);
+    close_client(client);
   }
 }
 
 
+static inline void
+set_current_request(client_t *client)
+{
+  request *req;
+  req = shift_request(client->request_queue);
+  client->current_req = req;
+}
+
+
 static void
 prepare_call_rack(client_t *client)
 {
-  VALUE input, object, c;
-  char *val;
+  request *req = NULL;
+  VALUE input, object;
+
+  set_current_request(client);    
+  req = client->current_req;
+
+  //check Expect
+  if (check_http_expect(client) < 0) {
+    return;
+  }
 
-  if(client->body_type == BODY_TYPE_BUFFER) {
-    rb_funcall((VALUE)client->body, i_seek, 1, INT2NUM(0));
-    rb_hash_aset(client->environ, rack_input, (VALUE)client->body);
+  if(req->body_type == BODY_TYPE_BUFFER) {
+    rb_funcall((VALUE)req->body, i_seek, 1, INT2NUM(0));
+    rb_hash_aset(req->environ, rack_input, (VALUE)req->body);
   } else {
     object = rb_str_new2("");
     input = rb_funcall(StringIO, i_new, 1, object);
     rb_gc_register_address(&input);
-    rb_hash_aset(client->environ, rack_input, input);
-    client->body = input;
+    rb_hash_aset(req->environ, rack_input, input);
+    req->body = input;
   }
 
-  if(is_keep_alive){
-    //support keep-alive
-    c = rb_hash_aref(client->environ, http_connection);
-    if(c != Qnil){
-      val = StringValuePtr(c);
-      if(!strcasecmp(val, "keep-alive")){
-	client->keep_alive = 1;
-      }else{
-	client->keep_alive = 0;
-      }
-    }else{
+  if(!is_keep_alive){
+    client->keep_alive = 0;
+  }
+}
+
+
+static void
+set_bad_request_code(client_t *client, int status_code)
+{
+  request *req;
+  req = client->request_queue->tail;
+  req->bad_request_code = status_code;
+  DEBUG("set bad request code %d", status_code);
+}
+
+
+static int
+check_status_code(client_t *client)
+{
+  request *req;
+  req = client->request_queue->head;
+  if (req && req->bad_request_code > 200) {
+    //error
+    //shift
+    DEBUG("bad status code %d", req->bad_request_code);
+    set_current_request(client);
+    client->status_code = req->bad_request_code;
+    send_error_page(client);
+    close_client(client);
+    return -1;
+  }
+  return 1;
+}
+
+
+static int
+set_read_error(client_t *client, int status_code)
+{
+  client->keep_alive = 0;
+  if (status_code == 0) {
+    // bad request
+    status_code = 400;
+  }
+  if (client->request_queue->size > 0) {
+    //piplining
+    set_bad_request_code(client, status_code);
+    return 1;
+  } else {
+    client->status_code = status_code;
+    send_error_page(client);
+    close_client(client);
+    return -1;
+  }
+}
+
+
+static int
+read_timeout(int fd, client_t *client)
+{
+  RDEBUG("** read timeout fd:%d", fd);
+  //timeout
+  return set_read_error(client, 408);
+}
+
+
+static int
+parse_http_request(int fd, client_t *client, char *buf, ssize_t r)
+{
+  int nread = 0;
+  request *req = NULL;
+
+  BDEBUG("fd:%d \n%.*s", fd, (int)r, buf);
+  nread = execute_parse(client, buf, r);
+  BDEBUG("read request fd %d readed %d nread %d", fd, (int)r, nread);
+
+  req = client->current_req;
+
+  if (nread != r || req->bad_request_code > 0) {
+    if (req == NULL) {
+      DEBUG("fd %d bad_request code 400", fd);
+      return set_read_error(client, 400);
+    } else {
+      DEBUG("fd %d bad_request code %d", fd,  req->bad_request_code);
+      return set_read_error(client, req->bad_request_code);
+    }
+  }
+
+  if (parser_finish(client) > 0) {
+    return 1;
+  }
+  return 0;
+}
+
+
+static int
+read_request(picoev_loop *loop, int fd, client_t *client, char call_time_update)
+{
+  char buf[READ_BUF_SIZE];
+  ssize_t r;
+
+  if (!client->keep_alive) {
+    picoev_set_timeout(loop, fd, READ_TIMEOUT_SECS);
+  }
+
+  r = read(client->fd, buf, sizeof(buf));
+  switch (r) {
+  case 0: 
+    return set_read_error(client, 503);
+  case -1:
+    // Error
+    if (errno == EAGAIN || errno == EWOULDBLOCK) {
+      // try again later
+      return 0;
+    } else {
+      // Fatal error
       client->keep_alive = 0;
+      if (errno == ECONNRESET) {
+	client->header_done = 1;
+	client->response_closed = 1;
+      }
+      return set_read_error(client, 500);
+    }
+  default:
+    if (call_time_update) {
+      cache_time_update();
     }
+    return parse_http_request(fd, client, buf, r);
   }
 }
 
@@ -1504,85 +2099,22 @@ static void
 r_callback(picoev_loop* loop, int fd, int events, void* cb_arg)
 {
   client_t *cli = ( client_t *)(cb_arg);
+  int finish = 0;
+
   if ((events & PICOEV_TIMEOUT) != 0) {
-    YDEBUG("** r_callback timeout ** \n");
-    //timeout
-    cli->keep_alive = 0;
-    close_conn(cli, loop);
-  } else if ((events & PICOEV_READ) != 0) {
-    RDEBUG("ready read \n");
-    /* update timeout, and read */
-    int finish = 0, nread;
-    char buf[INPUT_BUF_SIZE];
-    ssize_t r;
-    if(!cli->keep_alive){
-      picoev_set_timeout(loop, cli->fd, SHORT_TIMEOUT_SECS);
-    }
-    r = read(cli->fd, buf, sizeof(buf));
-    switch (r) {
-    case 0: 
-      cli->keep_alive = 0;
-      cli->status_code = 500; // ??? 503 ??
-      send_error_page(cli);
-      close_conn(cli, loop);
-      return;
-    case -1: /* error */
-      if (errno == EAGAIN || errno == EWOULDBLOCK) { /* try again later */
-	break;
-      } else { /* fatal error */
-	if (cli->keep_alive && errno == ECONNRESET) {
-	  cli->keep_alive = 0;
-	  cli->status_code = 500;
-	  cli->header_done = 1;
-	  cli->response_closed = 1;
-	} else {
-	  /* rb_raise(rb_eException, "fatal error"); */
-	  write_error_log(__FILE__, __LINE__);
-	  cli->keep_alive = 0;
-	  cli->status_code = 500;
-	  if(errno != ECONNRESET){
-	    send_error_page(cli);
-	  }else{
-	    cli->header_done = 1;
-	    cli->response_closed = 1;
-	  }
-	}
-	close_conn(cli, loop);
-	return;
-      }
-      break;
-    default:
-      RDEBUG("read request fd %d bufsize %d \n", cli->fd, r);
-      nread = execute_parse(cli, buf, r);
-
-      if(cli->bad_request_code > 0){
-	RDEBUG("fd %d bad_request code %d \n", cli->fd,  cli->bad_request_code);
-	send_error_page(cli);
-	close_conn(cli, loop);
-	return;
-      }
-      if( nread != r ){
-	// parse error
-	DEBUG("fd %d parse error %d \n", cli->fd, cli->bad_request_code);
-	cli->bad_request_code = 400;
-	send_error_page(cli);
-	close_conn(cli, loop);
-	return;
-      }
-      RDEBUG("parse ok, fd %d %d nread \n", cli->fd, nread);
+    finish = read_timeout(fd, cli);
 
-      if(parser_finish(cli) > 0){
-	finish = 1;
-      }
-      break;
-    }
-    
-    if(finish == 1){
-      /* picoev_del(loop, cli->fd); */
+  } else if ((events & PICOEV_READ) != 0) {
+    finish = read_request(loop, fd, cli, 0);
+  }
+  if(finish == 1){
+    picoev_del(loop, cli->fd);
+    RDEBUG("del fd: %d", cli->fd);
+    if (check_status_code(cli) > 0) {
       prepare_call_rack(cli);
-      call_rack_app(cli, loop);
-      return;
+      call_rack_app(cli);
     }
+    return;
   }
 }
 
@@ -1595,6 +2127,7 @@ accept_callback(picoev_loop* loop, int fd, int events, void* cb_arg)
   struct sockaddr_in client_addr;
   char *remote_addr;
   uint32_t remote_port;
+  int finish = 0;
 
   if ((events & PICOEV_TIMEOUT) != 0) {
     // time out
@@ -1602,25 +2135,44 @@ accept_callback(picoev_loop* loop, int fd, int events, void* cb_arg)
     return;
   }else if ((events & PICOEV_READ) != 0) {
     socklen_t client_len = sizeof(client_addr);
+    for(;;) {
 #ifdef linux
-    client_fd = accept4(fd, (struct sockaddr *)&client_addr, &client_len, SOCK_NONBLOCK | SOCK_CLOEXEC);
+      client_fd = accept4(fd, (struct sockaddr *)&client_addr, &client_len, SOCK_NONBLOCK | SOCK_CLOEXEC);
 #else
-    client_fd = accept(fd, (struct sockaddr *)&client_addr, &client_len);
+      client_fd = accept(fd, (struct sockaddr *)&client_addr, &client_len);
 #endif
-    if (client_fd != -1) {
-      DEBUG("accept fd %d \n", client_fd);
-      setup_sock(client_fd);
-      remote_addr = inet_ntoa(client_addr.sin_addr);
-      remote_port = ntohs(client_addr.sin_port);
-      client = new_client_t(client_fd, remote_addr, remote_port);
-      rb_gc_register_address(&client->environ);
-      init_parser(client, server_name, server_port);
-      picoev_add(loop, client_fd, PICOEV_READ, keep_alive_timeout, r_callback, (void *)client);
-    }else{
-      if (errno != EAGAIN && errno != EWOULDBLOCK) {
-	write_error_log(__FILE__, __LINE__);
-	// die
-	loop_done = 0;
+      if (client_fd != -1) {
+	DEBUG("accept fd %d \n", client_fd);
+
+	if (setup_sock(client_fd) == -1) {
+	  write_error_log(__FILE__, __LINE__);
+	  // die
+	  loop_done = 0;
+	  return;
+	}
+
+	remote_addr = inet_ntoa(client_addr.sin_addr);
+	remote_port = ntohs(client_addr.sin_port);
+	client = new_client_t(client_fd, remote_addr, remote_port);
+	init_parser(client, server_name, server_port);
+
+	finish = read_request(loop, fd, client, 1);
+	if (finish == 1) {
+	  if (check_status_code(client) > 0) {
+	    //current request ok
+	    prepare_call_rack(client);
+	    call_rack_app(client);
+	  }
+	} else if (finish == 0) {
+	  picoev_add(loop, client_fd, PICOEV_READ, keep_alive_timeout, r_callback, (void *)client);
+	}
+      } else {
+	if (errno != EAGAIN && errno != EWOULDBLOCK) {
+	  write_error_log(__FILE__, __LINE__);
+	  // die
+	  loop_done = 0;
+	}
+      	break;
       }
     }
   }
@@ -1660,7 +2212,6 @@ inet_listen(void)
   for(p = servinfo; p != NULL; p = p->ai_next) {
     if ((listen_sock = socket(p->ai_family, p->ai_socktype,
 			      p->ai_protocol)) == -1) {
-      //perror("server: socket");
       continue;
     }
     
@@ -1677,10 +2228,9 @@ inet_listen(void)
     break;
   }
 
-  if (p == NULL)  {
+  if (p == NULL) {
     close(listen_sock);
     rb_raise(rb_eIOError, "server: failed to bind\n");
-    return -1;
   }
 
   freeaddrinfo(servinfo); // all done with this structure
@@ -1848,9 +2398,7 @@ bossan_run_loop(VALUE self, VALUE args)
   rack_app = args;
     
   /* init picoev */
-  picoev_init(max_fd);
-  /* create loop */
-  main_loop = picoev_create_loop(60);
+  init_main_loop();
   loop_done = 1;
   
   setsig(SIGPIPE, sigpipe_cb);
@@ -1863,6 +2411,7 @@ bossan_run_loop(VALUE self, VALUE args)
   while (loop_done) {
     picoev_loop_once(main_loop, 10);
   }
+
   picoev_destroy_loop(main_loop);
   picoev_deinit();
 
@@ -1874,7 +2423,7 @@ bossan_run_loop(VALUE self, VALUE args)
 }
 
 
-VALUE 
+static VALUE 
 bossan_set_max_content_length(VALUE self, VALUE args)
 {
   max_content_length = NUM2INT(args);
@@ -1882,21 +2431,21 @@ bossan_set_max_content_length(VALUE self, VALUE args)
 }
 
 
-VALUE 
+static VALUE 
 bossan_get_max_content_length(VALUE self)
 {
   return INT2NUM(max_content_length);
 }
 
 
-VALUE 
+static VALUE 
 bossan_set_keepalive(VALUE self, VALUE args)
 {
   int on;
 
   on = NUM2INT(args);
   if(on < 0){
-    rb_p("keep alive value out of range.\n");
+    printf("keep alive value out of range.\n");
     return Qfalse;
   }
 
@@ -1911,14 +2460,14 @@ bossan_set_keepalive(VALUE self, VALUE args)
 }
 
 
-VALUE
+static VALUE
 bossan_get_keepalive(VALUE self)
 {
   return INT2NUM(is_keep_alive);
 }
 
 
-VALUE 
+static VALUE 
 bossan_set_picoev_max_fd(VALUE self, VALUE args)
 {
   int temp;
@@ -1931,14 +2480,14 @@ bossan_set_picoev_max_fd(VALUE self, VALUE args)
 }
 
 
-VALUE 
+static VALUE 
 bossan_get_picoev_max_fd(VALUE self)
 {
   return INT2NUM(max_fd);
 }
 
 
-VALUE
+static VALUE
 bossan_set_backlog(VALUE self, VALUE args)
 {
   int temp;
@@ -1951,7 +2500,7 @@ bossan_set_backlog(VALUE self, VALUE args)
 }
 
 
-VALUE 
+static VALUE 
 bossan_get_backlog(VALUE self)
 {
   return INT2NUM(backlog);
@@ -1992,17 +2541,47 @@ Init_bossan_ext(void)
   rb_gc_register_address(&rack_input);
   rb_gc_register_address(&http_connection);
 
+  rb_gc_register_address(&h_content_type);
+  rb_gc_register_address(&h_content_length);
+  rb_gc_register_address(&content_type);
+  rb_gc_register_address(&content_length);
+
+  rb_gc_register_address(&http_10);
+  rb_gc_register_address(&http_11);
+
+  rb_gc_register_address(&http_delete);
+  rb_gc_register_address(&http_get);
+  rb_gc_register_address(&http_head);
+  rb_gc_register_address(&http_post);
+  rb_gc_register_address(&http_put);
+  rb_gc_register_address(&http_connect);
+  rb_gc_register_address(&http_options);
+  rb_gc_register_address(&http_trace);
+  rb_gc_register_address(&http_copy);
+  rb_gc_register_address(&http_lock);
+  rb_gc_register_address(&http_mkcol);
+  rb_gc_register_address(&http_move);
+  rb_gc_register_address(&http_propfind);
+  rb_gc_register_address(&http_proppatch);
+  rb_gc_register_address(&http_unlock);
+  rb_gc_register_address(&http_report);
+  rb_gc_register_address(&http_mkactivity);
+  rb_gc_register_address(&http_checkout);
+  rb_gc_register_address(&http_merge);
+
   rb_gc_register_address(&http_user_agent);
   rb_gc_register_address(&http_referer);
 
+  rb_gc_register_address(&http_expect);
+
   empty_string = rb_obj_freeze(rb_str_new2(""));
   rb_gc_register_address(&empty_string);
 
   rb_gc_register_address(&i_keys);
   rb_gc_register_address(&i_call);
   rb_gc_register_address(&i_new);
-  rb_gc_register_address(&i_key);
   rb_gc_register_address(&i_each);
+  rb_gc_register_address(&i_toenum);
   rb_gc_register_address(&i_close);
   rb_gc_register_address(&i_write);
   rb_gc_register_address(&i_seek);
@@ -2012,11 +2591,13 @@ Init_bossan_ext(void)
   i_new = rb_intern("new");
   i_call = rb_intern("call");
   i_keys = rb_intern("keys");
-  i_key = rb_intern("key?");
   i_each = rb_intern("each");
+  i_toenum = rb_intern("to_enum");
   i_close = rb_intern("close");
   i_write = rb_intern("write");
   i_seek = rb_intern("seek");
+  i_toa = rb_intern("to_a");
+  i_next = rb_intern("next");
 
   server = rb_define_module("Bossan");
   rb_gc_register_address(&server);