add readme and initial code

Makefile

@@ -0,0 +1,32 @@
+EVDIR=$(HOME)/local/libev
+V8INC = $(HOME)/src/v8/include
+V8LIB = $(HOME)/src/v8/libv8.a
+
+CFLAGS = -g -I$(V8INC) -Ideps/oi -DHAVE_GNUTLS=0 -Ideps/ebb 
+LDFLAGS = -lev #-lefence
+
+ifdef EVDIR
+	CFLAGS += -I$(EVDIR)/include
+	LDFLAGS += -L$(EVDIR)/lib
+endif
+
+server: server.o deps/oi/oi_socket.o deps/ebb/ebb_request_parser.o
+	g++ $(CFLAGS) $(LDFLAGS) $(V8LIB) -o server $^
+
+server.o: server.cc 
+	g++ $(CFLAGS) -c $@ $<
+
+ebb_request_parser.o: ebb_request_parser.c deps/ebb/ebb_request_parser.h 
+	gcc $(CFLAGS) -c $@ $<
+
+ebb_request_parser.c: deps/ebb/ebb_request_parser.rl
+	ragel -s -G2 $< -o $@
+
+oi_socket.o: deps/oi/oi_socket.c deps/oi/oi_socket.h 
+	gcc $(CFLAGS) -c $@ $<
+
+clean:
+	rm -f *.o 
+	rm -f server
+
+.PHONY: clean test

README

@@ -0,0 +1,4 @@
+
+git submodule init
+git submodule update
+make

js_http_request_processor.cc

