aspirin 0.0.0 → 0.0.1

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.0.1

data/ext/aspirin.c

@@ -1,19 +1,4 @@
-#include <ruby.h>
-#ifdef HAVE_RUBY_ST_H
-#include <ruby/st.h>
-#else
-#include <st.h>
-#endif
-#include <signal.h>
-#include <sys/queue.h>
-#include <stdio.h>
-#include <ctype.h>
-
-#include <event.h>
-#include <evhttp.h>
-#include <evutil.h>
-
-#define INSPECT(obj) {VALUE __obj__ = rb_inspect((obj)); fprintf(stderr, "%d:%s\n", __LINE__, RSTRING_PTR(__obj__));}
+#include "aspirin.h"
 
 static VALUE rb_mAspirin;
 static VALUE rb_cAspirin_Server;
@@ -26,79 +11,21 @@ static const char* const status_code_str[] = {
     "Continue","Switching Protocols","Processing","OK","Created","Accepted","Non-Authoritative Information","No Content","Reset Content","Partial Content","Multi-Status","Already Reported","IM Used","Multiple Choices","Moved Permanently","Found","See Other","Not Modified","Use Proxy","","Temporary Redirect","Bad Request","Unauthorized","Payment Required","Forbidden","Not Found","Method Not Allowed","Not Acceptable","Proxy Authentication Required","Request Timeout","Conflict","Gone","Length Required","Precondition Failed","Request Entity Too Large","Request-URI Too Long","Unsupported Media Type","Requested Range Not Satisfiable","Expectation Failed","","","Unprocessable Entity","Locked","Failed Dependency","","Upgrade Required","Internal Server Error","Not Implemented","Bad Gateway","Service Unavailable","Gateway Timeout","HTTP Version Not Supported","Variant Also Negotiates","Insufficient Storage","Loop Detected","Not Extended"
 };
 static VALUE default_env;
