RubyGems - bossan - Versions diffs - 0.1.0 - Mend

bossan 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

data/LICENSE.txt ADDED Viewed

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Hiroki Noda
+MIT License
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/ext/bossan/bossan_ext.c ADDED Viewed

@@ -0,0 +1,2012 @@
+#include "ruby.h"
+#include <assert.h>
+#include <fcntl.h>
+#include <stddef.h>
+#include <unistd.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+#include <arpa/inet.h>
+#include <signal.h>
+#include <sys/sendfile.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/prctl.h>
+#include <sys/un.h>
+#include <sys/stat.h>
+#include <sys/file.h>
+#include <sys/uio.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <netdb.h>
+#include "time_cache.h"
+#include "http_parser.h"
+#include "picoev.h"
+#define MAX_FDS 1024 * 8
+#define ACCEPT_TIMEOUT_SECS 1
+#define SHORT_TIMEOUT_SECS 2
+#define WRITE_TIMEOUT_SECS 5
+#define READ_LONG_TIMEOUT_SECS 5
+#define BACKLOG 1024
+#define MAX_BUFSIZE 1024 * 8
+#define INPUT_BUF_SIZE 1024 * 8
+#define LIMIT_MAX 1024 * 1024 * 1024
+#define LIMIT_SIZE 1024 * 512
+#define LIMIT_PATH 1024 * 4
+#define LIMIT_FRAGMENT 1024
+#define LIMIT_URI 1024 * 4
+#define LIMIT_QUERY_STRING 1024 * 8
+#define LIMIT_REQUEST_FIELDS 30
+#define LIMIT_REQUEST_FIELD_SIZE 1024 * 8
+#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</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 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</head><body><p>Bad Request.</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</head><body><p>Length Required.</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</head><body><p>Request Entity Too Large.</p></body></html>")
+#define SERVER "bossan/0.1"
+VALUE server; // Bossan::Server
+static VALUE version_key;
+static VALUE version_val;
+static VALUE scheme_key;
+static VALUE scheme_val;
+static VALUE errors_key;
+static VALUE errors_val;
+static VALUE multithread_key;
+static VALUE multithread_val;
+static VALUE multiprocess_key;
+static VALUE multiprocess_val;
+static VALUE run_once_key;
+static VALUE run_once_val;
+static VALUE script_key;
+static VALUE script_val;
+static VALUE server_name_key;
+static VALUE server_name_val;
+static VALUE server_port_key;
+static VALUE server_port_val;
+static VALUE server_protocol;
+static VALUE path_info;
+static VALUE request_uri;
+static VALUE query_string;
+static VALUE http_fragment;
+static VALUE request_method;
+static VALUE rb_remote_addr;
+static VALUE rb_remote_port;
+static VALUE rack_input;
+static VALUE http_connection;
+static VALUE http_user_agent;
+static VALUE i_keys;
+static VALUE i_call;
+static VALUE i_new;
+static char *server_name = "127.0.0.1";
+static short server_port = 8000;
+static int listen_sock;  // listen socket
+static int loop_done; // main loop flag
+static picoev_loop* main_loop; //main loop
+static VALUE rack_app = NULL; //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
+int max_content_length = 1024 * 1024 * 16; //max_content_length
+static VALUE StringIO;
+typedef enum {
+  WRITE_OK,
+  MEMORY_ERROR,
+  LIMIT_OVER,
+} buffer_result;
+typedef struct {
+  char *buf;
+  size_t buf_size;
+  size_t len;
+  size_t limit;
+} buffer;
+typedef struct {
+  VALUE filelike;
+} FileWrapperObject;
+typedef enum {
+  FIELD,
+  VAL,
+} field_type;
+typedef struct {
+  buffer *field;
+  buffer *value;
+} header;
+typedef struct {
+  buffer *path;
+  buffer *uri;
+  buffer *query_string;
+  buffer *fragment;
+  header *headers[LIMIT_REQUEST_FIELDS];
+  uint32_t num_headers;
+  field_type last_header_element;
+} request;
+typedef enum {
+  BODY_TYPE_NONE,
+  BODY_TYPE_TMPFILE,
+  BODY_TYPE_BUFFER
+} request_body_type;
+typedef struct _client {
+  int fd;
+  char *remote_addr;
+  uint32_t remote_port;
+  uint8_t keep_alive;
+  request *req;
+  uint32_t body_length;
+  int body_readed;
+  void *body;
+  int bad_request_code;
+  request_body_type body_type;
+  uint8_t complete;
+  http_parser *http;          // http req parser
+  VALUE environ;              // rack environ
+  int status_code;            // response status code
+  VALUE http_status;             // response status line
+  VALUE headers;                 // http response headers
+  uint8_t header_done;            // header write status
+  VALUE response;                // rack response object
+  VALUE response_iter;           // rack response object
+  uint8_t content_length_set;     // content_length_set flag
+  uint32_t content_length;         // content_length
+  uint32_t write_bytes;            // send body length
+  void *bucket;               //write_data
+  uint8_t response_closed;    //response closed flag
+} client_t;
+typedef struct iovec iovec_t;
+typedef struct {
+  int fd;
+  iovec_t *iov;
+  uint32_t iov_cnt;
+  uint32_t iov_size;
+  uint32_t total;
+  uint32_t total_size;
+} write_bucket;
+inline buffer *
+new_buffer(size_t buf_size, size_t limit)
+{
+  buffer *buf;
+  buf = ruby_xmalloc(sizeof(buffer));
+  memset(buf, 0, sizeof(buffer));
+  buf->buf = ruby_xmalloc(sizeof(char) * buf_size);
+  buf->buf_size = buf_size;
+  if(limit){
+    buf->limit = limit;
+  }else{
+    buf->limit = LIMIT_MAX;
+  }
+  return buf;
+}
+inline buffer_result
+write2buf(buffer *buf, const char *c, size_t  l) {
+  size_t newl;
+  char *newbuf;
+  buffer_result ret = WRITE_OK;
+  newl = buf->len + l;
+  if (newl >= buf->buf_size) {
+    buf->buf_size *= 2;
+    if(buf->buf_size <= newl) {
+      buf->buf_size = (int)(newl + 1);
+    }
+    if(buf->buf_size > buf->limit){
+      buf->buf_size = buf->limit + 1;
+    }
+    newbuf = (char*)ruby_xrealloc(buf->buf, buf->buf_size);
+    buf->buf = newbuf;
+  }
+  if(newl >= buf->buf_size){
+    l = buf->buf_size - buf->len -1;
+    ret = LIMIT_OVER;
+  }
+  memcpy(buf->buf + buf->len, c , l);
+  buf->len += (int)l;
+  return ret;
+}
+inline void
+free_buffer(buffer *buf)
+{
+  ruby_xfree(buf->buf);
+  ruby_xfree(buf);
+}
+inline VALUE
+getRbString(buffer *buf)
+{
+  VALUE o;
+  o = rb_str_new(buf->buf, buf->len);
+  free_buffer(buf);
+  return o;
+}
+inline char *
+getString(buffer *buf)
+{
+  buf->buf[buf->len] = '\0';
+  return buf->buf;
+}
+int
+open_log_file(const char *path)
+{
+  return open(path, O_CREAT|O_APPEND|O_WRONLY, 0744);
+}
+static inline int
+write_log(const char *new_path, int fd, const char *data, size_t len)
+{
+  int openfd;
+  flock(fd, LOCK_EX);
+  if(write(fd, data, len) < 0){
+    flock(fd, LOCK_UN);
+    //reopen
+    openfd = open_log_file(new_path);
+    if(openfd < 0){
+      //fail
+      return -1;
+    }
+    flock(openfd, LOCK_EX);
+    if(write(openfd, data, len) < 0){
+      flock(openfd, LOCK_UN);
+      // write fail
+      return -1;
+    }
+    flock(openfd, LOCK_UN);
+    return openfd;
+  }
+  flock(fd, LOCK_UN);
+  return fd;
+}
+int
+write_access_log(client_t *cli, int log_fd, const char *log_path)
+{
+  char buf[1024];
+  if(log_fd > 0){
+    VALUE obj;
+    char *method, *path, *version, *ua;
+    obj = rb_hash_aref(cli->environ, request_method);
+    if(obj){
+      method = StringValuePtr(obj);
+    }else{
+      method = "-";
+    }
+    obj = rb_hash_aref(cli->environ, path_info);
+    if(obj){
+      path = StringValuePtr(obj);
+    }else{
+      path = "-";
+    }
+    obj = rb_hash_aref(cli->environ, server_protocol);
+    if(obj){
+      version = StringValuePtr(obj);
+    }else{
+      version = "-";
+    }
+    obj = rb_hash_aref(cli->environ, http_user_agent);
+    if(obj){
+      ua = StringValuePtr(obj);
+    }else{
+      ua = "-";
+    }
+    //update
+    cache_time_update();
+    sprintf(buf, "%s - - [%s] \"%s %s %s\" %d %d \"-\" \"%s\"\n",
+	    cli->remote_addr,
+	    http_log_time,
+	    method,
+	    path,
+	    version,
+	    cli->status_code,
+	    cli->write_bytes,
+	    ua);
+    return write_log(log_path, log_fd, buf, strlen(buf));
+  }
+  return 0;
+}
+static inline int
+blocking_write(client_t *client, char *data, size_t len)
+{
+  size_t r = 0, send_len = len;
+  while ( (int)len > 0 ){
+    if (len < send_len){
+      send_len = len;
+    }
+    r = write(client->fd, data, send_len);
+    switch(r){
+    case 0:
+      return 1;
+      break;
+    case -1:
+      if (errno == EAGAIN || errno == EWOULDBLOCK) { /* try again later */
+	//printf("EAGAIN \n");
+	usleep(500); //TODO try again later
+	break;
+      }else{
+	// fatal error
+	//close
+	rb_raise(rb_eException, "fatal error");
+	// TODO:
+	// raise exception from errno
+	/* rb_raise(rb_eIOError); */
+	/* write_error_log(__FILE__, __LINE__); */
+	client->keep_alive = 0;
+	return -1;
+      }
+    default:
+      data += (int)r;
+      len -= r;
+      client->content_length += r;
+    }
+  }
+  return 1;
+}
+void
+send_error_page(client_t *client)
+{
+  shutdown(client->fd, SHUT_RD);
+  if(client->header_done){
+    //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){
+  case 400:
+    blocking_write(client, MSG_400, sizeof(MSG_400) -1);
+    break;
+  case 411:
+    blocking_write(client, MSG_411, sizeof(MSG_411) -1);
+    break;
+  case 413:
+    blocking_write(client, MSG_413, sizeof(MSG_413) -1);
+    break;
+  default:
+    //Internal Server Error
+    blocking_write(client, MSG_500, sizeof(MSG_500) -1);
+    break;
+  }
+  client->keep_alive = 0;
+}
+static inline void
+extent_sndbuf(client_t *client)
+{
+  int bufsize = 1024 * 1024 * 2, r;
+  r = setsockopt(client->fd, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize));
+  assert(r == 0);
+}
+static inline void
+enable_cork(client_t *client)
+{
+  int on = 1, r;
+  r = setsockopt(client->fd, IPPROTO_TCP, TCP_CORK, &on, sizeof(on));
+  assert(r == 0);
+}
+static inline write_bucket *
+new_write_bucket(int fd, int cnt)
+{
+  write_bucket *bucket;
+  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);
+  bucket->iov_size = cnt;
+  return bucket;
+}
+static inline void
+free_write_bucket(write_bucket *bucket)
+{
+  ruby_xfree(bucket->iov);
+  ruby_xfree(bucket);
+}
+static inline void
+set2bucket(write_bucket *bucket, char *buf, size_t len)
+{
+  bucket->iov[bucket->iov_cnt].iov_base = buf;
+  bucket->iov[bucket->iov_cnt].iov_len = len;
+  bucket->iov_cnt++;
+  bucket->total += len;
+  bucket->total_size += len;
+}
+static inline void
+add_header(write_bucket *bucket, char *key, size_t keylen, char *val, size_t vallen)
+{
+  set2bucket(bucket, key, keylen);
+  set2bucket(bucket, DELIM, 2);
+  set2bucket(bucket, val, vallen);
+  set2bucket(bucket, CRLF, 2);
+}
+static inline int
+writev_bucket(write_bucket *data)
+{
+  size_t w;
+  int i = 0;
+  w = writev(data->fd, data->iov, data->iov_cnt);
+  if(w == -1){
+    //error
+    if (errno == EAGAIN || errno == EWOULDBLOCK) {
+      // try again later
+      return 0;
+    }else{
+      //ERROR
+      rb_raise(rb_eException, "fatal error");
+      // TODO:
+      // raise exception from errno
+      /* rb_raise(rb_eIOError); */
+      /* write_error_log(__FILE__, __LINE__);  */
+      return -1;
+    }
+  }if(w == 0){
+    return 1;
+  }else{
+    if(data->total > w){
+      for(; i < data->iov_cnt;i++){
+	if(w > data->iov[i].iov_len){
+	  //already write
+	  w -= data->iov[i].iov_len;
+	  data->iov[i].iov_len = 0;
+	}else{
+	  data->iov[i].iov_base += w;
+	  data->iov[i].iov_len = data->iov[i].iov_len - w;
+	  break;
+	}
+      }
+      data->total = data->total -w;
+#ifdef DEBUG
+      printf("writev_bucket write %d progeress %d/%d \n", w, data->total, data->total_size);
+#endif
+      //resume
+      // again later
+      return writev_bucket(data);
+    }
+  }
+  return 1;
+}
+static inline int
+write_headers(client_t *client, char *data, size_t datalen)
+{
+  if(client->header_done){
+    return 1;
+  }
+  write_bucket *bucket;
+  uint32_t i = 0, hlen = 0;
+  VALUE arr = NULL;
+  VALUE object = NULL;
+  char *name = NULL;
+  ssize_t namelen;
+  char *value = NULL;
+  long valuelen;
+  if(client->headers){
+    if (TYPE(client->headers) != T_HASH) {
+      return -1;
+    }
+    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);
+    //write status code
+    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){
+      add_header(bucket, "Connection", 10, "keep-alive", 10);
+    }
+  }
+  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, rb_intern("key?"), 1, object1);
+      if (tmp == Qfalse){
+	goto error;
+      }
+      object2 = rb_hash_aref(client->headers, object1);
+      Check_Type(object2, T_STRING);
+      name = StringValuePtr(object1);
+      namelen = RSTRING_LEN(object1);
+      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 (!strcasecmp(name, "Server") || !strcasecmp(name, "Date")) {
+ 	continue;
+      }
+      if (!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;
+      }
+    add_header(bucket, name, namelen, value, valuelen);
+    }
+  }
+  set2bucket(bucket, CRLF, 2);
+  if(data){
+    set2bucket(bucket, data, datalen);
+  }
+  client->bucket = bucket;
+  int ret = writev_bucket(bucket);
+  if(ret != 0){
+    client->header_done = 1;
+    if(ret > 0 && data){
+      client->write_bytes += datalen;
+    }
+    // clear
+    free_write_bucket(bucket);
+    client->bucket = NULL;
+  }
+  return ret;
+ error:
+  /* write_error_log(__FILE__, __LINE__); */
+  if(bucket){
+    free_write_bucket(bucket);
+    client->bucket = NULL;
+  }
+  return -1;
+}
+/* static inline int */
+/* write_sendfile(int out_fd, int in_fd, size_t count) */
+/* { */
+/*   int size = (int)count; */
+/*   if (size == 0) { */
+/*     struct stat info; */
+/*     if (fstat(in_fd, &info) == -1){ */
+/*       // TODO: */
+/*       // raise exception from errno */
+/*       /\* rb_raise(); *\/ */
+/*       /\* write_error_log(__FILE__, __LINE__);  *\/ */
+/*       return -1; */
+/*     } */
+/*     size = info.st_size - lseek(in_fd, 0, SEEK_CUR); */
+/*   } */
+/*   return sendfile(out_fd, in_fd, NULL, count); */
+/* } */
+static inline void
+close_response(client_t *client)
+{
+  //send all response
+  //closing reponse object
+  client->response_closed = 1;
+}
+static inline int
+processs_write(client_t *client)
+{
+  VALUE iterator = NULL;
+  VALUE arr;
+  VALUE item;
+  char *buf;
+  ssize_t buflen;
+  write_bucket *bucket;
+  int ret;
+  // body
+  iterator = client->response_iter;
+  if(iterator != NULL){
+    /* Check_Type(iterator, T_ARRAY); */
+    /* assert(3 == RARRAY_LEN(iterator)); */
+    if (TYPE(iterator) != T_ARRAY || RARRAY_LEN(iterator) != 3){
+      return -1;
+    }
+    arr = rb_ary_entry(iterator, 2);
+    if (TYPE(arr) != T_ARRAY){
+      return -1;
+    }
+    item = rb_ary_entry(arr, 0);
+    if(TYPE(item) != T_STRING) {
+      return -1;
+    }
+    buf = StringValuePtr(item);
+    buflen = RSTRING_LEN(item);
+    //write
+    bucket = new_write_bucket(client->fd, 1);
+    set2bucket(bucket, buf, buflen);
+    ret = writev_bucket(bucket);
+    if(ret <= 0){
+      return ret;
+    }
+    //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;
+      }
+    }
+    close_response(client);
+  }
+  return 1;
+}
+inline int
+process_body(client_t *client)
+{
+  int ret;
+  write_bucket *bucket;
+  if(client->bucket){
+    bucket = (write_bucket *)client->bucket;
+    //retry send
+    ret = writev_bucket(bucket);
+    if(ret != 0){
+      client->write_bytes += bucket->total_size;
+      //free
+      free_write_bucket(bucket);
+      client->bucket = NULL;
+    }else{
+      return 0;
+    }
+  }
+  ret = processs_write(client);
+  return ret;
+}
+static inline int
+start_response_write(client_t *client)
+{
+  VALUE iterator;
+  VALUE arr;
+  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));
+  arr = rb_ary_entry(iterator, 2);
+  if (TYPE(arr) != T_ARRAY){
+    return -1;
+  }
+  VALUE v_body = rb_ary_entry(arr, 0);
+  Check_Type(v_body, T_STRING);
+  if (v_body) {
+    buf = StringValuePtr(v_body);
+    buflen = RSTRING_LEN(v_body);
+#ifdef DEBUG
+    printf("start_response_write buflen %d \n", buflen);
+#endif
+    return write_headers(client, buf, buflen);
+  }
+  return -1;
+}
+inline int
+response_start(client_t *client)
+{
+  int ret;
+  enable_cork(client);
+  if(client->status_code == 304){
+    return write_headers(client, NULL, 0);
+  }
+  ret = start_response_write(client);
+#ifdef DEBUG
+  printf("start_response_write ret = %d \n", ret);
+#endif
+  if(ret > 0){
+    // sended header
+    ret = processs_write(client);
+  }
+  return ret;
+}
+inline request *
+new_request(void)
+{
+  request *req = (request *)ruby_xmalloc(sizeof(request));
+  memset(req, 0, sizeof(request));
+  return req;
+}
+inline header *
+new_header(size_t fsize, size_t flimit, size_t vsize, size_t vlimit)
+{
+  header *h;
+  h = ruby_xmalloc(sizeof(header));
+  h->field = new_buffer(fsize, flimit);
+  h->value = new_buffer(vsize, vlimit);
+  return h;
+}
+inline void
+free_header(header *h)
+{
+  ruby_xfree(h);
+}
+inline void
+free_request(request *req)
+{
+  uint32_t i;
+  header *h;
+  if(req->path){
+    free_buffer(req->path);
+    req->path = NULL;
+  }
+  if(req->uri){
+    free_buffer(req->uri);
+    req->uri = NULL;
+  }
+  if(req->query_string){
+    free_buffer(req->query_string);
+    req->query_string = NULL;
+  }
+  if(req->fragment){
+    free_buffer(req->fragment);
+    req->fragment = NULL;
+  }
+  for(i = 0; i < req->num_headers+1; i++){
+    h = req->headers[i];
+    if(h){
+      free_buffer(h->field);
+      free_buffer(h->value);
+      free_header(h);
+      req->headers[i] = NULL;
+    }
+  }
+  ruby_xfree(req);
+}
+static inline void
+key_upper(char *s, const char *key, size_t len)
+{
+  int i = 0;
+  register int c;
+  for (i = 0; i < len; i++) {
+    c = key[i];
+    if(c == '-'){
+      s[i] = '_';
+    }else{
+      if(islower(c)){
+	s[i] = toupper(c);
+      }else{
+	s[i] = c;
+      }
+    }
+  }
+}
+static inline int
+write_body2file(client_t *client, const char *buffer, size_t buffer_len)
+{
+  FILE *tmp = (FILE *)client->body;
+  fwrite(buffer, 1, buffer_len, tmp);
+  client->body_readed += buffer_len;
+#ifdef DEBUG
+  printf("write_body2file %d bytes \n", buffer_len);
+#endif
+  return client->body_readed;
+}
+static inline int
+write_body2mem(client_t *client, const char *buffer, size_t buffer_len)
+{
+  printf("body2mem called\n");
+  VALUE obj = (VALUE)client->body;
+  rb_str_concat(obj, rb_str_new(buffer, buffer_len));
+  client->body_readed += buffer_len;
+#ifdef DEBUG
+  printf("write_body2mem %d bytes \n", buffer_len);
+#endif
+  return client->body_readed;
+}
+static inline int
+write_body(client_t *cli, const char *buffer, size_t buffer_len)
+{
+  return write_body2mem(cli, buffer, buffer_len);
+}
+typedef enum{
+  CONTENT_TYPE,
+  CONTENT_LENGTH,
+  OTHER
+} rack_header_type;
+static inline rack_header_type
+check_header_type(const char *buf)
+{
+  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;
+  }
+  char c = *buf++;
+  if(c == 'L'){
+    return CONTENT_LENGTH;
+  }else if(c == 'T'){
+    return CONTENT_TYPE;
+  }
+  return OTHER;
+}
+static inline client_t *
+get_client(http_parser *p)
+{
+  return (client_t *)p->data;
+}
+int
+message_begin_cb(http_parser *p)
+{
+  return 0;
+}
+int
+header_field_cb (http_parser *p, const char *buf, size_t len, char partial)
+{
+  uint32_t i;
+  register header *h;
+  client_t *client = get_client(p);
+  register 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;
+    }
+    req->num_headers++;
+  }
+  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);
+    }
+    ret = write2buf(h->field, temp, len);
+    //printf("%s \n", getString(h->field));
+  }
+  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->last_header_element = FIELD;
+  return 0;
+}
+int
+header_value_cb (http_parser *p, const char *buf, size_t len, char partial)
+{
+  uint32_t i;
+  register header *h;
+  client_t *client = get_client(p);
+  register 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;
+  }
+  req->last_header_element = VAL;
+  return 0;
+}
+int
+request_path_cb (http_parser *p, const char *buf, size_t len, char partial)
+{
+  client_t *client = get_client(p);
+  register 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;
+  }
+  return 0;
+}
+int
+request_uri_cb (http_parser *p, const char *buf, size_t len, char partial)
+{
+  client_t *client = get_client(p);
+  register request *req = client->req;
+  buffer_result ret = MEMORY_ERROR;
+  if(req->uri){
+    ret = write2buf(req->uri, buf, len);
+  }else{
+    req->uri = new_buffer(1024, LIMIT_URI);
+    ret = write2buf(req->uri, 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;
+  }
+  return 0;
+}
+int
+query_string_cb (http_parser *p, const char *buf, size_t len, char partial)
+{
+  client_t *client = get_client(p);
+  register request *req = client->req;
+  buffer_result ret = MEMORY_ERROR;
+  if(req->query_string){
+    ret = write2buf(req->query_string, buf, len);
+  }else{
+    req->query_string = new_buffer(1024*2, LIMIT_QUERY_STRING);
+    ret = write2buf(req->query_string, 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;
+  }
+  return 0;
+}
+int
+fragment_cb (http_parser *p, const char *buf, size_t len, char partial)
+{
+  client_t *client = get_client(p);
+  register request *req = client->req;
+  buffer_result ret = MEMORY_ERROR;
+  if(req->fragment){
+    ret = write2buf(req->fragment, buf, len);
+  }else{
+    req->fragment = new_buffer(1024, LIMIT_FRAGMENT);
+    ret = write2buf(req->fragment, 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;
+  }
+  return 0;
+}
+int
+body_cb (http_parser *p, const char *buf, size_t len, char partial)
+{
+  client_t *client = get_client(p);
+  if(max_content_length <= client->body_readed + len){
+    client->bad_request_code = 413;
+    return -1;
+  }
+  if(client->body_type == BODY_TYPE_NONE){
+    if(client->body_length == 0){
+      //Length Required
+      client->bad_request_code = 411;
+      return -1;
+    }
+    //default memory stream
+#ifdef DEBUG
+    printf("client->body_length %d \n", client->body_length);
+#endif
+    client->body_type = BODY_TYPE_BUFFER;
+#ifdef DEBUG
+    printf("BODY_TYPE_BUFFER \n");
+#endif
+  }
+  write_body(client, buf, len);
+  return 0;
+}
+int
+headers_complete_cb(http_parser *p)
+{
+  register VALUE obj, key;
+  client_t *client = get_client(p);
+  request *req = client->req;
+  register VALUE env = client->environ;
+  register uint32_t i = 0;
+  register header *h;
+  if(max_content_length < p->content_length){
+    client->bad_request_code = 413;
+    return -1;
+  }
+  if (p->http_minor == 1) {
+    obj = rb_str_new2("HTTP/1.1");
+  } else {
+    obj = rb_str_new2("HTTP/1.0");
+  }
+  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(req->uri){
+    obj = getRbString(req->uri);
+    rb_hash_aset(env, request_uri, obj);
+    req->uri = 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;
+    }
+  }
+  switch(p->method){
+  case HTTP_DELETE:
+    obj = rb_str_new("DELETE", 6);
+    break;
+  case HTTP_GET:
+    obj = rb_str_new("GET", 3);
+    break;
+  case HTTP_HEAD:
+    obj = rb_str_new("HEAD", 4);
+    break;
+  case HTTP_POST:
+    obj = rb_str_new("POST", 4);
+    break;
+  case HTTP_PUT:
+    obj = rb_str_new("PUT", 3);
+    break;
+  case HTTP_CONNECT:
+    obj = rb_str_new("CONNECT", 7);
+    break;
+  case HTTP_OPTIONS:
+    obj = rb_str_new("OPTIONS", 7);
+    break;
+  case  HTTP_TRACE:
+    obj = rb_str_new("TRACE", 5);
+    break;
+  case HTTP_COPY:
+    obj = rb_str_new("COPY", 4);
+    break;
+  case HTTP_LOCK:
+    obj = rb_str_new("LOCK", 4);
+    break;
+  case HTTP_MKCOL:
+    obj = rb_str_new("MKCOL", 5);
+    break;
+  case HTTP_MOVE:
+    obj = rb_str_new("MOVE", 4);
+    break;
+  case HTTP_PROPFIND:
+    obj = rb_str_new("PROPFIND", 8);
+    break;
+  case HTTP_PROPPATCH:
+    obj = rb_str_new("PROPPATCH", 9);
+    break;
+  case HTTP_UNLOCK:
+    obj = rb_str_new("UNLOCK", 6);
+    break;
+  case HTTP_REPORT:
+    obj = rb_str_new("REPORT", 6);
+    break;
+  case HTTP_MKACTIVITY:
+    obj = rb_str_new("MKACTIVITY", 10);
+    break;
+  case HTTP_CHECKOUT:
+    obj = rb_str_new("CHECKOUT", 8);
+    break;
+  case HTTP_MERGE:
+    obj = rb_str_new("MERGE", 5);
+    break;
+  default:
+    obj = rb_str_new("GET", 3);
+    break;
+  }
+  rb_hash_aset(env, request_method, obj);
+  ruby_xfree(req);
+  client->req = NULL;
+  client->body_length = p->content_length;
+  return 0;
+}
+int
+message_complete_cb (http_parser *p)
+{
+  client_t *client = get_client(p);
+  client->complete = 1;
+  return 0;
+}
+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
+  };
+inline int
+init_parser(client_t *cli, const char *name, const short port)
+{
+  register VALUE object;
+  cli->http = (http_parser*)ruby_xmalloc(sizeof(http_parser));
+  memset(cli->http, 0, sizeof(http_parser));
+  cli->environ = rb_hash_new();
+  if (cli->environ == NULL) {
+    return -1;
+  }
+  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);
+  object = rb_str_new2(cli->remote_addr);
+  rb_hash_aset(cli->environ, rb_remote_addr, object);
+  object = INT2NUM(cli->remote_port);
+  rb_hash_aset(cli->environ, rb_remote_port, object);
+  http_parser_init(cli->http, HTTP_REQUEST);
+  cli->http->data = cli;
+  return 0;
+}
+inline size_t
+execute_parse(client_t *cli, const char *data, size_t len)
+{
+  return http_parser_execute(cli->http, &settings, data, len);
+}
+inline int
+parser_finish(client_t *cli)
+{
+  return cli->complete;
+}
+inline void
+setup_static_env(char *name, int port)
+{
+  version_val = rb_obj_freeze(rb_ary_new3(2, INT2FIX(1), INT2FIX(1)));
+  version_key = rb_str_new2("rack.version");
+  scheme_val = rb_str_new2("http");
+  scheme_key = rb_str_new2("rack.url_scheme");
+  errors_val = rb_stderr;
+  errors_key = rb_str_new2("rack.errors");
+  multithread_val = Qfalse;
+  multithread_key = rb_str_new2("rack.multithread");
+  multiprocess_val = Qfalse; /* or Qtrue? I have no clue.. */
+  multiprocess_key = rb_str_new2("rack.multiprocess");
+  run_once_val = Qfalse;
+  run_once_key = rb_str_new2("rack.run_once");
+  script_val = rb_str_new2("");
+  script_key = rb_str_new2("SCRIPT_NAME");
+  server_name_val = rb_str_new2(name);
+  server_name_key = rb_str_new2("SERVER_NAME");
+  server_port_val = INT2NUM(port);
+  server_port_key = rb_str_new2("SERVER_PORT");
+  server_protocol = rb_str_new2("SERVER_PROTOCOL");
+  path_info = rb_str_new2("PATH_INFO");
+  request_uri = rb_str_new2("REQUEST_URI");
+  query_string = rb_str_new2("QUERY_STRING");
+  http_fragment = rb_str_new2("HTTP_FRAGMENT");
+  request_method = rb_str_new2("REQUEST_METHOD");
+  rb_remote_addr = rb_str_new2("REMOTE_ADDR");
+  rb_remote_port = rb_str_new2("REMOTE_PORT");
+  rack_input = rb_str_new2("rack.input");
+  http_connection = rb_str_new2("HTTP_CONNECTION");
+  http_user_agent = rb_str_new2("HTTP_USER_AGENT");
+}
+static inline int
+setsig(int sig, void* handler)
+{
+  struct sigaction context, ocontext;
+  context.sa_handler = handler;
+  sigemptyset(&context.sa_mask);
+  context.sa_flags = 0;
+  return sigaction(sig, &context, &ocontext);
+}
+static inline void
+setup_sock(int fd)
+{
+  int on = 1, r;
+  r = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on));
+  assert(r == 0);
+  r = fcntl(fd, F_SETFL, O_NONBLOCK);
+  assert(r == 0);
+}
+static inline void
+disable_cork(client_t *client)
+{
+  int off = 0;
+  int on = 1, r;
+  r = setsockopt(client->fd, IPPROTO_TCP, TCP_CORK, &off, sizeof(off));
+  assert(r == 0);
+  r = setsockopt(client->fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on));
+  assert(r == 0);
+}
+static inline client_t *
+new_client_t(int client_fd, struct sockaddr_in client_addr){
+  client_t *client;
+  client = ruby_xmalloc(sizeof(client_t));
+  memset(client, 0, sizeof(client_t));
+  /* printf("size %d\n", sizeof(client_t)); */
+  client->fd = client_fd;
+  client->remote_addr = inet_ntoa(client_addr.sin_addr);
+  client->remote_port = ntohs(client_addr.sin_port);
+  client->req = new_request();
+  client->body_type = BODY_TYPE_NONE;
+  //printf("input_buf_size %d\n", client->input_buf_size);
+  return client;
+}
+static inline void
+clean_cli(client_t *client)
+{
+  write_access_log(client, log_fd, log_path);
+  if(client->req){
+    free_request(client->req);
+    client->req = NULL;
+  }
+  if(client->http != NULL){
+    ruby_xfree(client->http);
+    client->http = NULL;
+  }
+}
+static inline void
+close_conn(client_t *cli, picoev_loop* loop)
+{
+  if(!cli->keep_alive){
+    picoev_del(loop, cli->fd);
+    clean_cli(cli);
+    close(cli->fd);
+#ifdef DEBUG
+    printf("close fd %d \n", cli->fd);
+#endif
+    ruby_xfree(cli);
+  }else{
+    clean_cli(cli);
+    disable_cork(cli);
+    cli->keep_alive = 1;
+    cli->environ = NULL;
+    cli->http_status = NULL;
+    cli->headers = NULL;
+    cli->header_done = 0;
+    cli->body_type = BODY_TYPE_NONE;
+    cli->status_code = 0;
+    cli->response = NULL;
+    cli->content_length_set = 0;
+    cli->content_length = 0;
+    cli->write_bytes = 0;
+    cli->response_closed = 0;
+    cli->bad_request_code = 0;
+    init_parser(cli, server_name, server_port);
+  }
+}
+static inline int
+process_rack_app(client_t *cli)
+{
+  VALUE args = NULL;
+  char *status;
+  args = cli->environ;
+  // cli->response = [200, {}, []]
+  cli->response = rb_funcall(rack_app, i_call, 1, args);
+  if(TYPE(cli->response) != T_ARRAY || RARRAY_LEN(cli->response) < 3) {
+    return 0;
+  }
+  VALUE* response_ary = RARRAY_PTR(cli->response);
+  if (TYPE(response_ary[0])!=T_FIXNUM ||
+      TYPE(response_ary[1])!=T_HASH   ||
+      TYPE(response_ary[2])!=T_ARRAY){
+    return 0;
+  }
+  cli->status_code = NUM2INT(response_ary[0]);
+  cli->headers = response_ary[1];
+  errno = 0;
+  /* printf("status code: %d\n", cli->status_code); */
+  char buff[256];
+  sprintf(buff, "HTTP/1.1 %d\r\n", cli->status_code);
+  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 1;
+}
+static void
+w_callback(picoev_loop* loop, int fd, int events, void* cb_arg)
+{
+  client_t *client = ( client_t *)(cb_arg);
+  int ret;
+#ifdef DEBUG
+  printf("call w_callback \n");
+#endif
+  if ((events & PICOEV_TIMEOUT) != 0) {
+#ifdef DEBUG
+    printf("** w_callback timeout ** \n");
+#endif
+    //timeout
+    client->keep_alive = 0;
+    close_conn(client, loop);
+  } else if ((events & PICOEV_WRITE) != 0) {
+    ret = process_body(client);
+    picoev_set_timeout(loop, client->fd, WRITE_TIMEOUT_SECS);
+#ifdef DEBUG
+    printf("process_body ret %d \n", ret);
+#endif
+    if(ret != 0){
+      //ok or die
+      close_conn(client, loop);
+    }
+  }
+}
+static inline void
+call_rack_app(client_t *client, picoev_loop* loop)
+{
+  int ret;
+  if(!process_rack_app(client)){
+    //Internal Server Error
+    client->bad_request_code = 500;
+    send_error_page(client);
+    close_conn(client, loop);
+    return;
+  }
+  ret = response_start(client);
+  /* printf("response_start done: %d\n", ret); */
+  switch(ret){
+  case -1:
+    // Internal Server Error
+    client->bad_request_code = 500;
+    send_error_page(client);
+    close_conn(client, loop);
+    return;
+  case 0:
+    // continue
+    // set callback
+#ifdef DEBUG
+    printf("set write callback %d \n", ret);
+#endif
+    picoev_add(loop, client->fd, PICOEV_WRITE, WRITE_TIMEOUT_SECS, w_callback, (void *)client);
+    return;
+  default:
+    // send OK
+    close_conn(client, loop);
+  }
+}
+static inline void
+prepare_call_rack(client_t *client)
+{
+  VALUE input = NULL, object = NULL, c = NULL;
+  char *val;
+  object = rb_str_new2("");
+  input = rb_funcall(StringIO, i_new, 1, object);
+  rb_hash_aset((VALUE)client->environ, rack_input, input);
+  client->body = object;
+  if(is_keep_alive){
+    //support keep-alive
+    c = rb_hash_aref(client->environ, http_connection);
+    if(c){
+      val = StringValuePtr(c);
+      if(!strcasecmp(val, "keep-alive")){
+	client->keep_alive = 1;
+      }else{
+	client->keep_alive = 0;
+      }
+    }else{
+      client->keep_alive = 0;
+    }
+  }
+}
+static void
+r_callback(picoev_loop* loop, int fd, int events, void* cb_arg)
+{
+  client_t *cli = ( client_t *)(cb_arg);
+  if ((events & PICOEV_TIMEOUT) != 0) {
+#ifdef DEBUG
+    printf("** r_callback timeout ** \n");
+#endif
+    //timeout
+    cli->keep_alive = 0;
+    close_conn(cli, loop);
+  } else if ((events & PICOEV_READ) != 0) {
+#ifdef DEBUG
+    printf("ready read \n");
+#endif
+    /* 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:
+      finish = 1;
+      break;
+    case -1: /* error */
+      if (errno == EAGAIN || errno == EWOULDBLOCK) { /* try again later */
+	break;
+      } else { /* fatal error */
+	rb_raise(rb_eException, "fatal error");
+	// TODO:
+	// raise exception from errno
+	/* rb_raise(); */
+	/* write_error_log(__FILE__, __LINE__);  */
+	cli->keep_alive = 0;
+	cli->status_code = 500;
+	close_conn(cli, loop);
+	return;
+      }
+      break;
+    default:
+#ifdef DEBUG
+      printf("read request fd %d bufsize %d \n", cli->fd, r);
+#endif
+      nread = execute_parse(cli, buf, r);
+      if(cli->bad_request_code > 0){
+#ifdef DEBUG
+	printf("fd %d bad_request code %d \n", cli->fd,  cli->bad_request_code);
+#endif
+	send_error_page(cli);
+	close_conn(cli, loop);
+	return;
+      }
+      if( nread != r ){
+	// parse error
+#ifdef DEBUG
+	printf("fd %d parse error %d \n", cli->fd, cli->bad_request_code);
+#endif
+	cli->bad_request_code = 400;
+	send_error_page(cli);
+	close_conn(cli, loop);
+	return;
+      }
+#ifdef DEBUG
+      printf("parse ok, fd %d %d nread \n", cli->fd, nread);
+#endif
+      if(parser_finish(cli) > 0){
+	finish = 1;
+      }
+      break;
+    }
+    if(finish == 1){
+      prepare_call_rack(cli);
+      call_rack_app(cli, loop);
+      return;
+    }
+  }
+}
+// TODO: use accept4 in linux
+static void
+accept_callback(picoev_loop* loop, int fd, int events, void* cb_arg)
+{
+  int client_fd;
+  client_t *client;
+  struct sockaddr_in client_addr;
+  if ((events & PICOEV_TIMEOUT) != 0) {
+    // time out
+    // next turn or other process
+    return;
+  }else if ((events & PICOEV_READ) != 0) {
+    socklen_t client_len = sizeof(client_addr);
+    client_fd = accept(fd, (struct sockaddr *)&client_addr, &client_len);
+    if (client_fd != -1) {
+#ifdef DEBUG
+      printf("accept fd %d \n", client_fd);
+#endif
+      setup_sock(client_fd);
+      client = new_client_t(client_fd, client_addr);
+      client->environ = Qnil;
+      rb_gc_register_address(&client->environ);
+      init_parser(client, server_name, server_port);
+      picoev_add(loop, client_fd, PICOEV_READ, READ_LONG_TIMEOUT_SECS, r_callback, (void *)client);
+    }else{
+      if (errno != EAGAIN && errno != EWOULDBLOCK) {
+	// TODO:
+	// raise exception from errno
+	/* rb_raise(); */
+	/* write_error_log(__FILE__, __LINE__); */
+	// die
+	loop_done = 0;
+      }
+    }
+  }
+}
+static inline void
+setup_server_env(void)
+{
+  setup_sock(listen_sock);
+  cache_time_init();
+  setup_static_env(server_name, server_port);
+}
+static inline int
+inet_listen(void)
+{
+  struct addrinfo hints, *servinfo, *p;
+  int flag = 1;
+  int rv;
+  char strport[7];
+  memset(&hints, 0, sizeof hints);
+  hints.ai_family = AF_UNSPEC;
+  hints.ai_socktype = SOCK_STREAM;
+  hints.ai_flags = AI_PASSIVE;
+  snprintf(strport, sizeof (strport), "%d", server_port);
+  if ((rv = getaddrinfo(server_name, strport, &hints, &servinfo)) == -1) {
+    // TODO:
+    // raise exception from errno
+    /* rb_raise(); */
+    return -1;
+  }
+  // loop through all the results and bind to the first we can
+  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;
+    }
+    if (setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &flag,
+		   sizeof(int)) == -1) {
+      close(listen_sock);
+      // TODO:
+      // raise exception from errno
+      /* rb_raise(); */
+      return -1;
+    }
+    if (bind(listen_sock, p->ai_addr, p->ai_addrlen) == -1) {
+      close(listen_sock);
+      // TODO:
+      // raise exception from errno
+      /* rb_raise(); */
+      return -1;
+    }
+    break;
+  }
+  if (p == NULL)  {
+    close(listen_sock);
+    rb_raise(rb_eIOError, "server: failed to bind\n");
+    return -1;
+  }
+  freeaddrinfo(servinfo); // all done with this structure
+  // BACKLOG 1024
+  if (listen(listen_sock, BACKLOG) == -1) {
+    close(listen_sock);
+    // TODO:
+    // raise exception from errno
+    /* rb_raise(); */
+    return -1;
+  }
+  setup_server_env();
+  return 1;
+}
+static void
+sigint_cb(int signum)
+{
+  loop_done = 0;
+  /* rb_interrupt(); */
+}
+static void
+sigpipe_cb(int signum)
+{
+}
+static VALUE
+bossan_stop(VALUE self)
+{
+  loop_done = 0;
+  return Qnil;
+}
+static VALUE
+bossan_access_log(VALUE self, VALUE args)
+{
+  log_path = StringValuePtr(args);
+  if(log_fd > 0){
+    close(log_fd);
+  }
+  log_fd = open_log_file(log_path);
+  if(log_fd < 0){
+    rb_raise(rb_eTypeError, "not open file. %s", log_path);
+  }
+  return Qnil;
+}
+// Bossan.run('127.0.0.1', 8000) do |env|
+//   ...
+// end
+static VALUE
+bossan_run_loop(VALUE self, VALUE args1, VALUE args2, VALUE args3)
+{
+  int ret;
+  if(listen_sock > 0){
+    rb_raise(rb_eException, "already set listen socket");
+  }
+  server_name = StringValuePtr(args1);
+  server_port = NUM2INT(args2);
+  long _port = NUM2INT(args2);
+  if (_port <= 0 || _port >= 65536) {
+    // out of range
+    rb_raise(rb_eArgError, "port number outside valid range");
+  }
+  server_port = (short)_port;
+  ret = inet_listen();
+  if(ret < 0){
+    //error
+    listen_sock = -1;
+  }
+  rack_app = args3;
+  if(listen_sock <= 0){
+    rb_raise(rb_eTypeError, "not found listen socket");
+  }
+  /* init picoev */
+  picoev_init(MAX_FDS);
+  /* create loop */
+  main_loop = picoev_create_loop(60);
+  loop_done = 1;
+  setsig(SIGPIPE, sigpipe_cb);
+  setsig(SIGINT, sigint_cb);
+  setsig(SIGTERM, sigint_cb);
+  picoev_add(main_loop, listen_sock, PICOEV_READ, ACCEPT_TIMEOUT_SECS, accept_callback, NULL);
+  /* loop */
+  while (loop_done) {
+    picoev_loop_once(main_loop, 10);
+  }
+  picoev_destroy_loop(main_loop);
+  picoev_deinit();
+  printf("Bye.\n");
+  return Qnil;
+}
+VALUE
+bossan_set_max_content_length(VALUE self, VALUE args)
+{
+  max_content_length = NUM2INT(args);
+  return Qnil;
+}
+VALUE
+bossan_get_max_content_length(VALUE self)
+{
+  return INT2NUM(max_content_length);
+}
+void
+Init_bossan_ext(void)
+{
+  rb_gc_register_address(&version_key);
+  rb_gc_register_address(&version_val);
+  rb_gc_register_address(&scheme_key);
+  rb_gc_register_address(&scheme_val);
+  rb_gc_register_address(&errors_key);
+  rb_gc_register_address(&errors_val);
+  rb_gc_register_address(&multithread_key);
+  rb_gc_register_address(&multithread_val);
+  rb_gc_register_address(&multiprocess_key);
+  rb_gc_register_address(&multiprocess_val);
+  rb_gc_register_address(&run_once_key);
+  rb_gc_register_address(&run_once_val);
+  rb_gc_register_address(&script_key);
+  rb_gc_register_address(&script_val);
+  rb_gc_register_address(&server_name_key);
+  rb_gc_register_address(&server_name_val);
+  rb_gc_register_address(&server_port_key);
+  rb_gc_register_address(&server_port_val);
+  rb_gc_register_address(&server_protocol);
+  rb_gc_register_address(&path_info);
+  rb_gc_register_address(&request_uri);
+  rb_gc_register_address(&query_string);
+  rb_gc_register_address(&http_fragment);
+  rb_gc_register_address(&request_method);
+  rb_gc_register_address(&rb_remote_addr);
+  rb_gc_register_address(&rb_remote_port);
+  rb_gc_register_address(&rack_input);
+  rb_gc_register_address(&http_connection);
+  rb_gc_register_address(&http_user_agent);
+  rb_gc_register_address(&i_keys);
+  rb_gc_register_address(&i_call);
+  rb_gc_register_address(&i_new);
+  rb_gc_register_address(&rack_app); //rack app
+  i_new = rb_intern("new");
+  i_call = rb_intern("call");
+  i_keys = rb_intern("keys");
+  server = rb_define_module("Bossan");
+  rb_gc_register_address(&server);
+  rb_define_module_function(server, "run", bossan_run_loop, 3);
+  rb_define_module_function(server, "stop", bossan_stop, 0);
+  rb_define_module_function(server, "access_log", bossan_access_log, 1);
+  rb_define_module_function(server, "set_max_content_length", bossan_set_max_content_length, 1);
+  rb_define_module_function(server, "get_max_content_length", bossan_get_max_content_length, 0);
+  rb_require("stringio");
+  StringIO = rb_const_get(rb_cObject, rb_intern("StringIO"));
+}