CSE2410 Fall 2014 Bounce

EVDIR=$(HOME)/local/libev

OIINC = $(HOME)/projects/oi/

OILIB = $(HOME)/projects/oi/liboi.a

V8INC = $(HOME)/src/v8/include

#V8LIB = $(HOME)/src/v8/libv8_g.a

V8LIB = $(HOME)/src/v8/libv8.a

CFLAGS = -g -I$(V8INC) -I$(OIINC) -DHAVE_GNUTLS=0 -Ideps/ebb 

LDFLAGS = -lev -pthread # -lefence

ifdef EVDIR

	CFLAGS += -I$(EVDIR)/include

	LDFLAGS += -L$(EVDIR)/lib

endif

node: node.o node_tcp.o node_http.o node_timer.o ebb_request_parser.o

	g++ -o node $^ $(LDFLAGS) $(V8LIB) $(OILIB)

node.o: node.cc 

	g++ $(CFLAGS) -c $<

node_tcp.o: node_tcp.cc 

	g++ $(CFLAGS) -c $<

node_http.o: node_http.cc 

	g++ $(CFLAGS) -c $<

node_timer.o: node_timer.cc 

	g++ $(CFLAGS) -c $<

ebb_request_parser.o: ebb_request_parser.c deps/ebb/ebb_request_parser.h 

	g++ $(CFLAGS) -c $<

ebb_request_parser.c: deps/ebb/ebb_request_parser.rl

	ragel -s -G2 $< -o $@

PASS="\033[1;32mPASS\033[0m\n" 

FAIL="\033[1;31mFAIL\033[0m\n" 

test: node test/test_*

	@for i in test/test_*; do \

		if [ -x $$i ]; then \

			echo "\n\033[1m$$i\033[0m";	\

			./$$i && echo $(PASS) || echo $(FAIL); \

		fi \

	done 

clean:

	rm -f ebb_request_parser.c

	rm -f *.o 

	rm -f node

.PHONY: clean test

#include "node.h"

#include "node_tcp.h"

#include "node_http.h"

#include "node_timer.h"

#include <stdio.h>

#include <assert.h>

#include <string>

#include <list>

#include <map>

using namespace v8;

using namespace std;

static int exit_code = 0;

// Reads a file into a v8 string.

static 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[size+1];

  chars[size] = '\0';

  for (int i = 0; i < size;) {

    int read = fread(&chars[i], 1, size - i, file);

    if(read <= 0) {

      perror("read()");

    }

    i += read;

  }

  uint16_t expanded_base[size+1];

  expanded_base[size] = '\0';

  for(int i = 0; i < size; i++) 

    expanded_base[i] = chars[i];

  fclose(file);

  HandleScope scope;

  Local<String> result = String::New(expanded_base, size);

  return scope.Close(result);

}

static Handle<Value>

Log (const Arguments& args) 

{

  if (args.Length() < 1) return v8::Undefined();

  HandleScope scope;

  Handle<Value> arg = args[0];

  String::Utf8Value value(arg);

  printf("%s\n", *value);

  fflush(stdout);

  return Undefined();

}

static Handle<Value>

BlockingFileRead (const Arguments& args)

{

  if (args.Length() < 1) return v8::Undefined();

  HandleScope scope;

  String::Utf8Value filename(args[0]);

  Handle<String> output = ReadFile (*filename);

  return scope.Close(output);

}

static void

OnFatalError (const char* location, const char* message)

{

  fprintf(stderr, "Fatal error. %s %s\n", location, message);

  ev_unloop(node_loop(), EVUNLOOP_ALL);

}

// Extracts a C string from a V8 Utf8Value.

const char* ToCString(const v8::String::Utf8Value& value) {

  return *value ? *value : "<string conversion failed>";

}