-
-typedef struct
-{
-    struct event_base* base;
-    struct evhttp*     http;
-    struct event       signal;
-    VALUE              app;
-    VALUE              options;
-    VALUE              env;
-} Aspirin_Server;
-
-// Aspirin::Server.new
-static VALUE aspirin_server_initialize(VALUE, VALUE, VALUE);
-// Aspirin::Server.start
-static VALUE aspirin_server_start(VALUE);
-// Rack::Handler::Aspirin.run
-static VALUE rack_handler_aspirin_run(int, VALUE*, VALUE);
-
-static VALUE aspirin_server_address(VALUE);
-static int   aspirin_server_port(VALUE);
-
-static VALUE aspirin_server_alloc(VALUE);
-static void  aspirin_server_mark(Aspirin_Server*);
-static void  aspirin_server_free(Aspirin_Server*);
-
-static void  aspirin_server_http_request(struct evhttp_request*, void*);
-static VALUE aspirin_server_create_env(struct evhttp_request*, Aspirin_Server*);
-
-static void  aspirin_server_base_initialize(Aspirin_Server*);
-static void  aspirin_server_signal_initialize(Aspirin_Server*);
-static void  aspirin_server_sigint(int, short, void*);
-static void  aspirin_server_http_initialize(Aspirin_Server*);
-
-static void  set_http_version(VALUE, struct evhttp_request*);
-static void  set_path_info(VALUE, struct evhttp_request*);
-static void  set_response_header(struct evhttp_request*, VALUE);
-static void  set_additional_header(struct evhttp_request*);
-
-static void  init_default_env();
-static VALUE dupe_default_env();
-static void  init_status_code_tbl();
-static char* get_status_code_message(int);
-
-static char* upcase(char*);
-static char* hyphen_to_under(char*);
+static VALUE global_envs[GLOBAL_ENVS_NUM];
 
 static void
 init_default_env()
 {
-    VALUE rack_url_scheme, rack_version, gateway_interface, server_protocol, script_name;
-
-    rack_url_scheme   = rb_str_new2("http");
-    rack_version      = rb_ary_new3(2, INT2FIX(1), INT2FIX(1));
-    gateway_interface = rb_str_new2("CGI/1.2");
-    server_protocol   = rb_str_new2("HTTP/1.1");
-    script_name       = rb_str_new2("");
-
-    OBJ_FREEZE(rack_url_scheme);
-    OBJ_FREEZE(rack_version);
-    OBJ_FREEZE(gateway_interface);
-    OBJ_FREEZE(server_protocol);
-    OBJ_FREEZE(script_name);
-
     default_env = rb_hash_new();
 
     rb_hash_aset(default_env, rb_str_new2("rack.multiprocess"), Qfalse);
     rb_hash_aset(default_env, rb_str_new2("rack.multithread"),  Qfalse);
     rb_hash_aset(default_env, rb_str_new2("rack.run_once"),     Qfalse);
-    rb_hash_aset(default_env, rb_str_new2("rack.url_scheme"),   rack_url_scheme);
-    rb_hash_aset(default_env, rb_str_new2("rack.version"),      rack_version);
-    rb_hash_aset(default_env, rb_str_new2("GATEWAY_INTERFACE"), gateway_interface);
-    rb_hash_aset(default_env, rb_str_new2("SCRIPT_NAME"),       script_name);
-    rb_hash_aset(default_env, rb_str_new2("SERVER_PROTOCOL"),   server_protocol);
+    rb_hash_aset(default_env, rb_str_new2("rack.url_scheme"),   rb_obj_freeze(rb_str_new2("http")));
+    rb_hash_aset(default_env, rb_str_new2("rack.version"),      rb_obj_freeze(rb_ary_new3(2, INT2FIX(1), INT2FIX(1))));
+    rb_hash_aset(default_env, rb_str_new2("GATEWAY_INTERFACE"), rb_obj_freeze(rb_str_new2("CGI/1.2")));
+    rb_hash_aset(default_env, rb_str_new2("SCRIPT_NAME"),       rb_obj_freeze(rb_str_new2("")));
+    rb_hash_aset(default_env, rb_str_new2("SERVER_PROTOCOL"),   rb_obj_freeze(rb_str_new2("HTTP/1.1")));
 }
 
 static VALUE
@@ -107,6 +34,30 @@ dupe_default_env()
     return rb_funcall(default_env, rb_intern("dup"), 0);
 }
 