@@ -0,0 +1,606 @@
+// Copyright 2008 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <v8.h>
+
+// To avoid warnings from <map> on windows we disable exceptions.
+#define _HAS_EXCEPTIONS 0
+#include <string>
+#include <map>
+
+#include <js_http_request_processor.h>
+
+using namespace std;
+using namespace v8;
+
+static Handle<Value> LogCallback
+  ( const Arguments& args
+  ) 
+{
+  if (args.Length() < 1) return v8::Undefined();
+  HandleScope scope;
+  Handle<Value> arg = args[0];
+  String::Utf8Value value(arg);
+  HttpRequestProcessor::Log(*value);
+  return v8::Undefined();
+}
+
+
+// Execute the script and fetch the Process method.
+bool JsHttpRequestProcessor::Initialize
+  ( map<string, string>* opts
+  , map<string, string>* output
+  ) 
+{
+  // Create a handle scope to hold the temporary references.
+  HandleScope handle_scope;
+
+  // Create a template for the global object where we set the
+  // built-in global functions.
+  Handle<ObjectTemplate> global = ObjectTemplate::New();
+  global->Set(String::New("log"), FunctionTemplate::New(LogCallback));
+
+  // Each processor gets its own context so different processors
+  // don't affect each other (ignore the first three lines).
+  Handle<Context> context = Context::New(NULL, global);
+
+  // Store the context in the processor object in a persistent handle,
+  // since we want the reference to remain after we return from this
+  // method.
+  context_ = Persistent<Context>::New(context);
+
+  // Enter the new context so all the following operations take place
+  // within it.
+  Context::Scope context_scope(context);
+
+  // Make the options mapping available within the context
+  if (!InstallMaps(opts, output))
+    return false;
+
+  // Compile and run the script
+  if (!ExecuteScript(script_))
+    return false;
+
+  // The script compiled and ran correctly.  Now we fetch out the
+  // Process function from the global object.
+  Handle<String> process_name = String::New("Process");
+  Handle<Value> process_val = context->Global()->Get(process_name);
+
+  // If there is no Process function, or if it is not a function,
+  // bail out
+  if (!process_val->IsFunction()) return false;
+
+  // It is a function; cast it to a Function
+  Handle<Function> process_fun = Handle<Function>::Cast(process_val);
+
+  // Store the function in a Persistent handle, since we also want
+  // that to remain after this call returns
+  process_ = Persistent<Function>::New(process_fun);
+
+  // All done; all went well
+  return true;
+}
+
+
+bool JsHttpRequestProcessor::ExecuteScript
+  ( Handle<String> script
+  ) 
+{
+  HandleScope handle_scope;
+
+  // We're just about to compile the script; set up an error handler to
+  // catch any exceptions the script might throw.
+  TryCatch try_catch;
+
+  // Compile the script and check for errors.
+  Handle<Script> compiled_script = Script::Compile(script);
+  if (compiled_script.IsEmpty()) {
+    String::Utf8Value error(try_catch.Exception());
+    Log(*error);
+    // The script failed to compile; bail out.
+    return false;
+  }
+
+  // Run the script!
+  Handle<Value> result = compiled_script->Run();
+  if (result.IsEmpty()) {
+    // The TryCatch above is still in effect and will have caught the error.
+    String::Utf8Value error(try_catch.Exception());
+    Log(*error);
+    // Running the script failed; bail out.
+    return false;
+  }
+  return true;
+}
+
+bool JsHttpRequestProcessor::InstallMaps
+  ( map<string, string>* opts
+  , map<string, string>* output
+  ) 
+{
+  HandleScope handle_scope;
+
+  // Wrap the map object in a JavaScript wrapper
+  Handle<Object> opts_obj = WrapMap(opts);
+
+  // Set the options object as a property on the global object.
+  context_->Global()->Set(String::New("options"), opts_obj);
+
+  Handle<Object> output_obj = WrapMap(output);
+  context_->Global()->Set(String::New("output"), output_obj);
+
+  return true;
+}
+
+
+bool JsHttpRequestProcessor::Process
+  ( HttpRequest* request
+  ) 
+{
+  // Create a handle scope to keep the temporary object references.
+  HandleScope handle_scope;
+
+  // Enter this processor's context so all the remaining operations
+  // take place there
+  Context::Scope context_scope(context_);
+
+  // Wrap the C++ request object in a JavaScript wrapper
+  Handle<Object> request_obj = WrapRequest(request);
+
+  // Set up an exception handler before calling the Process function
+  TryCatch try_catch;
+
+  // Invoke the process function, giving the global object as 'this'
+  // and one argument, the request.
+  const int argc = 1;
+  Handle<Value> argv[argc] = { request_obj };
+  Handle<Value> result = process_->Call(context_->Global(), argc, argv);
+  if (result.IsEmpty()) {
+    String::Utf8Value error(try_catch.Exception());
+    Log(*error);
+    return false;
+  } else {
+    return true;
+  }
+}
+
+
+JsHttpRequestProcessor::~JsHttpRequestProcessor
+  (
+  ) 
+{
+  // Dispose the persistent handles.  When noone else has any
+  // references to the objects stored in the handles they will be
+  // automatically reclaimed.
+  context_.Dispose();
+  process_.Dispose();
+}
+
+
+Persistent<ObjectTemplate> JsHttpRequestProcessor::request_template_;
+Persistent<ObjectTemplate> JsHttpRequestProcessor::map_template_;
+
+
+// -----------------------------------
+// --- A c c e s s i n g   M a p s ---
+// -----------------------------------
+
+// Utility function that wraps a C++ http request object in a
+// JavaScript object.
+Handle<Object> JsHttpRequestProcessor::WrapMap
+  ( map<string, string>* obj
+  ) 
+{
+  // Handle scope for temporary handles.
+  HandleScope handle_scope;
+
+  // Fetch the template for creating JavaScript map wrappers.
+  // It only has to be created once, which we do on demand.
+  if (request_template_.IsEmpty()) {
+    Handle<ObjectTemplate> raw_template = MakeMapTemplate();
+    map_template_ = Persistent<ObjectTemplate>::New(raw_template);
+  }
+  Handle<ObjectTemplate> templ = map_template_;
+
+  // Create an empty map wrapper.
+  Handle<Object> result = templ->NewInstance();
+
+  // Wrap the raw C++ pointer in an External so it can be referenced
+  // from within JavaScript.
+  Handle<External> map_ptr = External::New(obj);
+
+  // Store the map pointer in the JavaScript wrapper.
+  result->SetInternalField(0, map_ptr);
+
+  // Return the result through the current handle scope.  Since each
+  // of these handles will go away when the handle scope is deleted
+  // we need to call Close to let one, the result, escape into the
+  // outer handle scope.
+  return handle_scope.Close(result);
+}
+
+
+// Utility function that extracts the C++ map pointer from a wrapper
+// object.
+map<string, string>* JsHttpRequestProcessor::UnwrapMap
+  ( Handle<Object> obj
+  ) 
+{
+  Handle<External> field = Handle<External>::Cast(obj->GetInternalField(0));
+  void* ptr = field->Value();
+  return static_cast<map<string, string>*>(ptr);
+}
+
+
+// Convert a JavaScript string to a std::string.  To not bother too
+// much with string encodings we just use ascii.
+string ObjectToString
+  ( Local<Value> value
+  )
+{
+  String::Utf8Value utf8_value(value);
+  return string(*utf8_value);
+}
+
+
+Handle<Value> JsHttpRequestProcessor::MapGet
+  ( Local<String> name
+  , const AccessorInfo& info
+  ) 
+{
+  // Fetch the map wrapped by this object.
+  map<string, string>* obj = UnwrapMap(info.Holder());
+
+  // Convert the JavaScript string to a std::string.
+  string key = ObjectToString(name);
+
+  // Look up the value if it exists using the standard STL ideom.
+  map<string, string>::iterator iter = obj->find(key);
+
+  // If the key is not present return an empty handle as signal
+  if (iter == obj->end()) return Handle<Value>();
+
+  // Otherwise fetch the value and wrap it in a JavaScript string
+  const string& value = (*iter).second;
+  return String::New(value.c_str(), value.length());
+}
+
+
+Handle<Value> JsHttpRequestProcessor::MapSet
+  ( Local<String> name
+  , Local<Value> value_obj
+  , const AccessorInfo& info
+  ) 
+{
+  // Fetch the map wrapped by this object.
+  map<string, string>* obj = UnwrapMap(info.Holder());
+
+  // Convert the key and value to std::strings.
+  string key = ObjectToString(name);
+  string value = ObjectToString(value_obj);
+
+  // Update the map.
+  (*obj)[key] = value;
+
+  // Return the value; any non-empty handle will work.
+  return value_obj;
+}
+
+
+Handle<ObjectTemplate> JsHttpRequestProcessor::MakeMapTemplate
+  (
+  )
+{
+  HandleScope handle_scope;
+
+  Handle<ObjectTemplate> result = ObjectTemplate::New();
+  result->SetInternalFieldCount(1);
+  result->SetNamedPropertyHandler(MapGet, MapSet);
+
+  // Again, return the result through the current handle scope.
+  return handle_scope.Close(result);
+}
+
+
+// -------------------------------------------
+// --- A c c e s s i n g   R e q u e s t s ---
+// -------------------------------------------
+
+/**
+ * Utility function that wraps a C++ http request object in a
+ * JavaScript object.
+ */
+Handle<Object> JsHttpRequestProcessor::WrapRequest
+  ( HttpRequest* request
+  ) 
+{
+  // Handle scope for temporary handles.
+  HandleScope handle_scope;
+
+  // Fetch the template for creating JavaScript http request wrappers.
+  // It only has to be created once, which we do on demand.
+  if (request_template_.IsEmpty()) {
+    Handle<ObjectTemplate> raw_template = MakeRequestTemplate();
+    request_template_ = Persistent<ObjectTemplate>::New(raw_template);
+  }
+  Handle<ObjectTemplate> templ = request_template_;
+
+  // Create an empty http request wrapper.
+  Handle<Object> result = templ->NewInstance();
+
+  // Wrap the raw C++ pointer in an External so it can be referenced
+  // from within JavaScript.
+  Handle<External> request_ptr = External::New(request);
+
+  // Store the request pointer in the JavaScript wrapper.
+  result->SetInternalField(0, request_ptr);
+
+  // Return the result through the current handle scope.  Since each
+  // of these handles will go away when the handle scope is deleted
+  // we need to call Close to let one, the result, escape into the
+  // outer handle scope.
+  return handle_scope.Close(result);
+}
+
+
+/**
+ * Utility function that extracts the C++ http request object from a
+ * wrapper object.
+ */
+HttpRequest* JsHttpRequestProcessor::UnwrapRequest
+  ( Handle<Object> obj
+  ) 
+{
+  Handle<External> field = Handle<External>::Cast(obj->GetInternalField(0));
+  void* ptr = field->Value();
+  return static_cast<HttpRequest*>(ptr);
+}
+
+Handle<Value> JsHttpRequestProcessor::GetPath
+  ( Local<String> name
+  , const AccessorInfo& info
+  )
+{
+  // Extract the C++ request object from the JavaScript wrapper.
+  HttpRequest* request = UnwrapRequest(info.Holder());
+
+  // Fetch the path.
+  const string& path = request->Path();
+
+  // Wrap the result in a JavaScript string and return it.
+  return String::New(path.c_str(), path.length());
+}
+
+
+Handle<Value> JsHttpRequestProcessor::GetReferrer
+  ( Local<String> name
+  , const AccessorInfo& info
+  ) 
+{
+  HttpRequest* request = UnwrapRequest(info.Holder());
+  const string& path = request->Referrer();
+  return String::New(path.c_str(), path.length());
+}
+
+
+Handle<Value> JsHttpRequestProcessor::GetHost
+  ( Local<String> name
+  , const AccessorInfo& info
+  )
+{
+  HttpRequest* request = UnwrapRequest(info.Holder());
+  const string& path = request->Host();
+  return String::New(path.c_str(), path.length());
+}
+
+
+Handle<Value> JsHttpRequestProcessor::GetUserAgent
+  ( Local<String> name
+  , const AccessorInfo& info
+  ) 
+{
+  HttpRequest* request = UnwrapRequest(info.Holder());
+  const string& path = request->UserAgent();
+  return String::New(path.c_str(), path.length());
+}
+
+
+Handle<ObjectTemplate> JsHttpRequestProcessor::MakeRequestTemplate
+  (
+  ) 
+{
+  HandleScope handle_scope;
+
+  Handle<ObjectTemplate> result = ObjectTemplate::New();
+  result->SetInternalFieldCount(1);
+
+  // Add accessors for each of the fields of the request.
+  result->SetAccessor(String::NewSymbol("path"), GetPath);
+  result->SetAccessor(String::NewSymbol("referrer"), GetReferrer);
+  result->SetAccessor(String::NewSymbol("host"), GetHost);
+  result->SetAccessor(String::NewSymbol("userAgent"), GetUserAgent);
+
+  // Again, return the result through the current handle scope.
+  return handle_scope.Close(result);
+}
+
+
+// --- Test ---
+
+
+void HttpRequestProcessor::Log
+  ( const char* event
+  ) 
+{
+  printf("Logged: %s\n", event);
+}
+
+
+/**
+ * A simplified http request.
+ */
+class StringHttpRequest : public HttpRequest 
+{
+public:
+  StringHttpRequest
+    ( const string& path
+    , const string& referrer
+    , const string& host
+    , const string& user_agent
+    );
+  virtual const string& Path ()      { return path_; }
+  virtual const string& Referrer ()  { return referrer_; }
+  virtual const string& Host ()      { return host_; }
+  virtual const string& UserAgent () { return user_agent_; }
+private:
+  string path_;
+  string referrer_;
+  string host_;
+  string user_agent_;
+};
+
+
+StringHttpRequest::StringHttpRequest
+  ( const string& path
+  , const string& referrer
+  , const string& host 
+  , const string& user_agent
+  ) 
+  : path_       (path)
+  , referrer_   (referrer)
+  , host_       (host)
+  , user_agent_ (user_agent) 
+{ 
+}
+
+void ParseOptions
+  ( int argc
+  , char* argv[]
+  , map<string, string>& options
+  , string* file
+  )
+{
+  for (int i = 1; i < argc; i++) {
+    string arg = argv[i];
+    int index = arg.find('=', 0);
+    if (index == string::npos) {
+      *file = arg;
+    } else {
+      string key = arg.substr(0, index);
+      string value = arg.substr(index+1);
+      options[key] = value;
+    }
+  }
+}
+
+
+// Reads a file into a v8 string.
+Handle<String> ReadFile
+  ( const string& name
+  ) 
+{
+  FILE* file = fopen(name.c_str(), "rb");
+  if (file == NULL) return Handle<String>();
+
+  fseek(file, 0, SEEK_END);
+  int size = ftell(file);
+  rewind(file);
+
+  char* chars = new char[size + 1];
+  chars[size] = '\0';
+  for (int i = 0; i < size;) {
+    int read = fread(&chars[i], 1, size - i, file);
+    i += read;
+  }
+  fclose(file);
+  Handle<String> result = String::New(chars, size);
+  delete[] chars;
+  return result;
+}
+
+
+const int kSampleSize = 6;
+StringHttpRequest kSampleRequests[kSampleSize] = 
+  { StringHttpRequest("/process.cc", "localhost", "google.com", "firefox")
+  , StringHttpRequest("/", "localhost", "google.net", "firefox")
+  , StringHttpRequest("/", "localhost", "google.org", "safari")
+  , StringHttpRequest("/", "localhost", "yahoo.com", "ie")
+  , StringHttpRequest("/", "localhost", "yahoo.com", "safari")
+  , StringHttpRequest("/", "localhost", "yahoo.com", "firefox")
+  };
+
+
+bool ProcessEntries
+  ( HttpRequestProcessor* processor
+  , int count
+  , StringHttpRequest* reqs
+  ) 
+{
+  for (int i = 0; i < count; i++) {
+    if (!processor->Process(&reqs[i]))
+      return false;
+  }
+  return true;
+}
+
+
+void PrintMap
+  ( map<string, string>* m
+  ) 
+{
+  for (map<string, string>::iterator i = m->begin(); i != m->end(); i++) {
+    pair<string, string> entry = *i;
+    printf("%s: %s\n", entry.first.c_str(), entry.second.c_str());
+  }
+}
+
+#if 0
+int main(int argc, char* argv[]) {
+  map<string, string> options;
+  string file;
+  ParseOptions(argc, argv, options, &file);
+  if (file.empty()) {
+    fprintf(stderr, "No script was specified.\n");
+    return 1;
+  }
+  HandleScope scope;
+  Handle<String> source = ReadFile(file);
+  if (source.IsEmpty()) {
+    fprintf(stderr, "Error reading '%s'.\n", file.c_str());
+    return 1;
+  }
+  JsHttpRequestProcessor processor(source);
+  map<string, string> output;
+  if (!processor.Initialize(&options, &output)) {
+    fprintf(stderr, "Error initializing processor.\n");
+    return 1;
+  }
+  if (!ProcessEntries(&processor, kSampleSize, kSampleRequests))
+    return 1;
+  PrintMap(&output);
+}
+#endif