void ReportException(v8::TryCatch* try_catch) {

  v8::HandleScope handle_scope;

  v8::String::Utf8Value exception(try_catch->Exception());

  const char* exception_string = ToCString(exception);

  v8::Handle<v8::Message> message = try_catch->Message();

  if (message.IsEmpty()) {

    // V8 didn't provide any extra information about this error; just

    // print the exception.

    printf("%s\n", exception_string);

  } else {

    message->PrintCurrentStackTrace(stdout);

    // Print (filename):(line number): (message).

    v8::String::Utf8Value filename(message->GetScriptResourceName());

    const char* filename_string = ToCString(filename);

    int linenum = message->GetLineNumber();

    printf("%s:%i: %s\n", filename_string, linenum, exception_string);

    // Print line of source code.

    v8::String::Utf8Value sourceline(message->GetSourceLine());

    const char* sourceline_string = ToCString(sourceline);

    printf("%s\n", sourceline_string);

    // Print wavy underline (GetUnderline is deprecated).

    int start = message->GetStartColumn();

    for (int i = 0; i < start; i++) {

      printf(" ");

    }

    int end = message->GetEndColumn();

    for (int i = start; i < end; i++) {

      printf("^");

    }

    printf("\n");

  }

}

void

node_fatal_exception (TryCatch &try_catch)

{

  ReportException(&try_catch);

  ev_unloop(node_loop(), EVUNLOOP_ALL);

  exit_code = 1;

}

// Executes a string within the current v8 context.

bool ExecuteString(v8::Handle<v8::String> source,

                   v8::Handle<v8::Value> name,

                   bool print_result,

                   bool report_exceptions) {

  v8::HandleScope handle_scope;

  v8::TryCatch try_catch;

  v8::Handle<v8::Script> script = v8::Script::Compile(source, name);

  if (script.IsEmpty()) {

    // Print errors that happened during compilation.

    if (report_exceptions)

      ReportException(&try_catch);

    return false;

  } else {

    v8::Handle<v8::Value> result = script->Run();

    if (result.IsEmpty()) {

      // Print errors that happened during execution.

      if (report_exceptions)

        ReportException(&try_catch);

      return false;

    } else {

      if (print_result && !result->IsUndefined()) {

        // If all went well and the result wasn't undefined then print

        // the returned value.

        v8::String::Utf8Value str(result);

        const char* cstr = ToCString(str);

        printf("%s\n", cstr);

      }

      return true;

    }

  }

}

// The callback that is invoked by v8 whenever the JavaScript 'load'

// function is called.  Loads, compiles and executes its argument

// JavaScript file.

v8::Handle<v8::Value> Load(const v8::Arguments& args) {

  for (int i = 0; i < args.Length(); i++) {

    v8::HandleScope handle_scope;

    v8::String::Utf8Value file(args[i]);

    if (*file == NULL) {

      return v8::ThrowException(v8::String::New("Error loading file"));

    }

    v8::Handle<v8::String> source = ReadFile(*file);

    if (source.IsEmpty()) {

      return v8::ThrowException(v8::String::New("Error loading file"));

    }

    if (!ExecuteString(source, v8::String::New(*file), false, true)) {

      return v8::ThrowException(v8::String::New("Error executing file"));

    }

  }

  return v8::Undefined();

}

int

main (int argc, char *argv[]) 

{

  V8::SetFlagsFromCommandLine(&argc, argv, true);

  if(argc != 2)  {

    fprintf(stderr, "No script was specified.\n");

    return 1;

  }

  string filename(argv[1]);

  HandleScope handle_scope;

  Persistent<Context> context = Context::New(NULL, ObjectTemplate::New());

  Context::Scope context_scope(context);

  Local<Object> g = Context::GetCurrent()->Global();

  g->Set ( String::New("log")

         , FunctionTemplate::New(Log)->GetFunction()

         );

  g->Set ( String::New("load")

         , FunctionTemplate::New(Load)->GetFunction()

         );

  g->Set ( String::New("blockingFileRead")

         , FunctionTemplate::New(BlockingFileRead)->GetFunction()

         );

  Init_timer(g);

  Init_tcp(g);

  Init_http(g);

  V8::SetFatalErrorHandler(OnFatalError);

  v8::Handle<v8::String> source = ReadFile(filename);

  ExecuteString(source, String::New(filename.c_str()), false, true);

  ev_loop(node_loop(), 0);

  context.Dispose();

  return exit_code;

}

#ifndef node_h

#define node_h

#include <ev.h>

#include <v8.h>

void node_fatal_exception (v8::TryCatch &try_catch); 