+static void
+init_global_envs()
+{
+    int i;
+    global_envs[GE_GET           ] = rb_str_new2("GET");
+    global_envs[GE_HEAD          ] = rb_str_new2("HEAD");
+    global_envs[GE_HTTP_VERSION  ] = rb_str_new2("HTTP_VERSION");
+    global_envs[GE_PATH_INFO     ] = rb_str_new2("PATH_INFO");
+    global_envs[GE_POST          ] = rb_str_new2("POST");
+    global_envs[GE_QUERY_STRING  ] = rb_str_new2("QUERY_STRING");
+    global_envs[GE_RACK_ERRORS   ] = rb_str_new2("rack.errors");
+    global_envs[GE_RACK_INPUT    ] = rb_str_new2("rack.input");
+    global_envs[GE_REMOTE_ADDR   ] = rb_str_new2("REMOTE_ADDR");
+    global_envs[GE_REQUEST_METHOD] = rb_str_new2("REQUEST_METHOD");
+    global_envs[GE_REQUEST_PATH  ] = rb_str_new2("REQUEST_PATH");
+    global_envs[GE_REQUEST_URI   ] = rb_str_new2("REQUEST_URI");
+    global_envs[GE_SERVER_NAME   ] = rb_str_new2("SERVER_NAME");
+    global_envs[GE_SERVER_PORT   ] = rb_str_new2("SERVER_PORT");
+    for(i=0; i<GLOBAL_ENVS_NUM; i++)
+    {
+        global_envs[i] = rb_obj_freeze(global_envs[i]);
+    }
+}
+
 static void
 init_status_code_tbl()
 {
@@ -131,7 +82,7 @@ set_http_version(VALUE env, struct evhttp_request *req)
 {
     char  buf[8 + 1]; // HTTP/x.y
     snprintf(buf, 9, "HTTP/%d.%d", req->major, req->minor);
-    rb_hash_aset(env, rb_str_new2("HTTP_VERSION"), rb_str_new2(buf));
+    rb_hash_aset(env, global_envs[GE_HTTP_VERSION], rb_obj_freeze(rb_str_new2(buf)));
 }
 
 static void
@@ -157,12 +108,12 @@ set_path_info(VALUE env, struct evhttp_request *req)
     request_uri  = rb_str_new2(buf);
     query_string = rb_str_new2(query);
 
-    OBJ_FREEZE(request_uri);
-    OBJ_FREEZE(query_string);
+    rb_obj_freeze(request_uri);
+    rb_obj_freeze(query_string);
 
-    rb_hash_aset(env, rb_str_new2("PATH_INFO"), request_uri);
-    rb_hash_aset(env, rb_str_new2("REQUEST_PATH"), request_uri);
-    rb_hash_aset(env, rb_str_new2("QUERY_STRING"), query_string);
+    rb_hash_aset(env, global_envs[GE_PATH_INFO],    request_uri);
+    rb_hash_aset(env, global_envs[GE_REQUEST_PATH], request_uri);
+    rb_hash_aset(env, global_envs[GE_QUERY_STRING], query_string);
 
     xfree(buf);
 }
@@ -173,7 +124,6 @@ set_http_header(VALUE env, struct evhttp_request *req)
     char  *buf;
     size_t len;
     struct evkeyval *header;
-    VALUE key, val;
 
     TAILQ_FOREACH(header, req->input_headers, next)
     {
@@ -187,10 +137,7 @@ set_http_header(VALUE env, struct evhttp_request *req)
             buf[len + 5] = '\0';
             hyphen_to_under(upcase(buf));
 
-            key = rb_str_new2(buf);
-            val = rb_str_new2(header->value);
-            OBJ_FREEZE(val);
-            rb_hash_aset(env, key, val);
+            rb_hash_aset(env, rb_str_new2(buf), rb_obj_freeze(rb_str_new2(header->value)));
 
             xfree(buf);
         }
@@ -200,37 +147,36 @@ set_http_header(VALUE env, struct evhttp_request *req)
 static VALUE
 aspirin_server_create_env(struct evhttp_request *req, Aspirin_Server *srv)
 {
-    VALUE env, rack_input, strio, remote_host, request_uri, method;
+    VALUE env, rack_input, strio, remote_host, request_uri;
 
     env = rb_funcall(srv->env, rb_intern("dup"), 0);
 
-    rb_hash_aset(env, rb_str_new2("rack.errors"), rb_gv_get("$stderr"));
+    rb_hash_aset(env, global_envs[GE_RACK_ERRORS], rb_gv_get("$stderr"));
 
     rack_input = rb_str_new((const char*)EVBUFFER_DATA(req->input_buffer),
                             EVBUFFER_LENGTH(req->input_buffer));
-    OBJ_FREEZE(rack_input);
+    rb_obj_freeze(rack_input);
     strio = rb_funcall(rb_cStringIO, rb_intern("new"), 1, rack_input);
-    rb_hash_aset(env, rb_str_new2("rack.input"), strio);
+    rb_hash_aset(env, global_envs[GE_RACK_INPUT], strio);
 
-    remote_host = rb_str_new2(req->remote_host);
-    OBJ_FREEZE(remote_host);
-    rb_hash_aset(env, rb_str_new2("REMOTE_ADDR"), remote_host);
+    rb_hash_aset(env,
+                 global_envs[GE_REMOTE_ADDR],
+                 rb_obj_freeze(rb_str_new2(req->remote_host)));
 
-    request_uri = rb_str_new2(evhttp_request_uri(req));
-    OBJ_FREEZE(request_uri);
-    rb_hash_aset(env, rb_str_new2("REQUEST_URI"), request_uri);
+    rb_hash_aset(env,
+                 global_envs[GE_REQUEST_URI],
+                 rb_obj_freeze(rb_str_new2(evhttp_request_uri(req))));
 
-    method = rb_str_new2("REQUEST_METHOD");
     switch(req->type)
     {
     case EVHTTP_REQ_GET:
-        rb_hash_aset(env, method, rb_str_new2("GET"));
+        rb_hash_aset(env, global_envs[GE_REQUEST_METHOD], global_envs[GE_GET]);
         break;
     case EVHTTP_REQ_POST:
-        rb_hash_aset(env, method, rb_str_new2("POST"));
+        rb_hash_aset(env, global_envs[GE_REQUEST_METHOD], global_envs[GE_POST]);
         break;
     case EVHTTP_REQ_HEAD:
-        rb_hash_aset(env, method, rb_str_new2("HEAD"));
+        rb_hash_aset(env, global_envs[GE_REQUEST_METHOD], global_envs[GE_HEAD]);
         break;
     }
 
@@ -271,13 +217,39 @@ set_additional_header(struct evhttp_request *req)
     evhttp_add_header(req->output_headers, "Connection", "close");
 }
 
