{

public:

RubyHttpConnection_t (VALUE v): Myself(v) {}

virtual ~RubyHttpConnection_t() {}

virtual void SendData (const char*, int);

virtual void CloseConnection (bool after_writing);

virtual void ProcessRequest (const char *request_method,

const char *cookie,

const char *ifnonematch,

const char *contenttype,

const char *query_string,

const char *path_info,

const char *request_uri,

const char *protocol,

int postlength,

const char *postdata,

const char *hdrblock,

int hdrblocksize);

virtual void ReceivePostData (const char *data, int len);

private:

VALUE Myself;

{

VALUE v = rb_intern (after_writing ? "close_connection_after_writing" : "close_connection");

rb_funcall (Myself, v, 0);

{

VALUE data_val = Qnil;

if ((len > 0) && data) {

data_val = rb_str_new(data,len);

rb_funcall (Myself, rb_intern ("receive_post_data"), 1, data_val);

}

const char *cookie,

const char *ifnonematch,

const char *contenttype,

const char *query_string,

const char *path_info,

const char *request_uri,

const char *protocol,

int post_length,

const char *post_content,

const char *hdr_block,

int hdr_block_size)

{

VALUE post = Qnil;

VALUE headers = Qnil;

VALUE req_method = Qnil;

VALUE cookie_val = Qnil;

VALUE ifnonematch_val = Qnil;

VALUE contenttype_val = Qnil;

VALUE path_info_val = Qnil;

VALUE query_string_val = Qnil;

VALUE request_uri_val = Qnil;

VALUE protocol_val = Qnil;

if ((post_length > 0) && post_content)

post = rb_str_new (post_content, post_length);

if (hdr_block && (hdr_block_size > 0))

headers = rb_str_new (hdr_block, hdr_block_size);

else

headers = rb_str_new ("", 0);

if (request_method && *request_method)

req_method = rb_str_new (request_method, strlen (request_method));

if (cookie && *cookie)

cookie_val = rb_str_new (cookie, strlen (cookie));

if (ifnonematch && *ifnonematch)

ifnonematch_val = rb_str_new (ifnonematch, strlen (ifnonematch));

if (contenttype && *contenttype)

contenttype_val = rb_str_new (contenttype, strlen (contenttype));

if (path_info && *path_info)

path_info_val = rb_str_new (path_info, strlen (path_info));

if (query_string && *query_string)

query_string_val = rb_str_new (query_string, strlen (query_string));

if (request_uri && *request_uri)

request_uri_val = rb_str_new (request_uri, strlen (request_uri));

if (protocol && *protocol)

protocol_val = rb_str_new (protocol, strlen (protocol));

rb_ivar_set (Myself, rb_intern ("@http_request_method"), req_method);

rb_ivar_set (Myself, rb_intern ("@http_cookie"), cookie_val);

rb_ivar_set (Myself, rb_intern ("@http_if_none_match"), ifnonematch_val);

rb_ivar_set (Myself, rb_intern ("@http_content_type"), contenttype_val);

rb_ivar_set (Myself, rb_intern ("@http_path_info"), path_info_val);

rb_ivar_set (Myself, rb_intern ("@http_request_uri"), request_uri_val);

rb_ivar_set (Myself, rb_intern ("@http_query_string"), query_string_val);

rb_ivar_set (Myself, rb_intern ("@http_post_content"), post);

rb_ivar_set (Myself, rb_intern ("@http_headers"), headers);

rb_ivar_set (Myself, rb_intern ("@http_protocol"), protocol_val);

rb_funcall (Myself, rb_intern ("process_http_request"), 0);

{

RubyHttpConnection_t *hc = new RubyHttpConnection_t (self);

if (!hc)

throw std::runtime_error ("no http-connection object");

rb_ivar_set (self, Intern_http_conn, LONG2NUM ((long)hc));

return Qnil;

{

int length = NUM2INT (rb_funcall (data, rb_intern ("length"), 0));

RubyHttpConnection_t *hc = (RubyHttpConnection_t*)(NUM2LONG (rb_ivar_get (self, Intern_http_conn)));

if (hc)

hc->ConsumeData (StringValuePtr (data), length);

return Qnil;

{

/** This is a NOOP. It should be overridden. **/

return Qnil;

{

RubyHttpConnection_t *hc = (RubyHttpConnection_t*)(NUM2LONG (rb_ivar_get (self, Intern_http_conn)));

if (hc)

delete hc;

return Qnil;

{

// This is a stub in case the caller doesn't define it.

rb_funcall (self, rb_intern ("send_data"), 1, rb_str_new2 ("HTTP/1.1 200 ...\r\nContent-type: text/plain\r\nContent-length: 8\r\n\r\nMonorail"));

return Qnil;

{

RubyHttpConnection_t *hc = (RubyHttpConnection_t*)(NUM2LONG (rb_ivar_get (self, Intern_http_conn)));

if (hc)

hc->SetNoEnvironmentStrings();

return Qnil;

{

RubyHttpConnection_t *hc = (RubyHttpConnection_t*)(NUM2LONG (rb_ivar_get (self, Intern_http_conn)));

if (hc)

hc->SetDontAccumulatePost();

return Qnil;

{

Intern_http_conn = rb_intern ("http_conn");

VALUE EmModule = rb_define_module ("EventMachine");

VALUE HttpServer = rb_define_module_under (EmModule, "HttpServer");

rb_define_method (HttpServer, "post_init", (VALUE(*)(...))t_post_init, 0);

rb_define_method (HttpServer, "receive_data", (VALUE(*)(...))t_receive_data, 1);

rb_define_method (HttpServer, "receive_post_data", (VALUE(*)(...))t_receive_post_data, 1);

rb_define_method (HttpServer, "unbind", (VALUE(*)(...))t_unbind, 0);

rb_define_method (HttpServer, "process_http_request", (VALUE(*)(...))t_process_http_request, 0);

rb_define_method (HttpServer, "no_environment_strings", (VALUE(*)(...))t_no_environment_strings, 0);

rb_define_method (HttpServer, "dont_accumulate_post", (VALUE(*)(...))t_dont_accumulate_post, 0);