#define node_loop() ev_default_loop(0)

#endif // node_h

#include "node_http.h"

#include "node.h"

#include <oi_socket.h>

#include <ebb_request_parser.h>

#include <string>

#include <list>

using namespace v8;

using namespace std;

static Persistent<ObjectTemplate> request_template;

// globals

static Persistent<String> path_str; 

static Persistent<String> uri_str; 

static Persistent<String> query_string_str; 

static Persistent<String> fragment_str; 

static Persistent<String> method_str; 

static Persistent<String> http_version_str; 

static Persistent<String> headers_str; 

static Persistent<String> on_request_str; 

static Persistent<String> on_body_str; 

static Persistent<String> respond_str; 

static Persistent<String> copy_str;

static Persistent<String> delete_str;

static Persistent<String> get_str;

static Persistent<String> head_str;

static Persistent<String> lock_str;

static Persistent<String> mkcol_str;

static Persistent<String> move_str;

static Persistent<String> options_str;

static Persistent<String> post_str;

static Persistent<String> propfind_str;

static Persistent<String> proppatch_str;

static Persistent<String> put_str;

static Persistent<String> trace_str;

static Persistent<String> unlock_str;

#define INVALID_STATE_ERR 1

class Server {

public:

  Server (Handle<Object> _js_server);

  ~Server ();

  int Start(struct addrinfo *servinfo);

  void Stop();

  Handle<Value> Callback()

  {

    HandleScope scope;

    Handle<Value> value = js_server->Get(on_request_str);

    return scope.Close(value);

  }

private:

  oi_server server;

  Persistent<Object> js_server;

};

class HttpRequest;

class Connection {

public:

  Connection();

  ~Connection();

  void Parse(const void *buf, size_t count);

  void Write();

  void Close();

  void AddRequest (HttpRequest *request);

  oi_socket socket;

  Persistent<Function> js_onrequest;

private:

  ebb_request_parser parser;

  list<HttpRequest*> requests;

  list<HttpRequest*> finished_requests;

  friend class Server;

};

class HttpRequest {

 public:

  HttpRequest (Connection &c);

  /* Deleted from C++ as soon as possible.

   * Javascript object might linger. This is okay

   */

  ~HttpRequest();

  void MakeBodyCallback (const char *base, size_t length);

  Local<Object> CreateJSObject ();

  void Respond (Handle<Value> data);

  string path;

  string query_string;

  string fragment;

  string uri;

  list<string> header_fields;

  list<string> header_values;

  Connection &connection;

  ebb_request parser_info;

  list<oi_buf*> output;

  bool done;

  Persistent<Object> js_object;

};

static Handle<Value>

GetMethodString (int method)

{

  switch(method) {

    case EBB_COPY:      return copy_str;

    case EBB_DELETE:    return delete_str;

    case EBB_GET:       return get_str;

    case EBB_HEAD:      return head_str;

    case EBB_LOCK:      return lock_str;

    case EBB_MKCOL:     return mkcol_str;

    case EBB_MOVE:      return move_str;

    case EBB_OPTIONS:   return options_str;

    case EBB_POST:      return post_str;

    case EBB_PROPFIND:  return propfind_str;

    case EBB_PROPPATCH: return proppatch_str;

    case EBB_PUT:       return put_str;

    case EBB_TRACE:     return trace_str;

    case EBB_UNLOCK:    return unlock_str;

  }

  return Null();

}

static Handle<Value>

RespondCallback (const Arguments& args) 

{

  HandleScope scope;

  Handle<Value> v = args.Holder()->GetInternalField(0);

  if(v->IsUndefined()) {

    // check that args.Holder()->GetInternalField(0)

    // is not NULL if so raise INVALID_STATE_ERR

    printf("null request external\n");

    ThrowException(Integer::New(INVALID_STATE_ERR)); 

    return Undefined();

  }

  Handle<External> field = Handle<External>::Cast(v);

  HttpRequest* request = static_cast<HttpRequest*>(field->Value());

  request->Respond(args[0]);

  return Undefined();

}

void

HttpRequest::Respond (Handle<Value> data)