+static VALUE
+body_concat(VALUE chunk, VALUE* buff)
+{
+    struct evbuffer *buf = DATA_PTR(*buff);
+    StringValue(chunk);
+    evbuffer_add(buf, RSTRING_PTR(chunk), RSTRING_LEN(chunk));
+    return Qnil;
+}
+
+static VALUE
+body_each(VALUE body)
+{
+    VALUE data = rb_ary_entry(body, 1);
+    rb_iterate(rb_each, rb_ary_entry(body, 0), body_concat, (VALUE)&data);
+    return Qnil;
+}
+
+static VALUE
+body_close(VALUE body)
+{
+    if(rb_respond_to(body, rb_intern("close")))
+    {
+        rb_funcall(body, rb_intern("close"), 0);
+    }
+    return Qnil;
+}
+
 static void
 aspirin_server_http_request(struct evhttp_request *req, void *arg)
 {
-    static VALUE args[][1] = {{INT2FIX(0)},{INT2FIX(1)},{INT2FIX(2)}};
     struct evbuffer *buf;
     Aspirin_Server  *srv;
-    VALUE env, result, bodies;
+    VALUE env, result, body, buff;
     int   status_code;
     char *status_code_msg;
 
@@ -285,22 +257,25 @@ aspirin_server_http_request(struct evhttp_request *req, void *arg)
     env = aspirin_server_create_env(req, srv);
     result = rb_funcall(srv->app, rb_intern("call"), 1, env);
 
-    status_code = NUM2INT(rb_ary_aref(1, args[0], result));
+    status_code = NUM2INT(rb_ary_entry(result, 0));
     status_code_msg = get_status_code_message(status_code);
     if(status_code_msg == NULL)
     {
         status_code_msg = "";
     }
 
-    set_response_header(req, rb_ary_aref(1, args[1], result));
+    set_response_header(req, rb_ary_entry(result, 1));
     set_additional_header(req);
 
-    bodies = rb_funcall(rb_ary_aref(1, args[2], result), rb_intern("to_s"), 0);
+    buff = Data_Wrap_Struct(rb_cData, 0, 0, 0);
+    DATA_PTR(buff) = req->output_buffer;
+
+    body = rb_ary_new3(2, rb_ary_entry(result, 2), buff);
+
+    rb_ensure(body_each, body, body_close, rb_ary_entry(result, 2));
+    evhttp_send_reply(req, status_code, status_code_msg, NULL);
 
-    buf = evbuffer_new();
-    evbuffer_add(buf, RSTRING_PTR(bodies), RSTRING_LEN(bodies));
-    evhttp_send_reply(req, status_code, status_code_msg, buf);
-    evbuffer_free(buf);
+    DATA_PTR(buff) = NULL;
 }
 
 static Aspirin_Server*
