racer 0.1.3

data/ext/racer/http_parser.h

@@ -0,0 +1,318 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * 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.
+ */
+#ifndef http_parser_h
+#define http_parser_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define HTTP_PARSER_VERSION_MAJOR 1
+#define HTTP_PARSER_VERSION_MINOR 0
+
+#include <sys/types.h>
+#if defined(_WIN32) && !defined(__MINGW32__) && (!defined(_MSC_VER) || _MSC_VER<1600)
+typedef __int8 int8_t;
+typedef unsigned __int8 uint8_t;
+typedef __int16 int16_t;
+typedef unsigned __int16 uint16_t;
+typedef __int32 int32_t;
+typedef unsigned __int32 uint32_t;
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+
+typedef unsigned int size_t;
+typedef int ssize_t;
+#else
+#include <stdint.h>
+#endif
+
+/* Compile with -DHTTP_PARSER_STRICT=0 to make less checks, but run
+ * faster
+ */
+#ifndef HTTP_PARSER_STRICT
+# define HTTP_PARSER_STRICT 1
+#endif
+
+/* Compile with -DHTTP_PARSER_DEBUG=1 to add extra debugging information to
+ * the error reporting facility.
+ */
+#ifndef HTTP_PARSER_DEBUG
+# define HTTP_PARSER_DEBUG 0
+#endif
+
+
+/* Maximium header size allowed */
+#define HTTP_MAX_HEADER_SIZE (80*1024)
+
+
+typedef struct http_parser http_parser;
+typedef struct http_parser_settings http_parser_settings;
+
+
+/* Callbacks should return non-zero to indicate an error. The parser will
+ * then halt execution.
+ *
+ * The one exception is on_headers_complete. In a HTTP_RESPONSE parser
+ * returning '1' from on_headers_complete will tell the parser that it
+ * should not expect a body. This is used when receiving a response to a
+ * HEAD request which may contain 'Content-Length' or 'Transfer-Encoding:
+ * chunked' headers that indicate the presence of a body.
+ *
+ * http_data_cb does not return data chunks. It will be call arbitrarally
+ * many times for each string. E.G. you might get 10 callbacks for "on_path"
+ * each providing just a few characters more data.
+ */
+typedef int (*http_data_cb) (http_parser*, const char *at, size_t length);
+typedef int (*http_cb) (http_parser*);
+
+
+/* Request Methods */
+#define HTTP_METHOD_MAP(XX)         \
+  XX(0,  DELETE,      DELETE)       \
+  XX(1,  GET,         GET)          \
+  XX(2,  HEAD,        HEAD)         \
+  XX(3,  POST,        POST)         \
+  XX(4,  PUT,         PUT)          \
+  /* pathological */                \
+  XX(5,  CONNECT,     CONNECT)      \
+  XX(6,  OPTIONS,     OPTIONS)      \
+  XX(7,  TRACE,       TRACE)        \
+  /* webdav */                      \
+  XX(8,  COPY,        COPY)         \
+  XX(9,  LOCK,        LOCK)         \
+  XX(10, MKCOL,       MKCOL)        \
+  XX(11, MOVE,        MOVE)         \
+  XX(12, PROPFIND,    PROPFIND)     \
+  XX(13, PROPPATCH,   PROPPATCH)    \
+  XX(14, SEARCH,      SEARCH)       \
+  XX(15, UNLOCK,      UNLOCK)       \
+  /* subversion */                  \
+  XX(16, REPORT,      REPORT)       \
+  XX(17, MKACTIVITY,  MKACTIVITY)   \
+  XX(18, CHECKOUT,    CHECKOUT)     \
+  XX(19, MERGE,       MERGE)        \
+  /* upnp */                        \
+  XX(20, MSEARCH,     M-SEARCH)     \
+  XX(21, NOTIFY,      NOTIFY)       \
+  XX(22, SUBSCRIBE,   SUBSCRIBE)    \
+  XX(23, UNSUBSCRIBE, UNSUBSCRIBE)  \
+  /* RFC-5789 */                    \
+  XX(24, PATCH,       PATCH)        \
+  XX(25, PURGE,       PURGE)        \
+
+enum http_method
+  {
+#define XX(num, name, string) HTTP_##name = num,
+  HTTP_METHOD_MAP(XX)
+#undef XX
+  };
+
+
+enum http_parser_type { HTTP_REQUEST, HTTP_RESPONSE, HTTP_BOTH };
+
+
+/* Flag values for http_parser.flags field */
+enum flags
+  { F_CHUNKED               = 1 << 0
+  , F_CONNECTION_KEEP_ALIVE = 1 << 1
+  , F_CONNECTION_CLOSE      = 1 << 2
+  , F_TRAILING              = 1 << 3
+  , F_UPGRADE               = 1 << 4
+  , F_SKIPBODY              = 1 << 5
+  };
+
+
+/* Map for errno-related constants
+ * 
+ * The provided argument should be a macro that takes 2 arguments.
+ */
+#define HTTP_ERRNO_MAP(XX)                                           \
+  /* No error */                                                     \
+  XX(OK, "success")                                                  \
+                                                                     \
+  /* Callback-related errors */                                      \
+  XX(CB_message_begin, "the on_message_begin callback failed")       \
+  XX(CB_url, "the on_url callback failed")                           \
+  XX(CB_header_field, "the on_header_field callback failed")         \
+  XX(CB_header_value, "the on_header_value callback failed")         \
+  XX(CB_headers_complete, "the on_headers_complete callback failed") \
+  XX(CB_body, "the on_body callback failed")                         \
+  XX(CB_message_complete, "the on_message_complete callback failed") \
+                                                                     \
+  /* Parsing-related errors */                                       \
+  XX(INVALID_EOF_STATE, "stream ended at an unexpected time")        \
+  XX(HEADER_OVERFLOW,                                                \
+     "too many header bytes seen; overflow detected")                \
+  XX(CLOSED_CONNECTION,                                              \
+     "data received after completed connection: close message")      \
+  XX(INVALID_VERSION, "invalid HTTP version")                        \
+  XX(INVALID_STATUS, "invalid HTTP status code")                     \
+  XX(INVALID_METHOD, "invalid HTTP method")                          \
+  XX(INVALID_URL, "invalid URL")                                     \
+  XX(INVALID_HOST, "invalid host")                                   \
+  XX(INVALID_PORT, "invalid port")                                   \
+  XX(INVALID_PATH, "invalid path")                                   \
+  XX(INVALID_QUERY_STRING, "invalid query string")                   \
+  XX(INVALID_FRAGMENT, "invalid fragment")                           \
+  XX(LF_EXPECTED, "LF character expected")                           \
+  XX(INVALID_HEADER_TOKEN, "invalid character in header")            \
+  XX(INVALID_CONTENT_LENGTH,                                         \
+     "invalid character in content-length header")                   \
+  XX(INVALID_CHUNK_SIZE,                                             \
+     "invalid character in chunk size header")                       \
+  XX(INVALID_CONSTANT, "invalid constant string")                    \
+  XX(INVALID_INTERNAL_STATE, "encountered unexpected internal state")\
+  XX(STRICT, "strict mode assertion failed")                         \
+  XX(PAUSED, "parser is paused")                                     \
+  XX(UNKNOWN, "an unknown error occurred")
+
+
+/* Define HPE_* values for each errno value above */
+#define HTTP_ERRNO_GEN(n, s) HPE_##n,
+enum http_errno {
+  HTTP_ERRNO_MAP(HTTP_ERRNO_GEN)
+};
+#undef HTTP_ERRNO_GEN
+
+
+/* Get an http_errno value from an http_parser */
+#define HTTP_PARSER_ERRNO(p)            ((enum http_errno) (p)->http_errno)
+
+/* Get the line number that generated the current error */
+#if HTTP_PARSER_DEBUG
+#define HTTP_PARSER_ERRNO_LINE(p)       ((p)->error_lineno)
+#else
+#define HTTP_PARSER_ERRNO_LINE(p)       0
+#endif
+
+
+struct http_parser {
+  /** PRIVATE **/
+  unsigned char type : 2;     /* enum http_parser_type */
+  unsigned char flags : 6;    /* F_* values from 'flags' enum; semi-public */
+  unsigned char state;        /* enum state from http_parser.c */
+  unsigned char header_state; /* enum header_state from http_parser.c */
+  unsigned char index;        /* index into current matcher */
+
+  uint32_t nread;          /* # bytes read in various scenarios */
+  uint64_t content_length; /* # bytes in body (0 if no Content-Length header) */
+
+  /** READ-ONLY **/
+  unsigned short http_major;
+  unsigned short http_minor;
+  unsigned short status_code; /* responses only */
+  unsigned char method;       /* requests only */
+  unsigned char http_errno : 7;
+
+  /* 1 = Upgrade header was present and the parser has exited because of that.
+   * 0 = No upgrade header present.
+   * Should be checked when http_parser_execute() returns in addition to
+   * error checking.
+   */
+  unsigned char upgrade : 1;
+
+#if HTTP_PARSER_DEBUG
+  uint32_t error_lineno;
+#endif
+
+  /** PUBLIC **/
+  void *data; /* A pointer to get hook to the "connection" or "socket" object */
+};
+
+
+struct http_parser_settings {
+  http_cb      on_message_begin;
+  http_data_cb on_url;
+  http_data_cb on_header_field;
+  http_data_cb on_header_value;
+  http_cb      on_headers_complete;
+  http_data_cb on_body;
+  http_cb      on_message_complete;
+};
+
+
+enum http_parser_url_fields
+  { UF_SCHEMA           = 0
+  , UF_HOST             = 1
+  , UF_PORT             = 2
+  , UF_PATH             = 3
+  , UF_QUERY            = 4
+  , UF_FRAGMENT         = 5
+  , UF_MAX              = 6
+  };
+
+
+/* Result structure for http_parser_parse_url().
+ *
+ * Callers should index into field_data[] with UF_* values iff field_set
+ * has the relevant (1 << UF_*) bit set. As a courtesy to clients (and
+ * because we probably have padding left over), we convert any port to
+ * a uint16_t.
+ */
+struct http_parser_url {
+  uint16_t field_set;           /* Bitmask of (1 << UF_*) values */
+  uint16_t port;                /* Converted UF_PORT string */
+
+  struct {
+    uint16_t off;               /* Offset into buffer in which field starts */
+    uint16_t len;               /* Length of run in buffer */
+  } field_data[UF_MAX];
+};
+
+
+void http_parser_init(http_parser *parser, enum http_parser_type type);
+
+
+size_t http_parser_execute(http_parser *parser,
+                           const http_parser_settings *settings,
+                           const char *data,
+                           size_t len);
+
+
+/* If http_should_keep_alive() in the on_headers_complete or
+ * on_message_complete callback returns true, then this will be should be
+ * the last message on the connection.
+ * If you are the server, respond with the "Connection: close" header.
+ * If you are the client, close the connection.
+ */
+int http_should_keep_alive(http_parser *parser);
+
+/* Returns a string version of the HTTP method. */
+const char *http_method_str(enum http_method m);
+
+/* Return a string name of the given error */
+const char *http_errno_name(enum http_errno err);
+
+/* Return a string description of the given error */
+const char *http_errno_description(enum http_errno err);
+
+/* Parse a URL; return nonzero on failure */
+int http_parser_parse_url(const char *buf, size_t buflen,
+                          int is_connect,
+                          struct http_parser_url *u);
+
+/* Pause or un-pause the parser; a nonzero value pauses */
+void http_parser_pause(http_parser *parser, int paused);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/ext/racer/mkmf.log