{

  if(data == Null()) {

    done = true;

  } else {

    Handle<String> s = data->ToString();

    oi_buf *buf = oi_buf_new2(s->Length());

    uint16_t expanded[s->Length()];

    s->Write(expanded, 0, s->Length());

    for(int i = 0; i < s->Length(); i++) {

      buf->base[i] = expanded[i];

    }

    output.push_back(buf);

  }

  connection.Write();

}

static void

on_path (ebb_request *req, const char *buf, size_t len)

{

  HttpRequest *request = static_cast<HttpRequest*> (req->data);

  request->path.append(buf, len);

}

static void

on_uri (ebb_request *req, const char *buf, size_t len)

{

  HttpRequest *request = static_cast<HttpRequest*> (req->data);

  request->uri.append(buf, len);

}

static void

on_query_string (ebb_request *req, const char *buf, size_t len)

{

  HttpRequest *request = static_cast<HttpRequest*> (req->data);

  request->query_string.append(buf, len);

}

static void

on_fragment (ebb_request *req, const char *buf, size_t len)

{

  HttpRequest *request = static_cast<HttpRequest*> (req->data);

  request->fragment.append(buf, len);

}

static const char upcase[] =

  "\0______________________________"

  "_________________0123456789_____"

  "__ABCDEFGHIJKLMNOPQRSTUVWXYZ____"

  "__ABCDEFGHIJKLMNOPQRSTUVWXYZ____"

  "________________________________"

  "________________________________"

  "________________________________"

  "________________________________";

static void

on_header_field (ebb_request *req, const char *buf, size_t len, int header_index)

{

  HttpRequest *request = static_cast<HttpRequest*> (req->data);

  char upbuf[len];

  for(int i = 0; i < len; i++) 

    upbuf[i] = upcase[buf[i]];

  if( request->header_fields.size() == header_index - 1) {

    request->header_fields.back().append(upbuf, len);

  } else { 

    request->header_fields.push_back( string(upbuf, len) );

  }

}

static void

on_header_value (ebb_request *req, const char *buf, size_t len, int header_index)

{

  HttpRequest *request = static_cast<HttpRequest*> (req->data);

  if( request->header_values.size() == header_index - 1) {

    request->header_values.back().append(buf, len);

  } else { 

    request->header_values.push_back( string(buf, len) );

  }

}

static void

on_headers_complete (ebb_request *req)

{

  HttpRequest *request = static_cast<HttpRequest*> (req->data);

  HandleScope scope;

  Handle<Object> js_request = request->CreateJSObject();

  // 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] = { js_request };

  Handle<Value> r = request->connection.js_onrequest->Call(Context::GetCurrent()->Global(), argc, argv);

  if(try_catch.HasCaught())

    node_fatal_exception(try_catch);

}

static void

on_request_complete (ebb_request *req)

{

  HttpRequest *request = static_cast<HttpRequest*> (req->data);

  request->MakeBodyCallback(NULL, 0); // EOF

}

static void

on_body (ebb_request *req, const char *base, size_t length)

{

  HttpRequest *request = static_cast<HttpRequest*> (req->data);

  if(length)

    request->MakeBodyCallback(base, length);

}

static ebb_request * on_request

  ( void *data

  ) 

{

  Connection *connection = static_cast<Connection*> (data);

  HttpRequest *request = new HttpRequest(*connection);

  connection->AddRequest(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);

  if(count == 0) {

    connection->Close();

  } else {

    //write(1, buf, count);

    connection->Parse(buf, count);  

  }

}

static void on_close 

  ( oi_socket *socket

  )

{

  Connection *connection = static_cast<Connection*> (socket->data);

  delete connection;

}

HttpRequest::~HttpRequest ()

{

  HandleScope scope; // needed?

  // delete a reference c++ HttpRequest

  js_object->SetInternalField(0, Undefined());

  js_object->Delete(respond_str);

  // dispose of Persistent handle so that 

  // it can be GC'd normally.

  js_object.Dispose();

}

HttpRequest::HttpRequest (Connection &c) : connection(c)