js_http_request_processor.h

@@ -0,0 +1,104 @@
+#ifndef js_http_request_processor_h
+#define js_http_request_processor_h
+
+#include <v8.h>
+#include <string>
+#include <map>
+
+using namespace std;
+using namespace v8;
+
+// These interfaces represent an existing request processing interface.
+// The idea is to imagine a real application that uses these interfaces
+// and then add scripting capabilities that allow you to interact with
+// the objects through JavaScript.
+
+/**
+ * A simplified http request.
+ */
+class HttpRequest {
+ public:
+  virtual ~HttpRequest() { }
+  virtual const string& Path() = 0;
+  virtual const string& Referrer() = 0;
+  virtual const string& Host() = 0;
+  virtual const string& UserAgent() = 0;
+};
+
+/**
+ * The abstract superclass of http request processors.
+ */
+class HttpRequestProcessor {
+ public:
+  virtual ~HttpRequestProcessor() { }
+
+  // Initialize this processor.  The map contains options that control
+  // how requests should be processed.
+  virtual bool Initialize(map<string, string>* options,
+                          map<string, string>* output) = 0;
+
+  // Process a single request.
+  virtual bool Process(HttpRequest* req) = 0;
+
+  static void Log(const char* event);
+};
+
+/**
+ * An http request processor that is scriptable using JavaScript.
+ */
+class JsHttpRequestProcessor : public HttpRequestProcessor {
+ public:
+
+  // Creates a new processor that processes requests by invoking the
+  // Process function of the JavaScript script given as an argument.
+  explicit JsHttpRequestProcessor(Handle<String> script) : script_(script) { }
+  virtual ~JsHttpRequestProcessor();
+
+  virtual bool Initialize(map<string, string>* opts,
+                          map<string, string>* output);
+  virtual bool Process(HttpRequest* req);
+
+ private:
+
+  // Execute the script associated with this processor and extract the
+  // Process function.  Returns true if this succeeded, otherwise false.
+  bool ExecuteScript(Handle<String> script);
+
+  // Wrap the options and output map in a JavaScript objects and
+  // install it in the global namespace as 'options' and 'output'.
+  bool InstallMaps(map<string, string>* opts, map<string, string>* output);
+
+  // Constructs the template that describes the JavaScript wrapper
+  // type for requests.
+  static Handle<ObjectTemplate> MakeRequestTemplate();
+  static Handle<ObjectTemplate> MakeMapTemplate();
+
+  // Callbacks that access the individual fields of request objects.
+  static Handle<Value> GetPath(Local<String> name, const AccessorInfo& info);
+  static Handle<Value> GetReferrer(Local<String> name,
+                                   const AccessorInfo& info);
+  static Handle<Value> GetHost(Local<String> name, const AccessorInfo& info);
+  static Handle<Value> GetUserAgent(Local<String> name,
+                                    const AccessorInfo& info);
+
+  // Callbacks that access maps
+  static Handle<Value> MapGet(Local<String> name, const AccessorInfo& info);
+  static Handle<Value> MapSet(Local<String> name,
+                              Local<Value> value,
+                              const AccessorInfo& info);
+
+  // Utility methods for wrapping C++ objects as JavaScript objects,
+  // and going back again.
+  static Handle<Object> WrapMap(map<string, string>* obj);
+  static map<string, string>* UnwrapMap(Handle<Object> obj);
+  static Handle<Object> WrapRequest(HttpRequest* obj);
+  static HttpRequest* UnwrapRequest(Handle<Object> obj);
+
+  Handle<String> script_;
+  Persistent<Context> context_;
+  Persistent<Function> process_;
+  static Persistent<ObjectTemplate> request_template_;
+  static Persistent<ObjectTemplate> map_template_;
+};
+
+#endif // js_http_request_processor_h

