ebb 0.1.0 → 0.2.0

data/ruby_lib/ebb/runner/rails.rb

@@ -11,10 +11,7 @@ module Ebb
         # defaults for ebb_rails
         @options.update(
           :environment => 'development',
-          :port => 3000,
-          # rails has a mutex lock around each request - threaded processing
-          # will only slow things down
-          :threaded_processing => false
+          :port => 3000
         )
 
         @parser.on("-e", "--env ENV", 

data/ruby_lib/rack/adapter/rails.rb

@@ -66,6 +66,11 @@ module Rack
           serve_rails(env)
         end
       end
+      
+      # Never spawn threads for a request
+      def deferred?(env)
+        false
+      end
     
       protected
         

data/src/ebb.c

@@ -17,11 +17,9 @@
 #include <signal.h>
 #include <assert.h>
 
-#include <pthread.h>
-#include <glib.h>
-
 #define EV_STANDALONE 1
 #include <ev.c>
+#include <glib.h>
 
 #include "parser.h"
 #include "ebb.h"
@@ -29,7 +27,14 @@
 #define min(a,b) (a < b ? a : b)
 #define ramp(a) (a > 0 ? a : 0)
 
-static int server_socket_unix(const char *path, int access_mask);
+static void client_init(ebb_client *client);
+
+static void set_nonblock(int fd)
+{
+  int flags = fcntl(fd, F_GETFL, 0);
+  assert(0 <= fcntl(fd, F_SETFL, flags | O_NONBLOCK) && "Setting socket non-block failed!");
+}
+
 
 void env_add(ebb_client *client, const char *field, int flen, const char *value, int vlen)
 {
@@ -37,7 +42,7 @@ void env_add(ebb_client *client, const char *field, int flen, const char *value,
     client->parser.overflow_error = TRUE;
     return;
   }
-  client->env[client->env_size].type = EBB_FIELD_VALUE_PAIR;
+  client->env[client->env_size].type = -1;
   client->env[client->env_size].field = field;
   client->env[client->env_size].field_length = flen;
   client->env[client->env_size].value = value;
@@ -70,75 +75,22 @@ void http_field_cb(void *data, const char *field, size_t flen, const char *value
 }
 
 
-void request_method_cb(void *data, const char *at, size_t length)
-{
-  ebb_client *client = (ebb_client*)(data);
-  env_add_const(client, EBB_REQUEST_METHOD, at, length);
-}
-
-
-void request_uri_cb(void *data, const char *at, size_t length)
-{
-  ebb_client *client = (ebb_client*)(data);
-  env_add_const(client, EBB_REQUEST_URI, at, length);
-}
-
-
-void fragment_cb(void *data, const char *at, size_t length)
-{
-  ebb_client *client = (ebb_client*)(data);
-  env_add_const(client, EBB_FRAGMENT, at, length);
-}
-
-
-void request_path_cb(void *data, const char *at, size_t length)
-{
-  ebb_client *client = (ebb_client*)(data);
-  env_add_const(client, EBB_REQUEST_PATH, at, length);
-}
-
-
-void query_string_cb(void *data, const char *at, size_t length)
-{
-  ebb_client *client = (ebb_client*)(data);
-  env_add_const(client, EBB_QUERY_STRING, at, length);
-}
-
-
-void http_version_cb(void *data, const char *at, size_t length)
-{
-  ebb_client *client = (ebb_client*)(data);
-  env_add_const(client, EBB_HTTP_VERSION, at, length);
-}
-
-
-void content_length_cb(void *data, const char *at, size_t length)
+void on_element(void *data, int type, const char *at, size_t length)
 {
   ebb_client *client = (ebb_client*)(data);
-  env_add_const(client, EBB_CONTENT_LENGTH, at, length);
-  /* atoi_length - why isn't this in the statndard library? i hate c */
-  assert(client->content_length == 0);
-  int i, mult;
-  for(mult=1, i=length-1; i>=0; i--, mult*=10)
-    client->content_length += (at[i] - '0') * mult;
+  env_add_const(client, type, at, length);
 }
 
 
 static void dispatch(ebb_client *client)
 {
   ebb_server *server = client->server;
-  
   if(client->open == FALSE)
     return;
-  
-  /* Set the env variables */
-  if(server->port) {
-    env_add_const(client, EBB_SERVER_PORT
-                        , server->port
-                        , strlen(server->port)
-                        );
-  }
   client->in_use = TRUE;
+  
+  /* XXX decide if to use keep-alive or not? */
+  
   server->request_cb(client, server->request_cb_data);
 }
 
@@ -157,77 +109,7 @@ static void on_timeout(struct ev_loop *loop, ev_timer *watcher, int revents)
 }
 
 #define client_finished_parsing http_parser_is_finished(&client->parser)
-#define total_request_size (client->content_length + client->parser.nread)
-
-static void* read_body_into_file(void *_client)
-{
-  ebb_client *client = (ebb_client*)_client;
-  static unsigned int id;
-  FILE *tmpfile;
-  
-  assert(client->open);
-  assert(client->server->open);
-  assert(client->content_length > 0);
-  assert(client_finished_parsing);
-  
-  /* set blocking socket */
-  int flags = fcntl(client->fd, F_GETFL, 0);
-  assert(0 <= fcntl(client->fd, F_SETFL, flags & ~O_NONBLOCK));
-  
-  sprintf(client->upload_file_filename, "/tmp/ebb_upload_%010d", id++);
-  tmpfile = fopen(client->upload_file_filename, "w+");
-  if(tmpfile == NULL) g_message("Cannot open tmpfile %s", client->upload_file_filename);
-  client->upload_file = tmpfile;
-  
-  size_t body_head_length = client->read - client->parser.nread;
-  size_t written = 0, r;
-  while(written < body_head_length) {
-    r = fwrite( client->request_buffer + sizeof(char)*(client->parser.nread + written)
-              , sizeof(char)
-              , body_head_length - written
-              , tmpfile
-              );
-    if(r <= 0) {
-      ebb_client_close(client);
-      return NULL;
-    }
-    written += r;
-  }
-  
-  int bufsize = 5*1024;
-  char buffer[bufsize];
-  size_t received;
-  while(written < client->content_length) {
-    received = recv(client->fd
-                   , buffer
-                   , min(client->content_length - written, bufsize)
-                   , 0
-                   );
-    if(received < 0) goto error;
-    client->read += received;
-    
-    ssize_t w = 0;
-    int rv;
-    while(w < received) {
-      rv = fwrite( buffer + w*sizeof(char)
-                 , sizeof(char)
-                 , received - w
-                 , tmpfile
-                 );
-      if(rv <= 0) goto error;
-      w += rv;
-    }
-    written += received;
-  }
-  rewind(tmpfile);
-  // g_debug("%d bytes written to file %s", written, client->upload_file_filename);
-  dispatch(client);
-  return NULL;
-error:
-  ebb_client_close(client);
-  return NULL;
-}
-
+#define total_request_size (client->parser.content_length + client->parser.nread)
 
 static void on_client_readable(struct ev_loop *loop, ev_io *watcher, int revents)
 {
@@ -244,12 +126,12 @@ static void on_client_readable(struct ev_loop *loop, ev_io *watcher, int revents
                      , EBB_BUFFERSIZE - client->read
                      , 0
                      );
-  if(read < 0) goto error; 
+  if(read < 0) goto error;
   if(read == 0) goto error; /* XXX is this the right action to take for read==0 ? */
   client->read += read;
   ev_timer_again(loop, &client->timeout_watcher);
   
-  if(client->read == EBB_BUFFERSIZE) goto error;
+  // if(client->read == EBB_BUFFERSIZE) goto error;
   
   if(FALSE == client_finished_parsing) {
     http_parser_execute( &client->parser
@@ -261,88 +143,144 @@ static void on_client_readable(struct ev_loop *loop, ev_io *watcher, int revents
   }
   
   if(client_finished_parsing) {
-    if(total_request_size == client->read) {
+    assert(client->read <= total_request_size);
+    if(total_request_size == client->read || total_request_size > EBB_BUFFERSIZE) {
+      client->body_head = client->request_buffer + client->parser.nread;
+      client->body_head_len = client->read - client->parser.nread;
       ev_io_stop(loop, watcher);
-      client->nread_from_body = 0;
       dispatch(client);
       return;
     }
-    if(total_request_size > EBB_BUFFERSIZE ) {
-      /* read body into file - in a thread */
-      ev_io_stop(loop, watcher);
-      pthread_t thread;
-      assert(0 <= pthread_create(&thread, NULL, read_body_into_file, client));
-      pthread_detach(thread);
-      return;
-    }
   }
   return;
 error:
+#ifdef DEBUG
   if(read < 0) g_message("Error recving data: %s", strerror(errno));
+#endif
   ebb_client_close(client);
 }
 
-static client_init(ebb_server *server, ebb_client *client)
+
+static void on_client_writable(struct ev_loop *loop, ev_io *watcher, int revents)
 {
-  assert(client->in_use == FALSE);
+  ebb_client *client = (ebb_client*)(watcher->data);
+  ssize_t sent;
+  
+  if(client->status_written == FALSE || client->headers_written == FALSE) {
+    g_message("no status or headers - closing connection.");
+    goto error;
+  }
+  
+  if(EV_ERROR & revents) {
+    g_message("on_client_writable() got error event, closing peer");
+    goto error;
+  }
+  
+  //if(client->written != 0)
+  //  g_debug("total written: %d", (int)(client->written));
+  
+  sent = send( client->fd
+             , client->response_buffer->str + sizeof(gchar)*(client->written)
+             , client->response_buffer->len - client->written
+             , 0
+             );
+  if(sent < 0) {
 #ifdef DEBUG
-  /* does ragel fuck up if request buffer isn't null? */
-  for(i=0; i< EBB_BUFFERSIZE; i++)
-    client->request_buffer[i] = 'A';
+    g_message("Error writing: %s", strerror(errno));
 #endif
+    goto error;
+  } else if(sent == 0) {
+    /* is this the wrong thing to do? */
+    g_message("Sent zero bytes? Closing connection");
+    goto error;
+  }
+  client->written += sent;
   
-  client->open = TRUE;
-  client->server = server;
+  assert(client->written <= client->response_buffer->len);
+  //g_message("wrote %d bytes. total: %d", (int)sent, (int)(client->written));
   
-  /* DO SOCKET STUFF */
-  socklen_t len;
-  client->fd = accept(server->fd, (struct sockaddr*)&(server->sockaddr), &len);
-  if(client->fd < 0) {
-    perror("accept()");
-    client->open = FALSE;
-    return;
+  ev_timer_again(loop, &client->timeout_watcher);
+  
+  if(client->written == client->response_buffer->len) {
+    /* stop the write watcher. to be restarted by the next call to ebb_client_write_body
+     * or if client->body_written is set (by using ebb_client_release) then
+     * we close the connection
+     */
+    ev_io_stop(loop, watcher);
+    if(client->body_written) {
+      client->keep_alive ? client_init(client) : ebb_client_close(client);
+    }
+  }
+  return;
+error:
+  ebb_client_close(client);
+}
+
+
+static void client_init(ebb_client *client)
+{
+  assert(client->in_use == FALSE);
+  
+  /* If the client is already open, reuse the fd, just reset all the parameters
+   * this would happen in the case of a keep_alive request
+   */
+  if(!client->open) {
+    /* DO SOCKET STUFF */
+    socklen_t len;
+    int fd = accept(client->server->fd, (struct sockaddr*)&(client->sockaddr), &len);
+    if(fd < 0) {
+      perror("accept()");
+      return;
+    }
+    client->open = TRUE;
+    client->fd = fd;
   }
   
-  int flags = fcntl(client->fd, F_GETFL, 0);
-  assert(0 <= fcntl(client->fd, F_SETFL, flags | O_NONBLOCK));
+  set_nonblock(client->fd);
+  
+  /* IP Address */
+  if(client->server->port)
+    client->ip = inet_ntoa(client->sockaddr.sin_addr);  
   
   /* INITIALIZE http_parser */
-  http_parser_init(&(client->parser));
+  http_parser_init(&client->parser);
   client->parser.data = client;
-  client->parser.http_field     = http_field_cb;
-  client->parser.request_method = request_method_cb;
-  client->parser.request_uri    = request_uri_cb;
-  client->parser.fragment       = fragment_cb;
-  client->parser.request_path   = request_path_cb;
-  client->parser.query_string   = query_string_cb;
-  client->parser.http_version   = http_version_cb;
-  client->parser.content_length = content_length_cb;
+  client->parser.http_field = http_field_cb;
+  client->parser.on_element = on_element;
   
   /* OTHER */
   client->env_size = 0;
-  client->read = client->nread_from_body = 0;
-  client->response_buffer->len = 0; /* see note in ebb_client_close */
-  client->content_length = 0;
+  client->read =  0;
   if(client->request_buffer == NULL) {
+    /* Only allocate the request_buffer once */
     client->request_buffer = (char*)malloc(EBB_BUFFERSIZE);
   }
+  client->keep_alive = FALSE;
+  client->status_written = client->headers_written = client->body_written = FALSE;
+  client->written = 0;
   
-  client->status_written = FALSE;
-  client->headers_written = FALSE;
-  client->body_written = FALSE;
-  client->began_transmission = FALSE;
+  if(client->response_buffer != NULL)
+    g_string_free(client->response_buffer, TRUE);
+  client->response_buffer = g_string_new("");
   
   /* SETUP READ AND TIMEOUT WATCHERS */
+  client->write_watcher.data = client;
+  ev_init (&client->write_watcher, on_client_writable);
+  ev_io_set (&client->write_watcher, client->fd, EV_WRITE | EV_ERROR);
+  /* Note, do not start write_watcher until there is something to be written.
+   * See ebb_client_write_body() */
+  
   client->read_watcher.data = client;
   ev_init(&client->read_watcher, on_client_readable);
   ev_io_set(&client->read_watcher, client->fd, EV_READ | EV_ERROR);
-  ev_io_start(server->loop, &client->read_watcher);
+  ev_io_start(client->server->loop, &client->read_watcher);
   
   client->timeout_watcher.data = client;  
   ev_timer_init(&client->timeout_watcher, on_timeout, EBB_TIMEOUT, EBB_TIMEOUT);
-  ev_timer_start(server->loop, &client->timeout_watcher);
+  ev_timer_start(client->server->loop, &client->timeout_watcher);
 }
 
+
 static void on_request(struct ev_loop *loop, ev_io *watcher, int revents)
 {
   ebb_server *server = (ebb_server*)(watcher->data);
@@ -380,7 +318,7 @@ static void on_request(struct ev_loop *loop, ev_io *watcher, int revents)
   g_debug("%d open connections", count);
 #endif
   
-  client_init(server, client);
+  client_init(client);
 }
 
 
@@ -400,9 +338,10 @@ void ebb_server_init( ebb_server *server
   int i;
   for(i=0; i < EBB_MAX_CLIENTS; i++) {
     server->clients[i].request_buffer = NULL;
-    server->clients[i].response_buffer = g_string_new("");
+    server->clients[i].response_buffer = NULL;
     server->clients[i].open = FALSE;
     server->clients[i].in_use = FALSE;
+    server->clients[i].server = server;
   }
   
   server->request_cb = request_cb;
@@ -421,9 +360,6 @@ void ebb_server_free(ebb_server *server)
 {
   ebb_server_unlisten(server);
   
-  int i; 
-  for(i=0; i < EBB_MAX_CLIENTS; i++)
-    g_string_free(server->clients[i].response_buffer, TRUE);
   if(server->port)
     free(server->port);
   if(server->socketpath)
@@ -439,12 +375,43 @@ void ebb_server_unlisten(ebb_server *server)
     ebb_client *client;
     ev_io_stop(server->loop, &server->request_watcher);
     close(server->fd);
-    if(server->socketpath)
+    if(server->socketpath) {
       unlink(server->socketpath);
+      server->socketpath = NULL;
+    }
+    if(server->port) {
+      free(server->port);
+      server->port = NULL;
+    }
     server->open = FALSE;
   }
 }
 
+
+int ebb_server_listen_on_fd(ebb_server *server, const int sfd)
+{
+  if (listen(sfd, EBB_MAX_CLIENTS) < 0) {
+    perror("listen()");
+    return -1;
+  }
+  
+  set_nonblock(sfd); /* XXX: superfluous? */
+  
+  server->fd = sfd;
+  assert(server->port == NULL);
+  assert(server->socketpath == NULL);
+  assert(server->open == FALSE);
+  server->open = TRUE;
+  
+  server->request_watcher.data = server;
+  ev_init (&server->request_watcher, on_request);
+  ev_io_set (&server->request_watcher, server->fd, EV_READ | EV_ERROR);
+  ev_io_start (server->loop, &server->request_watcher);
+  
+  return server->fd;
+}
+
+
 int ebb_server_listen_on_port(ebb_server *server, const int port)
 {
   int sfd = -1;
@@ -457,12 +424,6 @@ int ebb_server_listen_on_port(ebb_server *server, const int port)
     goto error;
   }
   
-  flags = fcntl(sfd, F_GETFL, 0);
-  if(fcntl(sfd, F_SETFL, flags | O_NONBLOCK) < 0) {
-    perror("setting O_NONBLOCK");
-    goto error;
-  }
-  
   flags = 1;
   setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (void *)&flags, sizeof(flags));
   setsockopt(sfd, SOL_SOCKET, SO_KEEPALIVE, (void *)&flags, sizeof(flags));
@@ -483,36 +444,79 @@ int ebb_server_listen_on_port(ebb_server *server, const int port)
     perror("bind()");
     goto error;
   }
-  if (listen(sfd, EBB_MAX_CLIENTS) < 0) {
-    perror("listen()");
+  
+  int ret = ebb_server_listen_on_fd(server, sfd);
+  if (ret >= 0) {
+    assert(server->port == NULL);
+    server->port = malloc(sizeof(char)*8); /* for easy access to the port */
+    sprintf(server->port, "%d", port);
+  }
+  return ret;
+error:
+  if(sfd > 0) close(sfd);
+  return -1;
+}
+
+
+int ebb_server_listen_on_unix_socket(ebb_server *server, const char *socketpath)
+{
+  int sfd = -1;
+  struct linger ling = {0, 0};
+  struct sockaddr_un addr;
+  struct stat tstat;
+  int flags =1;
+  int old_umask = -1;
+  int access_mask = 0777;
+  
+  if(( sfd = socket(AF_UNIX, SOCK_STREAM, 0) ) == -1) {
+    perror("socket()");
     goto error;
   }
-  server->fd = sfd;
-  server->port = malloc(sizeof(char)*8); /* for easy access to the port */
-  sprintf(server->port, "%d", port);
-  assert(server->open == FALSE);
-  server->open = TRUE;
   
-  server->request_watcher.data = server;
-  ev_init (&server->request_watcher, on_request);
-  ev_io_set (&server->request_watcher, server->fd, EV_READ | EV_ERROR);
-  ev_io_start (server->loop, &server->request_watcher);
+  /* Clean up a previous socket file if we left it around */
+  if(lstat(socketpath, &tstat) == 0 && S_ISSOCK(tstat.st_mode)) {
+    unlink(socketpath);
+  }
   
-  return server->fd;
+  flags = 1;
+  setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (void *)&flags, sizeof(flags));
+  setsockopt(sfd, SOL_SOCKET, SO_KEEPALIVE, (void *)&flags, sizeof(flags));
+  setsockopt(sfd, SOL_SOCKET, SO_LINGER, (void *)&ling, sizeof(ling));
+
+  /*
+   * the memset call clears nonstandard fields in some impementations
+   * that otherwise mess things up.
+   */
+  memset(&addr, 0, sizeof(addr));
+  
+  addr.sun_family = AF_UNIX;
+  strcpy(addr.sun_path, socketpath);
+  old_umask = umask( ~(access_mask & 0777) );
+  
+  if(bind(sfd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
+    perror("bind()");
+    goto error;
+  }
+  umask(old_umask);
+  
+  int ret = ebb_server_listen_on_fd(server, sfd);
+  if (ret >= 0) {
+    assert(server->socketpath == NULL);
+    server->socketpath = strdup(socketpath);
+  }
+  return ret;
 error:
   if(sfd > 0) close(sfd);
   return -1;
 }
 
 
-int ebb_server_listen_on_socket(ebb_server *server, const char *socketpath)
+int ebb_server_clients_in_use_p(ebb_server *server)
 {
-  // int fd = server_socket_unix(socketpath, 0755);
-  // if(fd < 0) return 0;
-  // server->socketpath = strdup(socketpath);
-  // server->fd = fd;
-  // server_listen(server);
-  // return fd;
+  int i;
+  for(i = 0; i < EBB_MAX_CLIENTS; i++)
+    if(server->clients[i].in_use) return TRUE;
+  return FALSE;
 }
 
 
@@ -520,6 +524,21 @@ void ebb_client_release(ebb_client *client)
 {
   assert(client->in_use);
   client->in_use = FALSE;
+  
+  if(client->headers_written == FALSE) {
+    g_string_append(client->response_buffer, "\r\n");
+    client->headers_written = TRUE;
+  }
+  client->body_written = TRUE;
+  
+  /* If the write_watcher isn't yet active, then start it. It could be that
+   * we're streaming and the watcher has been stopped. In that case we 
+   * start it again since we have more to write. */
+  if(ev_is_active(&client->write_watcher) == FALSE) {
+    set_nonblock(client->fd);
+    ev_io_start(client->server->loop, &client->write_watcher);
+  }
+  
   if(client->written == client->response_buffer->len)
     ebb_client_close(client);
 }
@@ -532,17 +551,10 @@ void ebb_client_close(ebb_client *client)
     ev_io_stop(client->server->loop, &client->write_watcher);
     ev_timer_stop(client->server->loop, &client->timeout_watcher);
     
-    if(client->upload_file) {
-      fclose(client->upload_file);
-      unlink(client->upload_file_filename);
-    }
+    client->ip = NULL;
     
-    /* here we do not free the already allocated GString client->response_buffer
-     * that we're holding the response in. we reuse it again - 
-     * presumably because the backend is going to keep sending such long
-     * requests.
-     */
-    client->response_buffer->len = 0;
+    g_string_free(client->response_buffer, TRUE);
+    client->response_buffer = NULL;
     
     close(client->fd);
     client->open = FALSE;
@@ -550,54 +562,7 @@ void ebb_client_close(ebb_client *client)
 }
 
 
-static void on_client_writable(struct ev_loop *loop, ev_io *watcher, int revents)
-{
-  ebb_client *client = (ebb_client*)(watcher->data);
-  ssize_t sent;
-  
-  assert(client->status_written);
-  assert(client->headers_written);
-  assert(client->began_transmission);
-  
-  if(EV_ERROR & revents) {
-    g_message("on_client_writable() got error event, closing peer");
-    ebb_client_close(client);
-    return;
-  }
-  
-  //if(client->written != 0)
-  //  g_debug("total written: %d", (int)(client->written));
-  
-  sent = send( client->fd
-             , client->response_buffer->str + sizeof(gchar)*(client->written)
-             , client->response_buffer->len - client->written
-             , 0
-             );
-  if(sent < 0) {
-#ifdef DEBUG
-    g_message("Error writing: %s", strerror(errno));
-#endif
-    ebb_client_close(client);
-    return;
-  } else if(sent == 0) {
-    g_message("Sent zero bytes? Closing connection");
-    ebb_client_close(client);
-  }
-  client->written += sent;
-  
-  assert(client->written <= client->response_buffer->len);
-  //g_message("wrote %d bytes. total: %d", (int)sent, (int)(client->written));
-  
-  ev_timer_again(loop, &(client->timeout_watcher));
-  
-  if(client->written == client->response_buffer->len) {
-    ev_io_stop(loop, watcher);
-    if(client->body_written)
-      ebb_client_close(client);
-  }
-}
-
-void ebb_client_write_status(ebb_client *client, int status, const char *human_status)
+void ebb_client_write_status(ebb_client *client, int status, const char *reason_phrase)
 {
   assert(client->in_use);
   if(!client->open) return;
@@ -605,17 +570,22 @@ void ebb_client_write_status(ebb_client *client, int status, const char *human_s
   g_string_append_printf( client->response_buffer
                         , "HTTP/1.1 %d %s\r\n"
                         , status
-                        , human_status
+                        , reason_phrase
                         );
   client->status_written = TRUE;
 }
 
+
 void ebb_client_write_header(ebb_client *client, const char *field, const char *value)
 {
   assert(client->in_use);
   if(!client->open) return;
   assert(client->status_written == TRUE);
   assert(client->headers_written == FALSE);
+  
+  if(strcmp(field, "Connection") == 0 && strcmp(value, "Keep-Alive") == 0) {
+    client->keep_alive = TRUE;
+  }
   g_string_append_printf( client->response_buffer
                         , "%s: %s\r\n"
                         , field
@@ -623,131 +593,35 @@ void ebb_client_write_header(ebb_client *client, const char *field, const char *
                         );
 }
 
-void ebb_client_write(ebb_client *client, const char *data, int length)
-{
-  assert(client->in_use);
-  if(!client->open) return;
-  g_string_append_len(client->response_buffer, data, length);
-  if(client->began_transmission) {
-    /* restart the watcher if we're streaming */
-    ev_io_start(client->server->loop, &client->write_watcher);
-  }
-}
-
 
-void ebb_client_begin_transmission(ebb_client *client)
+void ebb_client_write_body(ebb_client *client, const char *data, int length)
 {
   assert(client->in_use);
   if(!client->open) return;
-  assert(FALSE == ev_is_active(&client->write_watcher));
   
-  /* assure the socket is still in non-blocking mode */
-  int flags = fcntl(client->fd, F_GETFL, 0);
-  if(0 > fcntl(client->fd, F_SETFL, flags | O_NONBLOCK)) {
-    perror("fcntl()");
-    ebb_client_close(client);
-    return;
+  if(client->headers_written == FALSE) {
+    g_string_append(client->response_buffer, "\r\n");
+    client->headers_written = TRUE;
   }
   
-  client->headers_written = TRUE;
-  client->began_transmission = TRUE;
-  client->written = 0;
-  client->write_watcher.data = client;
-  ev_init (&(client->write_watcher), on_client_writable);
-  ev_io_set (&(client->write_watcher), client->fd, EV_WRITE | EV_ERROR);
-  ev_io_start(client->server->loop, &client->write_watcher);
-}
-
-
-/* pass an allocated buffer and the length to read. this function will try to
- * fill the buffer with that length of data read from the body of the request.
- * the return value says how much was actually written.
- */
-int ebb_client_read(ebb_client *client, char *buffer, int length)
-{
-  size_t read;
+  g_string_append_len(client->response_buffer, data, length);
   
-  assert(client->in_use);
-  if(!client->open) return -1;
-  assert(client_finished_parsing);
-  
-  if(client->upload_file) {
-    read = fread(buffer, 1, length, client->upload_file);
-    /* TODO error checking! */
-    return read;
-  } else {
-    char* request_body = client->request_buffer + client->parser.nread;
-    
-    read = ramp(min(length, client->content_length - client->nread_from_body));
-    memcpy( buffer
-          , request_body + client->nread_from_body
-          , read
-          );
-    client->nread_from_body += read;
-    return read;
+  /* If the write_watcher isn't yet active, then start it. It could be that
+   * we're streaming and the watcher has been stopped. In that case we 
+   * start it again since we have more to write. */
+  if(ev_is_active(&client->write_watcher) == FALSE) {
+    set_nonblock(client->fd);
+    ev_io_start(client->server->loop, &client->write_watcher);
   }
 }
 
-/* The following socket creation routines are modified and stolen from memcached */
-
-
-static int server_socket_unix(const char *path, int access_mask) {
-    int sfd;
-    struct linger ling = {0, 0};
-    struct sockaddr_un addr;
-    struct stat tstat;
-    int flags =1;
-    int old_umask;
-
-    if (!path) {
-        return -1;
-    }
-    
-    if ((sfd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
-        perror("socket()");
-        return -1;
-    }
-    
-    if ((flags = fcntl(sfd, F_GETFL, 0)) < 0 ||
-        fcntl(sfd, F_SETFL, flags | O_NONBLOCK) < 0) {
-        perror("setting O_NONBLOCK");
-        close(sfd);
-        return -1;
-    }
-    
-    /*
-     * Clean up a previous socket file if we left it around
-     */
-    if (lstat(path, &tstat) == 0) {
-        if (S_ISSOCK(tstat.st_mode))
-            unlink(path);
-    }
-
-    flags = 1;
-    setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (void *)&flags, sizeof(flags));
-    setsockopt(sfd, SOL_SOCKET, SO_KEEPALIVE, (void *)&flags, sizeof(flags));
-    setsockopt(sfd, SOL_SOCKET, SO_LINGER, (void *)&ling, sizeof(ling));
-
-    /*
-     * the memset call clears nonstandard fields in some impementations
-     * that otherwise mess things up.
-     */
-    memset(&addr, 0, sizeof(addr));
-
-    addr.sun_family = AF_UNIX;
-    strcpy(addr.sun_path, path);
-    old_umask=umask( ~(access_mask&0777));
-    if (bind(sfd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
-        perror("bind()");
-        close(sfd);
-        umask(old_umask);
-        return -1;
-    }
-    umask(old_umask);
-    if (listen(sfd, EBB_MAX_CLIENTS) == -1) {
-        perror("listen()");
-        close(sfd);
-        return -1;
-    }
-    return sfd;
-}
+// int ebb_client_should_keep_alive(ebb_client*)
+// {
+//   /* TODO - return boolean  */
+//     if env['HTTP_VERSION'] == 'HTTP/1.0' 
+//       return true if env['HTTP_CONNECTION'] =~ /Keep-Alive/i
+//     else
+//       return true unless env['HTTP_CONNECTION'] =~ /close/i
+//     end
+//     false
+// }