{

  ebb_request_init(&parser_info); 

  parser_info.on_path             = on_path;

  parser_info.on_query_string     = on_query_string;

  parser_info.on_uri              = on_uri;

  parser_info.on_fragment         = on_fragment;

  parser_info.on_header_field     = on_header_field;

  parser_info.on_header_value     = on_header_value;

  parser_info.on_headers_complete = on_headers_complete;

  parser_info.on_body             = on_body;

  parser_info.on_complete         = on_request_complete;

  parser_info.data                = this;

  done = false;

}

void

HttpRequest::MakeBodyCallback (const char *base, size_t length)

{

  HandleScope handle_scope;

  Handle<Value> onbody_val = js_object->Get(on_body_str);  

  if (!onbody_val->IsFunction()) return;

  Handle<Function> onbody = Handle<Function>::Cast(onbody_val);

  TryCatch try_catch;

  const int argc = 1;

  Handle<Value> argv[argc];

  if(length) {

    // TODO ByteArray?

    //

    uint16_t expanded_base[length];

    for(int i = 0; i < length; i++) {

      expanded_base[i] = base[i];

    }

    Handle<String> chunk = String::New(expanded_base, length);

    argv[0] = chunk;

  } else {

    argv[0] = Null();

  }

  Handle<Value> result = onbody->Call(js_object, argc, argv);

  if(try_catch.HasCaught())

    node_fatal_exception(try_catch);

}

Local<Object>

HttpRequest::CreateJSObject ()

{

  HandleScope scope;

  if (request_template.IsEmpty()) {

    Handle<ObjectTemplate> raw_template = ObjectTemplate::New();

    raw_template->SetInternalFieldCount(1);

    raw_template->Set(respond_str, FunctionTemplate::New(RespondCallback));

    request_template = Persistent<ObjectTemplate>::New(raw_template);

  }

  // Create an empty http request wrapper.

  Handle<Object> result = request_template->NewInstance();

  // Wrap the raw C++ pointer in an External so it can be referenced

  // from within JavaScript.

  Handle<External> request_ptr = External::New(this);

  // Store the request pointer in the JavaScript wrapper.

  result->SetInternalField(0, request_ptr);

  result->Set ( path_str

              , String::New(path.c_str(), path.length())

              );

  result->Set ( uri_str

              , String::New(uri.c_str(), uri.length())

              );

  result->Set ( query_string_str

              , String::New(query_string.c_str(), query_string.length())

              );

  result->Set ( fragment_str

              , String::New(fragment.c_str(), fragment.length())

              );

  result->Set ( method_str

              , GetMethodString(parser_info.method)

              );

  char version[10];

  snprintf ( version

           , 10 // big enough? :)

           , "%d.%d"

           , parser_info.version_major

           , parser_info.version_minor

           ); 

  result->Set ( http_version_str

              , String::New(version)

              );

  Handle<Object> headers = Object::New();

  list<string>::iterator field_iterator = header_fields.begin();

  list<string>::iterator value_iterator = header_values.begin();

  while( value_iterator != header_values.end() ) {

    string &f = *field_iterator;

    string &v = *value_iterator;

    headers->Set( String::NewSymbol(f.c_str(), f.length())

                , String::New(v.c_str(), v.length() ) 

                );

    field_iterator++;

    value_iterator++;

  }

  result->Set(headers_str, headers);

  js_object = Persistent<Object>::New(result);

  // XXX does the request's js_object need a MakeWeak callback?

  // i dont think so because at some point the connection closes

  // and we're going to delete the request. 

  return scope.Close(result);

}

static oi_socket*

on_connection (oi_server *_server, struct sockaddr *addr, socklen_t len)

{

  HandleScope scope;

  Server *server = static_cast<Server*> (_server->data);

  Handle<Value> callback_v = server->Callback();

  if(callback_v == Undefined())

    return NULL;

  Connection *connection = new Connection();

  Handle<Function> f = Handle<Function>::Cast(callback_v);

  connection->js_onrequest = Persistent<Function>::New(f);

  return &connection->socket;

}

Connection::Connection ()

{

  oi_socket_init (&socket, 30.0); // TODO make timeout adjustable

  socket.on_read    = on_read;

  socket.on_error   = NULL;

  socket.on_close   = on_close;

  socket.on_timeout = NULL;

  socket.on_drain   = NULL;

  socket.data       = this;

  ebb_request_parser_init (&parser);

  parser.new_request = on_request;

  parser.data        = this;

}