server.cc

@@ -0,0 +1,247 @@
+#include <v8.h>
+
+extern "C" {
+#include <oi.h>
+#include <ebb_request_parser.h>
+}
+
+#include <assert.h>
+#include <string>
+#include <map>
+
+using namespace v8;
+using namespace std;
+
+#define PORT "1981"
+#define MAX_URL 500 
+
+static oi_server server;
+static struct ev_loop *loop;
+
+class Connection {
+public:
+  Connection(void);
+  ebb_request_parser parser;
+  oi_socket socket;
+};
+
+class Request {
+public:
+  Request(Connection &);
+  string path;
+  Connection &connection_;
+  ebb_request parser_info;
+};
+
+Request::Request
+  ( Connection &connection
+  )
+  : connection_(connection)
+{
+  ebb_request_init(&parser_info);
+}
+
+Connection::Connection
+  ( void
+  )
+{
+  oi_socket_init (&socket, 30.0);
+  ebb_request_parser_init (&parser);
+}
+
+void on_path
+  ( ebb_request *req
+  , const char *buf
+  , size_t len
+  )
+{
+  Request *request = static_cast<Request*> (req->data);
+  request->path.append(buf, len);
+}
+
+void on_request_complete
+  ( ebb_request *req
+  )
+{
+  Request *request = static_cast<Request*> (req->data);
+
+  // dispatch to javascript
+}
+
+ebb_request * on_request
+  ( void *data
+  ) 
+{
+  Connection *connection = static_cast<Connection*> (data);
+
+  Request *request = new Request(*connection);
+  
+  request->parser_info.on_path             = on_path;
+  request->parser_info.on_query_string     = NULL;
+  request->parser_info.on_uri              = NULL;
+  request->parser_info.on_fragment         = NULL;
+  request->parser_info.on_header_field     = NULL;
+  request->parser_info.on_header_value     = NULL;
+  request->parser_info.on_headers_complete = NULL;
+  request->parser_info.on_body             = NULL;
+  request->parser_info.on_complete         = on_request_complete;
+  request->parser_info.data                = request;
+
+  return &request->parser_info;
+}
+
+static void on_read 
+  ( oi_socket *socket
+  , const void *buf
+  , size_t count
+  )
+{
+  Connection *connection = static_cast<Connection*> (socket->data);
+  ebb_request_parser_execute ( &connection->parser
+                             , static_cast<const char*> (buf) // FIXME change ebb to use void*
+                             , count
+                             );
+  /* TODO check for errors */
+}
+
+static void on_close 
+  ( oi_socket *socket
+  )
+{
+  Connection *connection = static_cast<Connection*> (socket->data);
+  /* TODO free requests */
+  free(connection);
+}
+
+static void on_drain 
+  ( oi_socket *socket
+  )
+{
+  Connection *connection = static_cast<Connection*> (socket->data);
+  //oi_socket_close(&connection->socket);
+}
+
+static oi_socket* new_connection 
+  ( oi_server *server
+  , struct sockaddr *addr
+  , socklen_t len
+  )
+{
+  Connection *connection = new Connection();
+
+  /* initialize the components of Connection */
+  oi_socket_init(&connection->socket, 30.0);
+  connection->socket.on_read    = on_read;
+  connection->socket.on_error   = NULL;
+  connection->socket.on_close   = on_close;
+  connection->socket.on_timeout = NULL;
+  connection->socket.on_drain   = on_drain;
+  connection->socket.data       = connection;
+
+  ebb_request_parser_init(&connection->parser);
+  connection->parser.new_request = on_request;
+  connection->parser.data        = connection;
+
+  return &connection->socket;
+}
+
+
+// Reads a file into a v8 string.
+Handle<String> ReadFile
+  ( const string& name
+  ) 
+{
+  FILE* file = fopen(name.c_str(), "rb");
+  if (file == NULL) return Handle<String>();
+
+  fseek(file, 0, SEEK_END);
+  int size = ftell(file);
+  rewind(file);
+
+  char* chars = new char[size + 1];
+  chars[size] = '\0';
+  for (int i = 0; i < size;) {
+    int read = fread(&chars[i], 1, size - i, file);
+    i += read;
+  }
+  fclose(file);
+  Handle<String> result = String::New(chars, size);
+  delete[] chars;
+  return result;
+}
+
+void ParseOptions
+  ( int argc
+  , char* argv[]
+  , map<string, string>& options
+  , string* file
+  )
+{
+  for (int i = 1; i < argc; i++) {
+    string arg = argv[i];
+    int index = arg.find('=', 0);
+    if (index == string::npos) {
+      *file = arg;
+    } else {
+      string key = arg.substr(0, index);
+      string value = arg.substr(index+1);
+      options[key] = value;
+    }
+  }
+}
+
+int main 
+  ( int argc
+  , char *argv[]
+  ) 
+{
+  map<string, string> options;
+  string file;
+  ParseOptions(argc, argv, options, &file);
+  if (file.empty()) {
+    fprintf(stderr, "No script was specified.\n");
+    return 1;
+  }
+  HandleScope scope;
+  Handle<String> source = ReadFile(file);
+  if (source.IsEmpty()) {
+    fprintf(stderr, "Error reading '%s'.\n", file.c_str());
+    return 1;
+  }
+  /*
+  HttpRequestProcessor processor(source);
+  map<string, string> output;
+  if (!processor.Initialize(&options, &output)) {
+    fprintf(stderr, "Error initializing processor.\n");
+    return 1;
+  }
+  */
+
+  /////////////////////////////////////
+
+
+  loop = ev_default_loop(0);
+  
+  oi_server_init(&server, 1024);
+  server.on_connection = new_connection;
+
+  // get addrinfo for localhost, PORT
+  struct addrinfo *servinfo;
+  struct addrinfo hints;
+  memset(&hints, 0, sizeof hints);
+  hints.ai_family = AF_UNSPEC;
+  hints.ai_socktype = SOCK_STREAM;
+  hints.ai_flags = AI_PASSIVE;
+  int r = getaddrinfo(NULL, PORT, &hints, &servinfo);
+  assert(r == 0);
+
+  r = oi_server_listen(&server, servinfo);
+  assert(r == 0);
+
+  oi_server_attach(&server, loop);
+
+  printf("Running at http://localhost:%s/\n", PORT);
+
+  ev_loop(loop, 0);
+  return 0;
+}