@@ -368,7 +343,9 @@ aspirin_server_free(Aspirin_Server* srv)
         return;
     }
 
-    event_del(&srv->signal);
+    event_del(&srv->sig_int);
+    event_del(&srv->sig_quit);
+    event_del(&srv->sig_term);
 
     if(srv->http)
     {
@@ -393,11 +370,18 @@ aspirin_server_alloc(VALUE klass)
 }
 
 static void
-aspirin_server_sigint(int fd, short event, void *arg)
+aspirin_server_stop_bang(int fd, short event, void *arg)
+{
+    Aspirin_Server *srv = arg;
+    event_base_loopbreak(srv->base);
+}
+
+static void
+aspirin_server_stop(int fd, short event, void *arg)
 {
     Aspirin_Server *srv = arg;
     struct timeval delay = {1, 0};
-    event_del(&srv->signal);
+    event_del(&srv->sig_quit);
     event_base_loopexit(srv->base, &delay);
 }
 
@@ -407,61 +391,21 @@ aspirin_server_port(VALUE options)
     VALUE port = Qnil;
     if(TYPE(options) == T_HASH)
     {
-        port = rb_hash_aref(options, ID2SYM(rb_intern("port")));
-        if(!NIL_P(port)){
-            return NUM2INT(port);
-        }
-        port = rb_hash_aref(options, rb_str_new2("port"));
-        if(!NIL_P(port)){
-            return NUM2INT(port);
-        }
         port = rb_hash_aref(options, ID2SYM(rb_intern("Port")));
         if(!NIL_P(port)){
             return NUM2INT(port);
         }
-        port = rb_hash_aref(options, rb_str_new2("Port"));
-        if(!NIL_P(port)){
-            return NUM2INT(port);
-        }
-        port = rb_hash_aref(options, ID2SYM(rb_intern("PORT")));
-        if(!NIL_P(port)){
-            return NUM2INT(port);
-        }
-        port = rb_hash_aref(options, rb_str_new2("PORT"));
-        if(!NIL_P(port)){
-            return NUM2INT(port);
-        }
     }
     return 9292;
 }
 
 static VALUE