Connection::~Connection ()

{

  list<HttpRequest*>::iterator it = requests.begin();

  // delete all the requests

  for(it = requests.begin(); it != requests.end(); it++)

    delete *it;

  for(it = finished_requests.begin(); it != finished_requests.end(); it++)

    delete *it;

}

void

Connection::Parse(const void *buf, size_t count)

{

  // FIXME change ebb_request_parser to have void* arg

  ebb_request_parser_execute ( &parser

                             , static_cast<const char*> (buf) 

                             , count

                             );

  if(ebb_request_parser_has_error(&parser)) {

    fprintf(stderr, "parse error closing connection\n");

    oi_socket_close(&socket);

  }

}

void 

Connection::AddRequest(HttpRequest *request)

{

  requests.push_back(request);

}

void

Connection::Write ( ) 

{

  if(requests.size() == 0)

    return;

  HttpRequest *request = requests.front(); 

  while(request->output.size() > 0) {

    oi_buf *buf = request->output.front();

    oi_socket_write(&socket, buf);

    request->output.pop_front();

  }

  if(request->done) {

    if(!ebb_request_should_keep_alive(&request->parser_info)) {

      socket.on_drain = oi_socket_close;

    } 

    requests.pop_front();

    finished_requests.push_back(request);

    Write();

  }

}

void

Connection::Close ( ) 

{

  oi_socket_close(&socket);

}

static void

server_destroy (Persistent<Value> _, void *data)

{

  Server *server = static_cast<Server *> (data);

  delete server;

}

Server::Server (Handle<Object> _js_server)

{

  oi_server_init(&server, 1024);

  server.on_connection = on_connection;

  server.data = this;

  HandleScope scope;

  js_server = Persistent<Object>::New (_js_server);

  // are we ever going to need this external?

  js_server->SetInternalField (0, External::New(this));

  js_server.MakeWeak (this, server_destroy);

}

Server::~Server ()

{

  Stop();

  js_server.Dispose();

  js_server.Clear(); // necessary? 

}

int

Server::Start(struct addrinfo *servinfo) 

{

  int r = oi_server_listen(&server, servinfo);

  if(r == 0)

    oi_server_attach(&server, node_loop());

  return r;

}

void

Server::Stop() 

{

  oi_server_close (&server);

  oi_server_detach (&server);

}

/* This constructor takes 2 arguments: host, port. */

static Handle<Value>

newHTTPServer (const Arguments& args) 

{

  if (args.Length() < 3)

    return Undefined();

  HandleScope scope;

  char *host = NULL; 

  String::AsciiValue host_v(args[0]->ToString());

  if(args[0]->IsString()) {

    host = *host_v;

  }

  String::AsciiValue port(args[1]->ToString());

  Handle<Function> onrequest = Handle<Function>::Cast(args[2]);

  args.This()->Set(on_request_str, onrequest);

  // 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;

  // FIXME BLOCKING

  int r = getaddrinfo(host, *port, &hints, &servinfo);

  if (r != 0)

    return Undefined(); // XXX raise error?

  //

  //

  //

  // TODO host is ignored for now assumed localhost

  //

  //

  //

  //

  Server *server = new Server(args.This());

  if(server == NULL)

    return Undefined(); // XXX raise error?

  r = server->Start(servinfo);

  if (r != 0)

    return Undefined(); // XXX raise error?

  return args.This();

}

void

Init_http (Handle<Object> target)

