eventmachine_httpserver 0.0.1

data/ext/http.h

@@ -0,0 +1,117 @@
+/*****************************************************************************
+
+$Id: http.h 3966 2007-03-16 11:52:05Z francis $
+
+File:     http.h
+Date:     21Apr06
+
+Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+Gmail: garbagecat10
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*****************************************************************************/
+
+
+#ifndef __HttpPersonality__H_
+#define __HttpPersonality__H_
+
+
+
+/**********************
+class HttpConnection_t
+**********************/
+
+class HttpConnection_t
+{
+	public:
+		HttpConnection_t();
+		virtual ~HttpConnection_t();
+
+		void ConsumeData (const char*, int);
+
+		virtual void SendData (const char*, int);
+		virtual void CloseConnection (bool after_writing);
+		virtual void ProcessRequest (const char *method,
+				const char *cookie,
+				const char *ifnonematch,
+				const char *content_type,
+				const char *query_string,
+				const char *path_info,
+				const char *request_uri,
+				const char *protocol,
+				int postlength,
+				const char *postdata,
+				const char* hdrblock,
+				int hdrblksize);
+
+		virtual void ReceivePostData(const char *data, int len);
+		virtual void SetNoEnvironmentStrings() {bSetEnvironmentStrings = false;}
+		virtual void SetDontAccumulatePost() {bAccumulatePost = false;}
+
+  private:
+
+		enum {
+			BaseState,
+			PreheaderState,
+			HeaderState,
+			ReadingContentState,
+			DispatchState,
+			EndState
+		} ProtocolState;
+
+		enum {
+			MaxLeadingBlanks = 12,
+			MaxHeaderLineLength = 8 * 1024,
+			MaxContentLength = 20 * 1024 * 1024,
+			HeaderBlockSize = 16 * 1024
+		};
+		int nLeadingBlanks;
+
+		char HeaderLine [MaxHeaderLineLength];
+		int HeaderLinePos;
+
+		char HeaderBlock [HeaderBlockSize];
+		int HeaderBlockPos;
+
+		int ContentLength;
+		int ContentPos;
+		char *_Content;
+
+		bool bSetEnvironmentStrings;
+		bool bAccumulatePost;
+		bool bRequestSeen;
+		bool bContentLengthSeen;
+
+		const char *RequestMethod;
+		std::string Cookie;
+		std::string IfNoneMatch;
+		std::string ContentType;
+		std::string PathInfo;
+		std::string RequestUri;
+		std::string QueryString;
+		std::string Protocol;
+
+	private:
+		bool _InterpretHeaderLine (const char*);
+		bool _InterpretRequest (const char*);
+		bool _DetectVerbAndSetEnvString (const char*, int);
+		void _SendError (int);
+};
+
+#endif // __HttpPersonality__H_
+
+
+

data/ext/ptch