-aspirin_server_address(VALUE options)
+aspirin_server_host(VALUE options)
 {
     VALUE address = Qnil;
     if(TYPE(options) == T_HASH)
     {
-        address = rb_hash_aref(options, ID2SYM(rb_intern("address")));
-        if(!NIL_P(address)){
-            return address;
-        }
-        address = rb_hash_aref(options, rb_str_new2("address"));
-        if(!NIL_P(address)){
-            return address;
-        }
-        address = rb_hash_aref(options, ID2SYM(rb_intern("Address")));
-        if(!NIL_P(address)){
-            return address;
-        }
-        address = rb_hash_aref(options, rb_str_new2("Address"));
-        if(!NIL_P(address)){
-            return address;
-        }
-        address = rb_hash_aref(options, ID2SYM(rb_intern("ADDRESS")));
-        if(!NIL_P(address)){
-            return address;
-        }
-        address = rb_hash_aref(options, rb_str_new2("ADDRESS"));
+        address = rb_hash_aref(options, ID2SYM(rb_intern("Host")));
         if(!NIL_P(address)){
             return address;
         }
@@ -478,26 +422,34 @@ aspirin_server_base_initialize(Aspirin_Server *srv)
 static void
 aspirin_server_signal_initialize(Aspirin_Server *srv)
 {
-    event_set(&srv->signal, SIGINT, EV_SIGNAL|EV_PERSIST, aspirin_server_sigint, srv);
-    event_base_set(srv->base, &srv->signal);
-    event_add(&srv->signal, NULL);
+    event_set(&srv->sig_quit, SIGQUIT, EV_SIGNAL|EV_PERSIST, aspirin_server_stop, srv);
+    event_base_set(srv->base, &srv->sig_quit);
+    event_add(&srv->sig_quit, NULL);
+
+    event_set(&srv->sig_int,  SIGINT, EV_SIGNAL|EV_PERSIST, aspirin_server_stop_bang, srv);
+    event_base_set(srv->base, &srv->sig_int);
+    event_add(&srv->sig_int, NULL);
+
+    event_set(&srv->sig_term, SIGTERM, EV_SIGNAL|EV_PERSIST, aspirin_server_stop_bang, srv);
+    event_base_set(srv->base, &srv->sig_term);
+    event_add(&srv->sig_term, NULL);
 }
 
 static void
 aspirin_server_http_initialize(Aspirin_Server *srv)
 {
-    VALUE addr = aspirin_server_address(srv->options);
+    VALUE host = aspirin_server_host(srv->options);
     int   port = aspirin_server_port(srv->options);
 
-    StringValue(addr);
-    rb_hash_aset(srv->env, rb_str_new2("SERVER_NAME"), addr);
+    StringValue(host);
+    rb_hash_aset(srv->env, global_envs[GE_SERVER_NAME], host);
 
     char port_str[6];
     snprintf(port_str, 5, "%d", port);
-    rb_hash_aset(srv->env, rb_str_new2("SERVER_PORT"), rb_str_new2(port_str));
+    rb_hash_aset(srv->env, global_envs[GE_SERVER_PORT], rb_str_new2(port_str));
 
     srv->http = evhttp_new(srv->base);
-    evhttp_bind_socket(srv->http, RSTRING_PTR(addr), port);
+    evhttp_bind_socket(srv->http, RSTRING_PTR(host), port);
     evhttp_set_gencb(srv->http, aspirin_server_http_request, srv);
 }
 
@@ -505,10 +457,10 @@ static char*
 upcase(char* str)
 {
     if(str){
-        int i, n=strlen(str);
-        for(i=0; i<n; i++)
+        char* tmp;
+        for(tmp=str; *tmp; tmp++)
         {
-            str[i] = toupper(str[i]);
+            *tmp = toupper(*tmp);
         }
     }
     return str;
@@ -518,12 +470,12 @@ static char*
 hyphen_to_under(char* str)
 {
     if(str){
-        int i, n=strlen(str);
-        for(i=0; i<n; i++)
+        char* tmp;
+        for(tmp=str; *tmp; tmp++)
         {
-            if(str[i] == '-')
+            if(*tmp == '-')
             {
-                str[i] = '_';
+                *tmp = '_';
             }
         }
     }
@@ -544,8 +496,11 @@ rack_handler_aspirin_run(int argc, VALUE *argv, VALUE obj)
 
 void Init_aspirin(void)
 {
+    VALUE rb_mRack, rb_mRack_Handler, rb_mRack_Handler_Aspirin;
+
     init_default_env();
     init_status_code_tbl();
+    init_global_envs();
 
     rb_require("stringio");
     rb_cStringIO = rb_const_get(rb_cObject, rb_intern("StringIO"));
@@ -559,8 +514,8 @@ void Init_aspirin(void)
     rb_define_method(rb_cAspirin_Server, "start", aspirin_server_start, 0);
 
     // Rack::Handler::Aspirin
-    VALUE rb_mRack = rb_define_module("Rack");
-    VALUE rb_mRack_Handler = rb_define_module_under(rb_mRack, "Handler");
-    VALUE rb_mRack_Handler_Aspirin = rb_define_module_under(rb_mRack_Handler, "Aspirin");
+    rb_mRack = rb_define_module("Rack");
+    rb_mRack_Handler = rb_define_module_under(rb_mRack, "Handler");
+    rb_mRack_Handler_Aspirin = rb_define_module_under(rb_mRack_Handler, "Aspirin");
     rb_define_singleton_method(rb_mRack_Handler_Aspirin, "run", rack_handler_aspirin_run, -1);
 }

data/ext/aspirin.h

@@ -0,0 +1,87 @@
+#ifndef __ASPIRIN_H__
+#define __ASPIRIN_H__
+
+#include <ruby.h>
+#ifdef HAVE_RUBY_ST_H
+#include <ruby/st.h>
+#else
+#include <st.h>
+#endif
+
+#include <ctype.h>
+#include <signal.h>
+#include <stdio.h>
+#include <sys/queue.h>
+
+#include <event.h>
+#include <evhttp.h>
+#include <evutil.h>
+
+#define INSPECT(obj) {VALUE __obj__ = rb_inspect((obj)); fprintf(stderr, "%d:%s\n", __LINE__, RSTRING_PTR(__obj__));}
+
+enum{
+    GE_GET,
+    GE_HEAD,
+    GE_HTTP_VERSION,
+    GE_PATH_INFO,
+    GE_POST,
+    GE_QUERY_STRING,
+    GE_RACK_ERRORS,
+    GE_RACK_INPUT,
+    GE_REMOTE_ADDR,
+    GE_REQUEST_METHOD,
+    GE_REQUEST_PATH,
+    GE_REQUEST_URI,
+    GE_SERVER_NAME,
+    GE_SERVER_PORT,
+    GLOBAL_ENVS_NUM,
+};
+
+typedef struct
+{
+    struct event_base* base;
+    struct evhttp*     http;
+    struct event       sig_int;
+    struct event       sig_quit;
+    struct event       sig_term;
+    VALUE              app;
+    VALUE              options;
+    VALUE              env;
+} Aspirin_Server;
+
+// Aspirin::Server.new
+static VALUE aspirin_server_initialize(VALUE, VALUE, VALUE);
+// Aspirin::Server#start
+static VALUE aspirin_server_start(VALUE);
+// Rack::Handler::Aspirin.run
+static VALUE rack_handler_aspirin_run(int, VALUE*, VALUE);
+
+static VALUE aspirin_server_address(VALUE);
+static int   aspirin_server_port(VALUE);
+
+static VALUE aspirin_server_alloc(VALUE);
+static void  aspirin_server_mark(Aspirin_Server*);
+static void  aspirin_server_free(Aspirin_Server*);
+
+static void  aspirin_server_http_request(struct evhttp_request*, void*);
+static VALUE aspirin_server_create_env(struct evhttp_request*, Aspirin_Server*);
+
+static void  aspirin_server_base_initialize(Aspirin_Server*);
+static void  aspirin_server_signal_initialize(Aspirin_Server*);
+static void  aspirin_server_stop(int, short, void*);
+static void  aspirin_server_stop_bang(int, short, void*);
+static void  aspirin_server_http_initialize(Aspirin_Server*);
+
+static void  set_http_version(VALUE, struct evhttp_request*);
+static void  set_path_info(VALUE, struct evhttp_request*);
+static void  set_response_header(struct evhttp_request*, VALUE);
+static void  set_additional_header(struct evhttp_request*);
+
+static void  init_default_env();
+static VALUE dupe_default_env();
+static void  init_status_code_tbl();
+static char* get_status_code_message(int);
+
+static char* upcase(char*);
+static char* hyphen_to_under(char*);
+#endif

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 0
-  version: 0.0.0
+  - 1
+  version: 0.0.1
 platform: ruby
 authors: 
 - fistfvck
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-29 00:00:00 +09:00
+date: 2010-06-30 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -51,6 +51,7 @@ files:
 - example/test.rb
 - example/thn.rb
 - ext/aspirin.c
+- ext/aspirin.h
 - ext/extconf.rb
 - spec/aspirin_spec.rb
 - spec/spec.opts