{

  HandleScope scope;

  Local<FunctionTemplate> server_t = FunctionTemplate::New(newHTTPServer);

  server_t->InstanceTemplate()->SetInternalFieldCount(1);

  server_t->Set("INVALID_STATE_ERR", Integer::New(INVALID_STATE_ERR));

  target->Set(String::New("HTTPServer"), server_t->GetFunction());

  path_str         = Persistent<String>::New( String::NewSymbol("path") );

  uri_str          = Persistent<String>::New( String::NewSymbol("uri") );

  query_string_str = Persistent<String>::New( String::NewSymbol("query_string") );

  fragment_str     = Persistent<String>::New( String::NewSymbol("fragment") );

  method_str       = Persistent<String>::New( String::NewSymbol("method") );

  http_version_str = Persistent<String>::New( String::NewSymbol("http_version") );

  headers_str      = Persistent<String>::New( String::NewSymbol("headers") );

  on_request_str = Persistent<String>::New( String::NewSymbol("onrequest") );

  on_body_str    = Persistent<String>::New( String::NewSymbol("onbody") );

  respond_str    = Persistent<String>::New( String::NewSymbol("respond") );

  copy_str      = Persistent<String>::New( String::New("COPY") );

  delete_str    = Persistent<String>::New( String::New("DELETE") );

  get_str       = Persistent<String>::New( String::New("GET") );

  head_str      = Persistent<String>::New( String::New("HEAD") );

  lock_str      = Persistent<String>::New( String::New("LOCK") );

  mkcol_str     = Persistent<String>::New( String::New("MKCOL") );

  move_str      = Persistent<String>::New( String::New("MOVE") );

  options_str   = Persistent<String>::New( String::New("OPTIONS") );

  post_str      = Persistent<String>::New( String::New("POST") );

  propfind_str  = Persistent<String>::New( String::New("PROPFIND") );

  proppatch_str = Persistent<String>::New( String::New("PROPPATCH") );

  put_str       = Persistent<String>::New( String::New("PUT") );

  trace_str     = Persistent<String>::New( String::New("TRACE") );

  unlock_str    = Persistent<String>::New( String::New("UNLOCK") );

}

#ifndef node_http_h

#define node_http_h

#include <v8.h>

void Init_http (v8::Handle<v8::Object> target);

#endif

#include "node_tcp.h"

#include "node.h"

#include <oi_socket.h>

#include <oi_buf.h>

#include <assert.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netdb.h>

using namespace v8;

static Persistent<String> readyState_str; 

static Persistent<Integer> readyState_CONNECTING; 

static Persistent<Integer> readyState_OPEN; 

static Persistent<Integer> readyState_CLOSED; 

enum readyState { READY_STATE_CONNECTING = 0

                , READY_STATE_OPEN       = 1

                , READY_STATE_CLOSED     = 2

                } ;

class TCPClient {

public:

  TCPClient(Handle<Object> obj);

  ~TCPClient();

  int Connect(char *host, char *port);

  void Write (Handle<Value> arg);

  void Disconnect();

  void OnOpen();

  void OnRead(const void *buf, size_t count);

  void OnClose();

private:

  int ReadyState();

  oi_socket socket;

  struct addrinfo *address;

  Persistent<Object> js_client;

};

static void

on_connect (oi_socket *socket)

{

  TCPClient *client = static_cast<TCPClient*> (socket->data);

  client->OnOpen();

}

static void

on_close (oi_socket *socket)

{

  TCPClient *client = static_cast<TCPClient*> (socket->data);

  client->OnClose();

}

static void

on_read (oi_socket *socket, const void *buf, size_t count)

{

  TCPClient *client = static_cast<TCPClient*> (socket->data);

  client->OnRead(buf, count);

}

static struct addrinfo tcp_hints = 

/* ai_flags      */ { AI_PASSIVE

/* ai_family     */ , AF_UNSPEC

/* ai_socktype   */ , SOCK_STREAM

/* ai_protocol   */ , 0

/* ai_addrlen    */ , 0

/* ai_addr       */ , 0

/* ai_canonname  */ , 0

/* ai_next       */ , 0

                    };

static Handle<Value> newTCPClient

  ( const Arguments& args

  ) 

{

  if (args.Length() < 1)

    return Undefined();

  HandleScope scope;

  char *host = NULL; 

  String::AsciiValue host_v(args[0]->ToString());

  if(args[0]->IsString()) {

    host = *host_v;

  }

  String::AsciiValue port(args[1]);

  TCPClient *client = new TCPClient(args.This());

  if(client == NULL)

    return Undefined(); // XXX raise error?

  int r = client->Connect(host, *port);

  if (r != 0)

    return Undefined(); // XXX raise error?

  return args.This();

}

static TCPClient*

UnwrapClient (Handle<Object> obj) 