@@ -0,0 +1,22 @@
+have_library: checking for main() in -luv... -------------------- yes
+
+"clang -o conftest -I/Users/charlie/.rvm/rubies/ruby-1.9.3-p194/include/ruby-1.9.1/x86_64-darwin11.4.0 -I/Users/charlie/.rvm/rubies/ruby-1.9.3-p194/include/ruby-1.9.1/ruby/backward -I/Users/charlie/.rvm/rubies/ruby-1.9.3-p194/include/ruby-1.9.1 -I. -I/Users/charlie/code/ricer/ext/libuv/include -I/Users/charlie/.rvm/usr/include -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE    -O3 -g3 -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Wpointer-arith -Wwrite-strings -Wdeclaration-after-statement -Wshorten-64-to-32 -Wimplicit-function-declaration  -fno-common -pipe -std=c99 -fPIC conftest.c  -L. -L/Users/charlie/.rvm/rubies/ruby-1.9.3-p194/lib -L/Users/charlie/code/ricer/ext/ricer -L/Users/charlie/.rvm/usr/lib -L.      -lruby.1.9.1  -lpthread -ldl -lobjc "
+checked program was:
+/* begin */
+1: #include "ruby.h"
+2: 
+3: int main() {return 0;}
+/* end */
+
+"clang -o conftest -I/Users/charlie/.rvm/rubies/ruby-1.9.3-p194/include/ruby-1.9.1/x86_64-darwin11.4.0 -I/Users/charlie/.rvm/rubies/ruby-1.9.3-p194/include/ruby-1.9.1/ruby/backward -I/Users/charlie/.rvm/rubies/ruby-1.9.3-p194/include/ruby-1.9.1 -I. -I/Users/charlie/code/ricer/ext/libuv/include -I/Users/charlie/.rvm/usr/include -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE    -O3 -g3 -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Wpointer-arith -Wwrite-strings -Wdeclaration-after-statement -Wshorten-64-to-32 -Wimplicit-function-declaration  -fno-common -pipe -std=c99 -fPIC conftest.c  -L. -L/Users/charlie/.rvm/rubies/ruby-1.9.3-p194/lib -L/Users/charlie/code/ricer/ext/ricer -L/Users/charlie/.rvm/usr/lib -L.      -lruby.1.9.1 -luv  -lpthread -ldl -lobjc "
+checked program was:
+/* begin */
+1: #include "ruby.h"
+2: 
+3: /*top*/
+4: int main() {return 0;}
+5: int t() { void ((*volatile p)()); p = (void ((*)()))main; return 0; }
+/* end */
+
+--------------------
+