@@ -0,0 +1,148 @@
+                                                                     
+                                                                     
+                                                                     
+                                             
+--- http.cpp	1969-12-31 18:00:00.000000000 -0600
++++ /usr/local/ruby185/lib/ruby/gems/1.8/gems/eventmachine_httpserver-0.0.1/ext/http.cpp	2007-03-10 08:13:24.000000000 -0600
+@@ -29,6 +29,7 @@
+ #include <string>
+ #include <sstream>
+ #include <stdexcept>
++#include <stdio.h>
+ 
+ #ifdef OS_WIN32
+ #include <windows.h>
+@@ -66,6 +67,7 @@
+ 	// (This is primarily beneficial because it lets the caller use Ruby's CGI classes.)
+ 	// The caller can switch this off in Ruby code, which greatly improves performance.
+ 	bSetEnvironmentStrings = true;
++	bAccumulatePost = true;
+ }
+ 
+ 
+@@ -112,6 +114,7 @@
+ 		const char *query_string,
+ 		const char *path_info,
+ 		const char *request_uri,
++		const char *protocol,
+ 		int post_length,
+ 		const char *post_content,
+ 		const char *hdrblock,
+@@ -121,7 +124,14 @@
+ }
+ 
+ 
++/********************************
++HttpConnection_t::ReceivePostData
++********************************/
+ 
++void HttpConnection_t::ReceivePostData (const char *data, int len)
++{
++	cerr << "UNIMPLEMENTED ReceivePostData" << endl;
++}
+ 
+ /*****************************
+ HttpConnection_t::ConsumeData
+@@ -159,6 +169,7 @@
+ 			PathInfo.clear();
+ 			RequestUri.clear();
+ 			QueryString.clear();
++			Protocol.clear();
+ 
+ 			if (bSetEnvironmentStrings) {
+ 				unsetenv ("REQUEST_METHOD");
+@@ -168,6 +179,7 @@
+ 				unsetenv ("PATH_INFO");
+ 				unsetenv ("REQUEST_URI");
+ 				unsetenv ("QUERY_STRING");
++				unsetenv ("PROTOCOL");
+ 			}
+ 		}
+ 
+@@ -202,9 +214,15 @@
+ 					if (ContentLength > 0) {
+ 						if (_Content)
+ 							free (_Content);
+-						_Content = (char*) malloc (ContentLength + 1);
+-						if (!_Content)
+-							throw std::runtime_error ("resource exhaustion");
++						if (bAccumulatePost) {
++							_Content = (char*) malloc (ContentLength + 1);
++							if (!_Content)
++								throw std::runtime_error ("resource exhaustion");
++						}
++						else {
++							_Content = (char*) malloc (1);
++							_Content = 0;
++						}
+ 						ContentPos = 0;
+ 						ProtocolState = ReadingContentState;
+ 					}
+@@ -241,12 +259,19 @@
+ 			int len = ContentLength - ContentPos;
+ 			if (len > length)
+ 				len = length;
+-			memcpy (_Content + ContentPos, data, len);
++			if (bAccumulatePost) {
++				memcpy (_Content + ContentPos, data, len);
++			} else {
++				ReceivePostData(data,len);
++			}
+ 			data += len;
+ 			length -= len;
+ 			ContentPos += len;
+ 			if (ContentPos == ContentLength) {
+-				_Content[ContentPos] = 0;
++				if (bAccumulatePost) {
++					_Content[ContentPos] = 0;
++				} else {
++				}
+ 				ProtocolState = DispatchState;
+ 			}
+ 		}
+@@ -254,7 +279,7 @@
+ 
+ 		//----------------------------------- DispatchState
+ 		if (ProtocolState == DispatchState) {
+-			ProcessRequest (RequestMethod, Cookie.c_str(), IfNoneMatch.c_str(), ContentType.c_str(), QueryString.c_str(), PathInfo.c_str(), RequestUri.c_str(), ContentLength, _Content, HeaderBlock, HeaderBlockPos);
++			ProcessRequest (RequestMethod, Cookie.c_str(), IfNoneMatch.c_str(), ContentType.c_str(), QueryString.c_str(), PathInfo.c_str(), RequestUri.c_str(), Protocol.c_str(), ContentLength, _Content, HeaderBlock, HeaderBlockPos);
+ 			ProtocolState = BaseState;
+ 		}
+ 	}
+@@ -424,6 +449,9 @@
+ 		return false;
+ 	}
+ 
++	string prot (blank2+1);
++	Protocol = prot.c_str();
++
+ 	// Here, the request starts at blank and ends just before blank2.
+ 	// Find the query-string (?) and/or fragment (#,;), if either are present. 
+ 	const char *questionmark = strchr (blank, '?');
+@@ -444,6 +472,7 @@
+ 			setenv ("PATH_INFO", req.c_str(), true);
+ 			setenv ("REQUEST_URI", req.c_str(), true);
+ 			setenv ("QUERY_STRING", qs.c_str(), true);
++			setenv ("PROTOCOL", prot.c_str(), true);
+ 		}
+ 	}
+ 	else if (fragment) {
+@@ -455,6 +484,7 @@
+ 			setenv ("PATH_INFO", req.c_str(), true);
+ 			setenv ("REQUEST_URI", req.c_str(), true);
+ 			setenv ("QUERY_STRING", "", true);
++			setenv ("PROTOCOL", prot.c_str(), true);
+ 		}
+ 	}
+ 	else {
+@@ -466,9 +496,9 @@
+ 			setenv ("PATH_INFO", req.c_str(), true);
+ 			setenv ("REQUEST_URI", req.c_str(), true);
+ 			setenv ("QUERY_STRING", "", true);
++			setenv ("PROTOCOL", prot.c_str(), true);
+ 		}
+ 	}
+-
+ 	
+ 	return true;
+ }

data/ext/rubyhttp.cpp

@@ -0,0 +1,278 @@
+/*****************************************************************************
+
+$Id: rubyhttp.cpp 3966 2007-03-16 11:52:05Z francis $
+
+File:     libmain.cpp
+Date:     06Apr06
+
+Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+Gmail: garbagecat10
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*****************************************************************************/
+
+#include <iostream>
+#include <string>
+#include <stdexcept>
+
+using namespace std;
+
+#include <ruby.h>
+#include "http.h"
+
+
+
+/**************************
+class RubyHttpConnection_t
+**************************/
+
+class RubyHttpConnection_t: public HttpConnection_t
+{
+	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;
+};
+
+
+/******************************
+RubyHttpConnection_t::SendData
+******************************/
+
+void RubyHttpConnection_t::SendData (const char *data, int length)
+{
+	rb_funcall (Myself, rb_intern ("send_data"), 1, rb_str_new (data, length));
+}
+
+
+/*************************************
+RubyHttpConnection_t::CloseConnection
+*************************************/
+
+void RubyHttpConnection_t::CloseConnection (bool after_writing)
+{
+	VALUE v = rb_intern (after_writing ? "close_connection_after_writing" : "close_connection");
+	rb_funcall (Myself, v, 0);
+}
+
+
+void RubyHttpConnection_t::ReceivePostData (const char *data, int len)
+{
+	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);
+	}
+}
+	
+/************************************
+RubyHttpConnection_t::ProcessRequest
+************************************/
+
+void RubyHttpConnection_t::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 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);
+}
+
+
+/*******
+Statics
+*******/
+
+
+
+/***********
+t_post_init
+***********/
+
+static VALUE t_post_init (VALUE self)
+{
+	RubyHttpConnection_t *hc = new RubyHttpConnection_t (self);
+	if (!hc)
+		throw std::runtime_error ("no http-connection object");
+
+	rb_ivar_set (self, rb_intern ("@http______conn"), INT2NUM ((long)hc));
+	return Qnil;
+}
+
+
+/**************
+t_receive_data
+**************/
+
+static VALUE t_receive_data (VALUE self, VALUE data)
+{
+	int length = NUM2INT (rb_funcall (data, rb_intern ("length"), 0));
+	RubyHttpConnection_t *hc = (RubyHttpConnection_t*)(NUM2INT (rb_ivar_get (self, rb_intern ("@http______conn"))));
+	if (hc)
+		hc->ConsumeData (StringValuePtr (data), length);
+	return Qnil;
+}
+
+/*******************
+t_receive_post_data
+*******************/
+
+static VALUE t_receive_post_data (VALUE self, VALUE data)
+{
+	/** This is a NOOP.  It should be overridden.  **/
+}
+
+/********
+t_unbind
+********/
+
+static VALUE t_unbind (VALUE self)
+{
+	RubyHttpConnection_t *hc = (RubyHttpConnection_t*)(NUM2INT (rb_ivar_get (self, rb_intern ("@http______conn"))));
+	if (hc)
+		delete hc;
+	return Qnil;
+}
+
+
+/**********************
+t_process_http_request
+**********************/
+
+static VALUE t_process_http_request (VALUE self)
+{
+	// 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;
+}
+
+/************************
+t_no_environment_strings
+************************/
+
+static VALUE t_no_environment_strings (VALUE self)
+{
+	RubyHttpConnection_t *hc = (RubyHttpConnection_t*)(NUM2INT (rb_ivar_get (self, rb_intern ("@http______conn"))));
+	if (hc)
+		hc->SetNoEnvironmentStrings();
+	return Qnil;
+}
+
+/**********************
+t_dont_accumulate_post
+**********************/
+
+static VALUE t_dont_accumulate_post (VALUE self)
+{
+	RubyHttpConnection_t *hc = (RubyHttpConnection_t*)(NUM2INT (rb_ivar_get (self, rb_intern ("@http______conn"))));
+	if (hc)
+		hc->SetDontAccumulatePost();
+	return Qnil;
+}
+
+
+/****************************
+Init_eventmachine_httpserver
+****************************/
+
+extern "C" void Init_eventmachine_httpserver()
+{
+	// INCOMPLETE, we need to define class Connections inside module EventMachine
+  
+	VALUE Monorail = rb_define_module ("EventMachine");
+	VALUE EmModule = rb_define_module_under (Monorail, "HttpServer");
+	rb_define_method (EmModule, "post_init", (VALUE(*)(...))t_post_init, 0);
+	rb_define_method (EmModule, "receive_data", (VALUE(*)(...))t_receive_data, 1);
+	rb_define_method (EmModule, "receive_post_data", (VALUE(*)(...))t_receive_post_data, 1);
+	rb_define_method (EmModule, "unbind", (VALUE(*)(...))t_unbind, 0);
+	rb_define_method (EmModule, "process_http_request", (VALUE(*)(...))t_process_http_request, 0);
+	rb_define_method (EmModule, "no_environment_strings", (VALUE(*)(...))t_no_environment_strings, 0);
+	rb_define_method (EmModule, "dont_accumulate_post", (VALUE(*)(...))t_dont_accumulate_post, 0);
+}
+
+