{

  HandleScope scope;

  Handle<External> field = Handle<External>::Cast(obj->GetInternalField(0));

  TCPClient* client = static_cast<TCPClient*>(field->Value());

  return client;

}

static Handle<Value>

WriteCallback (const Arguments& args) 

{

  HandleScope scope;

  TCPClient *client = UnwrapClient(args.Holder());

  client->Write(args[0]);

  return Undefined();

}

static Handle<Value>

DisconnectCallback (const Arguments& args) 

{

  HandleScope scope;

  TCPClient *client = UnwrapClient(args.Holder());

  client->Disconnect();

  return Undefined();

}

static void

client_destroy (Persistent<Value> _, void *data)

{

  TCPClient *client = static_cast<TCPClient *> (data);

  delete client;

}

TCPClient::TCPClient(Handle<Object> _js_client)

{

  oi_socket_init(&socket, 30.0); // TODO adjustable timeout

  socket.on_connect = on_connect;

  socket.on_read    = on_read;

  socket.on_drain   = NULL;

  socket.on_error   = NULL;

  socket.on_close   = on_close;

  socket.on_timeout = on_close;

  socket.data = this;

  HandleScope scope;

  js_client = Persistent<Object>::New(_js_client);

  js_client->SetInternalField (0, External::New(this));

  js_client.MakeWeak (this, client_destroy);

}

TCPClient::~TCPClient ()

{

  Disconnect();

  oi_socket_detach (&socket);

  js_client.Dispose();

  js_client.Clear(); // necessary? 

}

int

TCPClient::Connect(char *host, char *port)

{

  int r;

  HandleScope scope;

  js_client->Set(readyState_str, readyState_CONNECTING);

  /* FIXME Blocking DNS resolution. Use oi_async. */

  printf("resolving host: %s, port: %s\n", host, port);

  r = getaddrinfo (host, port, &tcp_hints, &address);

  if(r != 0)  {

    perror("getaddrinfo");

    return r;

  }

  r = oi_socket_connect (&socket, address);

  if(r != 0)  {

    perror("oi_socket_connect");

    return r;

  }

  oi_socket_attach (&socket, node_loop());

  freeaddrinfo(address);

  address = NULL;

}

void TCPClient::Write (Handle<Value> arg)

{

  HandleScope scope;

  //

  // TODO if ReadyState() is not READY_STATE_OPEN then raise INVALID_STATE_ERR

  //

  if(arg == Null()) {

    oi_socket_write_eof(&socket);

  } else {

    Local<String> s = arg->ToString();

    oi_buf *buf = oi_buf_new2(s->Length());

    s->WriteAscii(buf->base, 0, s->Length());

    oi_socket_write(&socket, buf);

  }

}

int

TCPClient::ReadyState()

{

  return js_client->Get(readyState_str)->IntegerValue();

}

void

TCPClient::Disconnect()

{

  oi_socket_close(&socket);

}

void

TCPClient::OnOpen()

{

  HandleScope scope;

  assert(READY_STATE_CONNECTING == ReadyState());

  js_client->Set(readyState_str, readyState_OPEN);

  Handle<Value> onopen_value = js_client->Get( String::NewSymbol("onopen") );

  if (!onopen_value->IsFunction())

    return; 

  Handle<Function> onopen = Handle<Function>::Cast(onopen_value);

  TryCatch try_catch;

  Handle<Value> r = onopen->Call(js_client, 0, NULL);

  if(try_catch.HasCaught())

    node_fatal_exception(try_catch);

}

void

TCPClient::OnRead(const void *buf, size_t count)

{

  HandleScope scope;

  assert(READY_STATE_OPEN == ReadyState());

  Handle<Value> onread_value = js_client->Get( String::NewSymbol("onread") );

  if (!onread_value->IsFunction()) return; 

  Handle<Function> onread = Handle<Function>::Cast(onread_value);

  const int argc = 1;

  Handle<Value> argv[argc];

  if(count) {

    Handle<String> chunk = String::New((const char*)buf, count); // TODO binary data?

    argv[0] = chunk;

  } else {

    // TODO eof? delete write method?

    argv[0] = Null();

  }

  TryCatch try_catch;