data/ext/racer/racer.c

@@ -0,0 +1,551 @@
+#include <ruby.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <uv.h>
+#include <arpa/inet.h>
+#include "http_parser.h"
+
+#define SERVER_SOFTWARE "Racer"
+#define MAX_HEADER_SIZE 4096
+
+typedef enum last_callback {
+    CB_URL,
+    CB_HEADER_FIELD,
+    CB_HEADER_VALUE,
+    CB_BODY,
+    CB_COMPLETE
+} last_callback_t;
+
+typedef struct client {
+    uv_stream_t socket;
+    http_parser_settings parser_settings;
+    http_parser parser;
+    last_callback_t last_callback;
+    size_t total_header_size;
+    char* url;
+    size_t url_len;
+    char* header_field;
+    size_t header_field_len;
+    char* header_value;
+    size_t header_value_len;
+    VALUE body;
+    bool shutdown;
+    bool sent_server_header;
+    VALUE env;
+} client_t;
+
+static VALUE globals;
+
+static VALUE Racer;
+static VALUE RacerStats;
+static ID i_new;
+static ID i_call;
+static ID i_to_i;
+static ID i_each;
+static ID i_close;
+static uint16_t port;
+static VALUE app = Qnil;
+static uv_loop_t* loop;
+static size_t total_requests;
+
+static VALUE StringIO;
+
+static VALUE sREQUEST_METHOD;
+static VALUE sREQUEST_PATH;
+static VALUE sREQUEST_URI;
+static VALUE sSCRIPT_NAME;
+static VALUE sPATH_INFO;
+static VALUE sQUERY_STRING;
+static VALUE sSERVER_NAME;
+static VALUE sSERVER_SOFTWARE;
+static VALUE sSERVER_PORT;
+static VALUE sREQUEST_PATH;
+static VALUE sRacer;
+static VALUE s_empty;
+static VALUE s_crlf;
+static VALUE s_colon_space;
+
+static VALUE sRackInput;
+static VALUE sRackErrors;
+static VALUE sRackVersion;
+static VALUE RACK_VERSION;
+static VALUE sRackMultithread;
+static VALUE sRackMultiprocess;
+static VALUE sRackRunOnce;
+static VALUE sRackUrlScheme;
+static VALUE HTTP_URL_SCHEME;
+
+static uv_buf_t uv_racer_alloc(uv_handle_t* handle, size_t suggested_size)
+{
+    return uv_buf_init((char*)malloc(suggested_size), (uint32_t)suggested_size);
+}
+
+static void uv_racer_free(uv_buf_t buff)
+{
+    free(buff.base);
+}
+
+static void on_close(uv_handle_t* stream)
+{
+    client_t* client = (client_t*)stream->data;
+    if(client->url) {
+        free(client->url);
+    }
+    if(client->header_field) {
+        free(client->header_field);
+    }
+    if(client->header_value) {
+        free(client->header_value);
+    }
+    rb_gc_unregister_address(&client->body);
+    rb_gc_unregister_address(&client->env);
+    free(client);
+}
+
+static void on_shutdown(uv_shutdown_t* req, int status)
+{
+    free(req);
+    uv_close((uv_handle_t*)req->handle, on_close);
+}
+
+static int on_http_url(http_parser* parser, const char* buff, size_t length)
+{
+    client_t* client = (client_t*)parser->data;
+    if((client->total_header_size += length) > MAX_HEADER_SIZE) {
+        // headers too long
+        return 1;
+    }
+    client->url = realloc(client->url, client->url_len + length);
+    memcpy(client->url + client->url_len, buff, length);
+    client->url_len += length;
+    client->last_callback = CB_URL;
+    return 0;
+}
+
+static void save_last_header_value(client_t* client)
+{
+    char cgi_header_name[5 /* HTTP_ */ + client->header_field_len + 1];
+    memcpy(cgi_header_name, "HTTP_", 5);
+    for(size_t i = 0; i < client->header_field_len; i++) {
+        if(client->header_field[i] == '-') {
+            cgi_header_name[i + 5] = '_';
+        } else {
+            cgi_header_name[i + 5] = toupper(client->header_field[i]);
+        }
+    }
+    cgi_header_name[client->header_field_len + 5] = 0;
+    VALUE header_name = rb_obj_freeze(rb_str_new(cgi_header_name, 5 + client->header_field_len));
+    VALUE header_value = rb_obj_freeze(rb_str_new(client->header_value, client->header_value_len));
+    rb_hash_aset(client->env, header_name, header_value);
+    free(client->header_field);
+    client->header_field = NULL;
+    client->header_field_len = 0;
+    free(client->header_value);
+    client->header_value = NULL;
+    client->header_value_len = 0;
+}
+
+static int on_http_header_field(http_parser* parser, const char* buff, size_t length)
+{
+    client_t* client = (client_t*)parser->data;
+    if(client->last_callback == CB_HEADER_VALUE) {
+        // we need to save the last header/value pair
+        save_last_header_value(client);
+    }
+    if((client->total_header_size += length) > MAX_HEADER_SIZE) {
+        // headers too long
+        return 1;
+    }
+    
+    client->header_field = realloc(client->header_field, client->header_field_len + length);
+    memcpy(client->header_field + client->header_field_len, buff, length);
+    client->header_field_len += length;
+    
+    client->last_callback = CB_HEADER_FIELD;
+    
+    return 0;
+}
+
+static int on_http_body(http_parser* parser, const char* buff, size_t length)
+{
+    client_t* client = (client_t*)parser->data;
+    if((client->total_header_size += length) > MAX_HEADER_SIZE) {
+        // headers too long
+        return 1;
+    }
+    rb_str_cat(client->body, buff, length);
+    client->last_callback = CB_BODY;
+    return 0;
+}
+
+static int on_http_header_value(http_parser* parser, const char* buff, size_t length)
+{
+    client_t* client = (client_t*)parser->data;
+    if((client->total_header_size += length) > MAX_HEADER_SIZE) {
+        // headers too long
+        return 1;
+    }
+    
+    client->header_value = realloc(client->header_value, client->header_value_len + length);
+    memcpy(client->header_value + client->header_value_len, buff, length);
+    client->header_value_len += length;
+    
+    client->last_callback = CB_HEADER_VALUE;
+    
+    return 0;
+}
+
+static int on_http_headers_complete(http_parser* parser)
+{
+    client_t* client = (client_t*)parser->data;
+    if(client->last_callback == CB_HEADER_VALUE) {
+        // we need to save the last header/value pair
+        save_last_header_value(client);
+    }
+    return 0;
+}
+
+static VALUE collect_headers(VALUE i, VALUE str, int argc, VALUE* argv)
+{
+    if(argc < 1 || TYPE(argv[0]) != T_ARRAY) {
+        return Qnil;
+    }
+    VALUE* nv = RARRAY_PTR(argv[0]);
+    if(RARRAY_LEN(argv[0]) < 2) {
+        return Qnil;
+    }
+    
+    char* name = rb_string_value_cstr(&nv[0]);
+    if(strcmp(name, "Content-Length") == 0 || strcmp(name, "Connection") == 0) {
+        return Qnil;
+    }
+    size_t name_len = strlen(name);
+    char* value = rb_string_value_cstr(&nv[1]);
+    
+    while(value) {
+        rb_str_cat(str, name, name_len);
+        rb_str_concat(str, s_colon_space);
+        char* next = strchr(value, '\n');
+        if(next) {
+            rb_str_cat(str, value, (int)(next - value));
+            value = next + 1;
+        } else {
+            rb_str_cat(str, value, strlen(value));
+            value = NULL;
+        }
+        rb_str_concat(str, s_crlf);
+    }
+    return Qnil;
+}
+
+static VALUE collect_body(VALUE i, VALUE str, int argc, VALUE* argv)
+{
+    if(argc < 1) {
+        return Qnil;
+    }
+    rb_str_concat(str, argv[0]);
+    return Qnil;
+}
+
+static void on_write(uv_write_t* req, int status)
+{
+    client_t* client = req->handle->data;
+    free(((uv_buf_t*)req->data)->base);
+    free(req->data);
+    free(req);
+}
+
+static void http_bad_request(client_t* client)
+{
+    uv_buf_t* b = malloc(sizeof(uv_buf_t));
+    const char* response = "HTTP/1.1 400 Bad Request\r\nServer: " SERVER_SOFTWARE "\r\n\r\n<h1>Bad Request</h1>";
+    b->len = strlen(response);
+    b->base = malloc(b->len);
+    memcpy(b->base, response, b->len);
+    uv_write_t* req = malloc(sizeof(uv_write_t));
+    req->data = b;
+    uv_write(req, &client->socket, b, 1, on_write);
+    client->shutdown = true;
+    uv_read_stop(&client->socket);
+    uv_shutdown_t* shutdown = malloc(sizeof(uv_shutdown_t));
+    uv_shutdown(shutdown, &client->socket, on_shutdown);
+}
+
+static int on_http_message_complete(http_parser* parser)
+{
+    client_t* client = (client_t*)parser->data;
+    
+    // set url, path name, etc:
+    rb_hash_aset(client->env, sSCRIPT_NAME, s_empty);
+    rb_hash_aset(client->env, sREQUEST_URI, rb_obj_freeze(rb_str_new(client->url, client->url_len)));
+    char* query_string = memchr(client->url, '?', client->url_len);
+    if(query_string) {
+        VALUE path = rb_obj_freeze(rb_str_new(client->url, (size_t)(query_string - client->url)));
+        rb_hash_aset(client->env, sPATH_INFO, path);
+        rb_hash_aset(client->env, sREQUEST_PATH, path);
+        rb_hash_aset(client->env, sQUERY_STRING, rb_obj_freeze(rb_str_new(query_string + 1, client->url_len - (size_t)(query_string - client->url) - 1)));
+    } else {
+        VALUE path = rb_obj_freeze(rb_str_new(client->url, client->url_len));
+        rb_hash_aset(client->env, sPATH_INFO, path);
+        rb_hash_aset(client->env, sREQUEST_PATH, path);
+        rb_hash_aset(client->env, sQUERY_STRING, s_empty);
+    }
+    
+    // set request method:
+    rb_hash_aset(client->env, sREQUEST_METHOD, rb_obj_freeze(rb_str_new_cstr(http_method_str(parser->method))));
+    
+    // set IO streams:
+    rb_hash_aset(client->env, sRackInput, rb_funcall(StringIO, i_new, 1, client->body));
+    rb_hash_aset(client->env, sRackErrors, rb_stderr);
+    
+    // call into app
+    VALUE response = rb_funcall(app, i_call, 1, client->env);
+    if(TYPE(response) != T_ARRAY || RARRAY_LEN(response) < 3) {
+        http_bad_request(client);
+        return 1;
+    }
+    
+    VALUE* response_ary = RARRAY_PTR(response);
+    VALUE v_status = response_ary[0];
+    VALUE v_headers = response_ary[1];
+    VALUE v_body = response_ary[2];
+    
+    int status = 0;
+    if(TYPE(v_status) != T_FIXNUM) {
+        v_status = rb_funcall(v_status, i_to_i, 0);
+        if(TYPE(v_status) != T_FIXNUM) {
+            http_bad_request(client);
+            return 1;
+        }
+    }
+    status = FIX2INT(v_status);
+    
+    VALUE v_body_str = rb_str_new_cstr("");
+    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);
+    }
+    
+    char buff[256];
+    sprintf(buff, "HTTP/1.1 %d\r\nContent-Length: %ld\r\nConnection: close\r\n", status, RSTRING_LEN(v_body_str));
+    VALUE v_response_str = rb_str_new(buff, strlen(buff));
+    rb_block_call(v_headers, i_each, 0, NULL, collect_headers, v_response_str);
+    rb_str_concat(v_response_str, s_crlf);
+    rb_str_concat(v_response_str, v_body_str);
+    
+    uv_buf_t* b = malloc(sizeof(uv_buf_t));
+    b->len = RSTRING_LEN(v_response_str);
+    b->base = malloc(b->len);
+    memcpy(b->base, RSTRING_PTR(v_response_str), b->len);
+    uv_write_t* req = malloc(sizeof(uv_write_t));
+    req->data = b;
+    uv_write(req, &client->socket, b, 1, on_write);
+    
+    client->last_callback = CB_COMPLETE;
+    
+    // done
+    return 0;
+}
+
+static int on_http_message_begin(http_parser* parser)
+{
+    client_t* client = (client_t*)parser->data;
+    
+    if(client->url) {
+        free(client->url);
+        client->url = NULL;
+        client->url_len = 0;
+    }
+    
+    total_requests++;
+    
+    // initialize environment for new request:
+    client->body = rb_str_new("", 0);
+    client->env = rb_hash_new();
+    rb_hash_aset(client->env, sSERVER_SOFTWARE, sRacer);
+    rb_hash_aset(client->env, sSERVER_PORT, INT2FIX(port));
+    rb_hash_aset(client->env, sRackVersion, RACK_VERSION);
+    rb_hash_aset(client->env, sRackMultithread, Qfalse);
+    rb_hash_aset(client->env, sRackMultiprocess, Qfalse /* or Qtrue? i have no clue ... */);
+    rb_hash_aset(client->env, sRackRunOnce, Qfalse);
+    rb_hash_aset(client->env, sRackUrlScheme, HTTP_URL_SCHEME /* TODO return https if applicable */);
+    
+    return 0;
+}
+
+static void on_read(uv_stream_t* stream, ssize_t nread, uv_buf_t buff)
+{
+    client_t* client = (client_t*)stream->data;
+    if(nread < 0) {
+        client->shutdown = 1;
+        uv_read_stop(stream);
+        uv_shutdown_t* shutdown = malloc(sizeof(uv_shutdown_t));
+        uv_shutdown(shutdown, stream, on_shutdown);
+    } else if(nread == 0) {
+        if(http_parser_execute(&client->parser, &client->parser_settings, buff.base, nread) != (size_t)nread) {
+            http_bad_request(client);
+        }
+    } else {
+        if(http_parser_execute(&client->parser, &client->parser_settings, buff.base, nread) != (size_t)nread) {
+            http_bad_request(client);
+        } else {
+            if(client->last_callback == CB_COMPLETE && !http_should_keep_alive(&client->parser)) {
+                client->shutdown = 1;
+                uv_read_stop(stream);
+                uv_shutdown_t* shutdown = malloc(sizeof(uv_shutdown_t));
+                uv_shutdown(shutdown, stream, on_shutdown);
+            }
+        }
+    }
+    uv_racer_free(buff);
+}
+
+static void on_connection(uv_stream_t* server, int status)
+{
+    client_t* client = malloc(sizeof(client_t));
+    memset(client, 0, sizeof(client_t));
+    uv_tcp_init(loop, (uv_tcp_t*)&client->socket);
+    uv_accept(server, &client->socket);
+    
+    http_parser_init(&client->parser, HTTP_REQUEST);
+    client->parser.data = client;
+    client->socket.data = client;
+    client->parser_settings.on_message_begin = on_http_message_begin;
+    client->parser_settings.on_url = on_http_url;
+    client->parser_settings.on_header_field = on_http_header_field;
+    client->parser_settings.on_header_value = on_http_header_value;
+    client->parser_settings.on_headers_complete = on_http_headers_complete;
+    client->parser_settings.on_body = on_http_body;
+    client->parser_settings.on_message_complete = on_http_message_complete;
+    
+    client->env = Qnil;
+    rb_gc_register_address(&client->env);
+    client->body = Qnil;
+    rb_gc_register_address(&client->body);
+    
+    uv_read_start((uv_stream_t*)&client->socket, uv_racer_alloc, on_read);
+}
+
+static void run(struct sockaddr_in addr, VALUE _app)
+{
+    const char* err = NULL;
+    const char* msg = NULL;
+    int errcode = 0;
+    
+    app = _app;
+    loop = uv_loop_new();
+    
+    uv_tcp_t tcp;
+    uv_tcp_init(loop, &tcp);
+    if((errcode = uv_tcp_bind(&tcp, addr)) != 0) {
+        err = "uv_tcp_bind failed";
+        msg = uv_strerror(uv_last_error(loop));
+        goto cleanup;
+    }
+    if((errcode = uv_listen((uv_stream_t*)&tcp, 16, on_connection)) != 0) {
+        err = "uv_tcp_listen failed";
+        msg = uv_strerror(uv_last_error(loop));
+        goto cleanup;
+    }
+    
+    uv_run(loop);
+    
+cleanup:
+    uv_loop_delete(loop);
+    app = Qnil;
+    loop = NULL;
+    if(err) {
+        rb_raise(rb_eRuntimeError, "%s: %s (%d)", err, msg, errcode);
+    }
+}
+
+static VALUE Racer_run(VALUE self, VALUE v_address, VALUE v_port, VALUE app)
+{
+    if(loop) {
+        rb_raise(rb_eRuntimeError, "Racer instance already running");
+    }
+    long _port = FIX2INT(v_port);
+    if(_port <= 0 || _port >= 65536) {
+        // out of range
+        rb_raise(rb_eArgError, "port number outside valid range");
+    }
+    char* addr_str = rb_string_value_cstr(&v_address);
+    port = (uint16_t)_port;
+    struct sockaddr_in addr = uv_ip4_addr(addr_str, port);
+    run(addr, app);
+    return Qnil;
+}
+
+static VALUE RacerStats_total_requests(VALUE self)
+{
+    return INT2FIX(total_requests);
+}
+
+static void on_sigint(int signal)
+{
+    rb_interrupt();
+}
+
+void Init_racer()
+{    
+    rb_gc_register_address(&app);
+    
+    globals = rb_ary_new();
+    rb_gc_register_address(&globals);
+    
+    i_new = rb_intern("new");
+    i_call = rb_intern("call");
+    i_to_i = rb_intern("to_i");
+    i_each = rb_intern("each");
+    i_close = rb_intern("close");
+    
+    Racer = rb_define_module("Racer");
+    rb_ary_push(globals, Racer);
+    rb_define_singleton_method(Racer, "run", Racer_run, 3);
+    
+    RacerStats = rb_define_module_under(Racer, "Stats");
+    rb_ary_push(globals, RacerStats);
+    
+    rb_define_singleton_method(RacerStats, "total_requests", RacerStats_total_requests, 0);
+    
+    #define GLOBAL_STR(var, str) var = rb_obj_freeze(rb_str_new_cstr(str)); rb_ary_push(globals, var);
+    
+    GLOBAL_STR(s_empty,             "");
+    GLOBAL_STR(s_crlf,              "\r\n");
+    GLOBAL_STR(s_colon_space,       ": ");
+    GLOBAL_STR(sREQUEST_METHOD,     "REQUEST_METHOD");
+    GLOBAL_STR(sREQUEST_PATH,       "REQUEST_PATH");
+    GLOBAL_STR(sREQUEST_URI,        "REQUEST_URI");
+    GLOBAL_STR(sSCRIPT_NAME,        "SCRIPT_NAME");
+    GLOBAL_STR(sPATH_INFO,          "PATH_INFO");
+    GLOBAL_STR(sQUERY_STRING,       "QUERY_STRING");
+    GLOBAL_STR(sSERVER_NAME,        "SERVER_NAME");
+    GLOBAL_STR(sSERVER_SOFTWARE,    "SERVER_SOFTWARE");
+    GLOBAL_STR(sSERVER_PORT,        "SERVER_PORT");
+    GLOBAL_STR(sRacer,              SERVER_SOFTWARE);
+    
+    GLOBAL_STR(sRackInput,          "rack.input");
+    GLOBAL_STR(sRackErrors,         "rack.errors");
+    GLOBAL_STR(sRackVersion,        "rack.version");
+    GLOBAL_STR(sRackMultithread,    "rack.multithread");
+    GLOBAL_STR(sRackMultiprocess,   "rack.multiprocess");
+    GLOBAL_STR(sRackRunOnce,        "rack.run_once");
+    GLOBAL_STR(sRackUrlScheme,      "rack.url_scheme");
+    GLOBAL_STR(HTTP_URL_SCHEME,     "http");
+    
+    RACK_VERSION = rb_obj_freeze(rb_ary_new3(2, INT2FIX(1), INT2FIX(1)));
+    rb_ary_push(globals, RACK_VERSION);
+    
+    rb_require("stringio");
+    StringIO = rb_const_get(rb_cObject, rb_intern("StringIO"));
+    rb_ary_push(globals, StringIO);
+    
+    signal(SIGINT, on_sigint);
+    
+    #undef GLOBAL_STR
+}