Adding upstream version 1:0.5.47.upstream/1%0.5.47

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

6 files changed, 1447 insertions, 0 deletions

diff --git a/extras/ruby/HTP.c b/extras/ruby/HTP.c
new file mode 100644
index 0000000..c83092d
--- /dev/null
+++ b/extras/ruby/HTP.c
@@ -0,0 +1,1008 @@
+/***************************************************************************
+ * Copyright (c) 2009-2010 Open Information Security Foundation
+ * Copyright (c) 2010-2013 Qualys, Inc.
+ * 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 the Qualys, 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
+ * HOLDER 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.
+ ***************************************************************************/
+
+/**
+ * @author Christopher Alfeld <calfeld@qualys.com>
+ */
+
+#include <ruby.h>
+#include <htp/htp.h>
+
+/* Status
+ * Complete: Tx, Header, HeaderLine, URI, all numeric constants.
+ * Incomplete: Cfg, Connp
+ * Missing completely: file, file_data, log, tx_data (probably not needed)
+ */
+
+// Debug
+#ifdef RBHTP_DBEUG
+#include <stdio.h>
+#define P( value ) { VALUE inspect = rb_funcall( value, rb_intern( "inspect" ), 0 ); printf("%s\n",StringValueCStr(inspect)); }
+#else
+#define P( value )
+#endif
+
+static VALUE mHTP;
+static VALUE cCfg;
+static VALUE cConnp;
+static VALUE cTx;
+static VALUE cHeader;
+static VALUE cHeaderLine;
+static VALUE cURI;
+static VALUE cFile;
+static VALUE cConn;
+
+#define BSTR_TO_RSTR( B ) ( rb_str_new( bstr_ptr( B ), bstr_len( B ) ) )
+
+// Accessor Helpers
+#define RBHTP_R_INT( T, N ) \
+  VALUE rbhtp_ ## T ## _ ## N( VALUE self ) \
+  { \
+		htp_ ## T ## _t* x = NULL; \
+		Data_Get_Struct( rb_iv_get( self, "@" #T ), htp_ ## T ## _t, x ); \
+		return INT2FIX( x->N ); \
+  }
+
+#define RBHTP_R_TV( T, N ) \
+	VALUE rbhtp_ ## T ## _ ## N( VALUE self ) \
+	{ \
+		htp_ ## T ## _t* x = NULL; \
+		Data_Get_Struct( rb_iv_get( self, "@" #T ), htp_ ## T ## _t, x ); \
+		return rb_time_new( x->N.tv_sec, x->N.tv_usec ); \
+	}
+
+#define RBHTP_R_CSTR( T, N ) \
+  VALUE rbhtp_ ## T ## _ ## N( VALUE self ) \
+  { \
+		htp_ ## T ## _t* x = NULL; \
+		Data_Get_Struct( rb_iv_get( self, "@" #T ), htp_ ## T ## _t, x ); \
+		if ( x->N == NULL ) return Qnil; \
+		return rb_str_new2( x->N ); \
+  }
+
+#define RBHTP_W_INT( T, N ) \
+	VALUE rbhtp_## T ##_ ## N ## _set( VALUE self, VALUE v ) \
+	{ \
+		Check_Type( v, T_FIXNUM ); \
+		htp_ ## T ## _t* x = NULL; \
+		Data_Get_Struct( rb_iv_get( self, "@" #T ), htp_ ## T ## _t, x ); \
+		x->N = FIX2INT( v ); \
+		return Qnil; \
+	}
+	
+#define RBHTP_RW_INT( T, N ) \
+	RBHTP_R_INT( T, N ) \
+	RBHTP_W_INT( T, N )
+
+#define RBHTP_R_BOOL( T, N ) \
+  VALUE rbhtp_ ## T ## _ ## N( VALUE self ) \
+  { \
+		htp_ ## T ## _t* x = NULL; \
+		Data_Get_Struct( rb_iv_get( self, "@" #T ), htp_ ## T ## _t, x ); \
+		return x->N == 1 ? Qtrue : Qfalse; \
+  }
+
+#define RBHTP_R_STRING( T, N ) \
+	VALUE rbhtp_ ## T ## _ ## N( VALUE self ) \
+	{ \
+		htp_ ## T ## _t* x = NULL; \
+		Data_Get_Struct( rb_iv_get( self, "@" #T ), htp_ ## T ## _t, x ); \
+		if ( x->N == NULL ) \
+			return Qnil; \
+		return BSTR_TO_RSTR( x->N ); \
+	}
+	
+#define RBHTP_R_HTP( T, N, H ) \
+	VALUE rbhtp_ ## T ## _ ## N( VALUE self ) \
+	{ \
+		htp_ ## T ## _t* x = NULL; \
+		Data_Get_Struct( rb_iv_get( self, "@" #T ), htp_ ## T ## _t, x ); \
+		if ( x->N == NULL ) \
+			return Qnil; \
+		return rb_funcall( H, rb_intern( "new" ), 1, \
+			Data_Wrap_Struct( rb_cObject, 0, 0, x->N ) ); \
+	}
+
+#define RBHTP_R_URI( T, N ) RBHTP_R_HTP( T, N, cURI )
+	
+static VALUE rbhtp_r_string_table( htp_table_t* table )
+{
+	if ( table == NULL ) return Qnil;
+	
+	bstr *k, *v;
+	VALUE r = rb_ary_new();	
+    for (int i = 0, n = htp_table_size(table); i < n; i++) {
+        v = htp_table_get_index(table, i, &k);
+		rb_ary_push( r, rb_ary_new3( 2,
+			BSTR_TO_RSTR( *k ), BSTR_TO_RSTR( *v ) ) );
+	}
+	return r;
+}
+	
+#define RBHTP_R_STRING_TABLE( T, N ) \
+	VALUE rbhtp_ ## T ## _ ## N( VALUE self ) \
+	{ \
+		htp_ ## T ## _t* x = NULL; \
+		Data_Get_Struct( rb_iv_get( self, "@" #T ), htp_ ## T ## _t, x ); \
+		return rbhtp_r_string_table( x->N ); \
+	}
+
+// We don't push the keys as they are duplicated in the header.
+static VALUE rbhtp_r_header_table( htp_table_t* table )
+{
+	if ( table == NULL ) return Qnil; 	
+	htp_header_t* v; 
+	VALUE r = rb_ary_new(); 
+
+    for (int i = 0, n = htp_table_size(table); i < n; i++) {
+        v = htp_table_get_index(table, i, NULL);
+        rb_ary_push( r,
+			rb_funcall( cHeader, rb_intern( "new" ), 1,
+				Data_Wrap_Struct( rb_cObject, 0, 0, v ) ) );
+    }
+
+	return r; 
+}	
+
+#define RBHTP_R_HEADER_TABLE( T, N ) \
+	VALUE rbhtp_ ## T ## _ ## N( VALUE self ) \
+	{ \
+		htp_ ## T ## _t* x = NULL; \
+		Data_Get_Struct( rb_iv_get( self, "@" #T ), htp_ ## T ## _t, x ); \
+		return rbhtp_r_header_table( x->N ); \
+	}
+
+static VALUE rbhtp_r_header_line_list( htp_list_t* list )
+{
+	if ( list == NULL ) return Qnil;	
+	VALUE r = rb_ary_new();	
+    for (int i = 0, n = htp_list_size(list); i < n; i++) {
+        htp_header_line_t *v = htp_list_get(list, i);
+        
+		rb_ary_push( r, 
+			rb_funcall( cHeaderLine, rb_intern( "new" ), 1,
+				Data_Wrap_Struct( rb_cObject, 0, 0, v ) ) );
+	}
+	return r;
+}
+
+#define RBHTP_R_HEADER_LINE_LIST( T, N ) \
+	VALUE rbhtp_ ## T ## _ ## N( VALUE self ) \
+	{ \
+		htp_ ## T ## _t* x = NULL; \
+		Data_Get_Struct( rb_iv_get( self, "@" #T ), htp_ ## T ## _t, x ); \
+		return rbhtp_r_header_line_list( x->N ); \
+	}
+
+// This function is only needed when we malloc the URI ourselves.
+void rbhtp_free_uri( void* p )
+{
+	htp_uri_t* uri = (htp_uri_t*)p;
+	free( uri );
+}
+
+//---- HTP ---
+VALUE rbhtp_get_version( VALUE self )
+{
+	return rb_str_new2( htp_get_version() );
+}
+
+// We return a HTP::URI and throw an exception on error.
+VALUE rbhtp_parse_uri( VALUE self, VALUE input )
+{
+	Check_Type( input, T_STRING );
+	bstr* input_b = bstr_dup_mem( RSTRING_PTR( input ), RSTRING_LEN( input ) );
+	htp_uri_t* uri = NULL; // htp_parse_uri will alloc.
+	
+	int result = htp_parse_uri( input_b, &uri );
+	if ( result != HTP_OK ) {
+		bstr_free( input_b );
+		free( uri );
+		rb_raise( rb_eRuntimeError, "HTP error in htp_parse_uri: %d", result );
+		return Qnil; // Ignored?
+	}
+
+	bstr_free( input_b ); // Okay, as htp_parse_uri dups the data it needs.
+
+	return rb_funcall( cURI, rb_intern( "new" ), 1,
+		Data_Wrap_Struct( rb_cObject, 0, rbhtp_free_uri, uri )
+	);
+}
+
+//---- Cfg ----
+
+// Terminate list with "".
+static char* const rbhtp_config_pvars[] = {
+	"@request_proc", 
+	"@request_proc",
+	"@transaction_start",
+	"@request_line",
+	"@request_headers",
+	"@request_trailer",
+	"@response_line",
+	"@response_headers",
+	"@response_trailers",
+	""
+};
+
+void rbhtp_config_free( void* p )
+{
+	htp_cfg_t* cfg = (htp_cfg_t*)p;
+	htp_config_destroy( cfg );
+}
+
+VALUE rbhtp_config_initialize( VALUE self )
+{
+	char* const* v = &rbhtp_config_pvars[0];
+	while ( *v[0] != '\0' ) {
+		rb_iv_set( self, *v, Qnil );
+		++v;
+	}
+	
+	htp_cfg_t* cfg = htp_config_create();
+
+	rb_iv_set( self, "@cfg", 
+		Data_Wrap_Struct( rb_cObject, 0, rbhtp_config_free, cfg ) 
+	);
+	
+	return Qnil;
+}
+
+VALUE rbhtp_config_copy( VALUE self )
+{
+	// We create one too many copies here.
+	VALUE new_config = rb_funcall( cCfg, rb_intern( "new" ), 0 );
+	htp_cfg_t* cfg = NULL;
+	Data_Get_Struct( rb_iv_get( self, "@cfg" ), htp_cfg_t, cfg );
+
+	// Note that the existing new_config @cfg will be garbage collected as a 
+	// result of this set.
+	
+	rb_iv_set( new_config, "@cfg", 
+		Data_Wrap_Struct( rb_cObject, 0, rbhtp_config_free, 
+			htp_config_copy( cfg ) ) );
+			
+	// Now copy over all our callbacks.
+	char* const* v = &rbhtp_config_pvars[0];
+	while ( *v[0] != '\0' ) {
+		rb_iv_set( new_config, *v, rb_iv_get( self, *v ) );
+		++v;
+	}
+
+	return new_config;
+}
+
+VALUE rbhtp_config_set_server_personality( VALUE self, VALUE personality )
+{
+	Check_Type( personality, T_FIXNUM );
+	
+	htp_cfg_t* cfg = NULL;
+	Data_Get_Struct( rb_iv_get( self, "@cfg" ), htp_cfg_t, cfg );
+
+	return INT2FIX( 
+		htp_config_set_server_personality( cfg, FIX2INT( personality ) ) 
+	);
+}
+
+VALUE rbhtp_config_register_urlencoded_parser( VALUE self )
+{
+	htp_cfg_t* cfg = NULL;
+	Data_Get_Struct( rb_iv_get( self, "@cfg" ), htp_cfg_t, cfg );
+
+	htp_config_register_urlencoded_parser( cfg );
+
+	return Qnil;
+}	
+
+#define RBHTP_CALLBACK_SUB( N ) \
+	VALUE rbhtp_config_register_ ## N( VALUE self ) \
+	{ \
+		if ( ! rb_block_given_p() ) { \
+			rb_raise( rb_eArgError, "A block is required." ); \
+			return Qnil; \
+		} \
+		VALUE proc = rb_iv_get( self, "@" #N "_proc" ); \
+		if ( proc == Qnil ) { \
+			htp_cfg_t* cfg = NULL; \
+			Data_Get_Struct( rb_iv_get( self, "@cfg" ), htp_cfg_t, cfg ); \
+			htp_config_register_## N( cfg, rbhtp_config_callback_ ## N ); \
+		} \
+		rb_iv_set( self, "@" #N "_proc", rb_block_proc() ); \
+		return self; \
+	}
+	
+#define RBHTP_CONNP_CALLBACK( N ) \
+	int rbhtp_config_callback_ ## N( htp_connp_t* connp ) \
+	{ \
+		VALUE userdata = (VALUE)htp_connp_get_user_data( connp ); \
+		VALUE config = rb_iv_get( userdata, "@cfg" ); \
+		VALUE proc = rb_iv_get( config, "@" #N "_proc" ); \
+		if ( proc != Qnil ) { \
+			return INT2FIX( \
+				rb_funcall( proc, rb_intern( "call" ), 1, userdata )  \
+			); \
+		} \
+		return 1; \
+	} \
+	RBHTP_CALLBACK_SUB( N )
+	
+// Tx data is a tx and a data block.  For *_body_data callbacks we pass 
+// in the tx as first argument and the data as a string as the second argument.
+#define RBHTP_TXDATA_CALLBACK( N ) \
+	int rbhtp_config_callback_ ##N( htp_tx_data_t* txdata ) \
+	{ \
+		htp_connp_t* connp = txdata->tx->connp; \
+		VALUE userdata = (VALUE)htp_connp_get_user_data( connp ); \
+		VALUE config = rb_iv_get( userdata, "@cfg" ); \
+		VALUE proc = rb_iv_get( config, "@" #N "_proc" ); \
+		if ( proc != Qnil ) { \
+			VALUE data = Qnil; \
+			if ( txdata->data ) \
+				data = rb_str_new( (char*)txdata->data, txdata->len ); \
+			return INT2FIX( \
+				rb_funcall( proc, rb_intern( "call" ), 2, \
+					rb_funcall( cTx, rb_intern( "new" ), 3,  \
+						Data_Wrap_Struct( rb_cObject, 0, 0, txdata->tx ), \
+						config, \
+						userdata \
+					), \
+					data \
+			  ) \
+			); \
+		} \
+		return 1; \
+	} \
+	RBHTP_CALLBACK_SUB( N )
+		
+		
+RBHTP_CONNP_CALLBACK( request )
+RBHTP_CONNP_CALLBACK( response )
+RBHTP_CONNP_CALLBACK( transaction_start )
+RBHTP_CONNP_CALLBACK( request_line )
+RBHTP_CONNP_CALLBACK( request_headers )
+RBHTP_CONNP_CALLBACK( request_trailer )
+RBHTP_CONNP_CALLBACK( response_line )
+RBHTP_CONNP_CALLBACK( response_headers )
+RBHTP_CONNP_CALLBACK( response_trailer )
+
+RBHTP_TXDATA_CALLBACK( request_body_data )
+RBHTP_TXDATA_CALLBACK( response_body_data )
+
+RBHTP_R_INT( cfg, spersonality )
+RBHTP_RW_INT( cfg, parse_request_cookies )
+
+// File data is a tx, file information, and file data.  The callback thus
+// takes those three as arguments.
+int rbhtp_config_callback_request_file_data( htp_file_data_t* filedata )
+{
+	htp_connp_t* connp = filedata->tx->connp;
+	VALUE userdata = (VALUE)htp_connp_get_user_data( connp );
+	VALUE config = rb_iv_get( userdata, "@cfg" );
+	VALUE proc = rb_iv_get( config, "@request_file_data_proc" );
+	if ( proc != Qnil ) {
+		VALUE data = Qnil;
+		if ( filedata->data )
+			data = rb_str_new( (char*)filedata->data, filedata->len );
+		return INT2FIX(
+			rb_funcall( proc, rb_intern( "call" ), 2,
+				rb_funcall( cTx, rb_intern( "new" ), 1, 
+					Data_Wrap_Struct( rb_cObject, 0, 0, filedata->tx )
+				),
+				rb_funcall( cFile, rb_intern( "new" ), 1, 
+					Data_Wrap_Struct( rb_cObject, 0, 0, filedata->file )
+				),
+				data
+		  )
+		);
+	}
+	return 1;
+}
+RBHTP_CALLBACK_SUB( request_file_data )
+
+//---- Connp ----
+
+void rbhtp_connp_free( void* p )
+{
+	htp_connp_t* connp = (htp_connp_t*)p;
+	if ( connp )
+		htp_connp_destroy_all( connp );
+}
+
+VALUE rbhtp_connp_initialize( VALUE self, VALUE config )
+{
+	rb_iv_set( self, "@cfg", config );
+	
+	htp_cfg_t* cfg = NULL;
+	Data_Get_Struct( rb_iv_get( config, "@cfg" ), htp_cfg_t, cfg );
+	
+	htp_connp_t* connp = htp_connp_create( cfg );
+	htp_connp_set_user_data( connp, (void*)self );
+	rb_iv_set( self, "@connp", 
+		Data_Wrap_Struct( rb_cObject, 0, rbhtp_connp_free, connp ) 
+	);
+	
+	return Qnil;
+}
+
+VALUE rbhtp_connp_req_data( VALUE self, VALUE timestamp, VALUE data )
+{
+	if ( strncmp( "Time", rb_class2name( CLASS_OF( timestamp ) ), 4 ) != 0 ) {
+		rb_raise( rb_eTypeError, "First argument must be a Time." );
+		return Qnil;
+	}
+
+	StringValue( data ); // try to make data a string.	
+	Check_Type( data, T_STRING );
+	
+	size_t len = RSTRING_LEN( data );
+	char* data_c = RSTRING_PTR( data );
+
+	htp_time_t timestamp_c;
+	timestamp_c.tv_sec = 
+		FIX2INT( rb_funcall( timestamp, rb_intern( "tv_sec" ), 0 ) );
+	timestamp_c.tv_usec = 
+		FIX2INT( rb_funcall( timestamp, rb_intern( "tv_usec" ), 0 ) );
+
+	VALUE connp_r = rb_iv_get( self, "@connp" );
+	htp_connp_t* connp = NULL;
+	Data_Get_Struct( connp_r, htp_connp_t, connp );
+		
+	int result = 
+		htp_connp_req_data( connp, &timestamp_c, (unsigned char*)data_c, len );
+	
+	return INT2FIX( result );
+}
+
+VALUE rbhtp_connp_in_tx( VALUE self )
+{
+	VALUE connp_r = rb_iv_get( self, "@connp" );
+	VALUE config = rb_iv_get( self, "@cfg" );
+	htp_connp_t* connp = NULL;
+	Data_Get_Struct( connp_r, htp_connp_t, connp );
+	
+	if ( connp->in_tx == NULL )
+		return Qnil;
+	
+	return rb_funcall( cTx, rb_intern( "new" ), 3, 
+		Data_Wrap_Struct( rb_cObject, 0, 0, connp->in_tx ),
+		config, 
+		self
+	);
+}
+
+VALUE rbhtp_connp_conn( VALUE self )
+{
+	htp_connp_t* connp = NULL;
+	Data_Get_Struct( rb_iv_get( self, "@connp" ), htp_connp_t, connp );
+	if ( connp->conn == NULL )
+		return Qnil;
+	return rb_funcall( cConn, rb_intern( "new" ), 2,
+		Data_Wrap_Struct( rb_cObject, 0, 0, connp->conn ),
+		self
+	);
+}
+
+// Unlike Connp and Cfg, these are just wrapper.  The lifetime of the
+// underlying objects are bound to the Connp.
+
+//---- Header ----
+VALUE rbhtp_header_initialize( VALUE self, VALUE raw_header )
+{
+	rb_iv_set( self, "@header", raw_header );
+	return Qnil;
+}
+
+RBHTP_R_STRING( header, name );
+RBHTP_R_STRING( header, value );
+RBHTP_R_INT( header, flags );
+
+// ---- Header Line ----
+VALUE rbhtp_header_line_initialize( VALUE self, VALUE raw_header_line )
+{
+	rb_iv_set( self, "@header_line", raw_header_line );
+	return Qnil;
+}
+
+VALUE rbhtp_header_line_header( VALUE self )
+{
+	htp_header_line_t* hline = NULL;
+	Data_Get_Struct( rb_iv_get( self, "@header_line" ), htp_header_line_t, hline );
+	
+	if ( hline->header == NULL ) 
+		return Qnil;
+		
+	return rb_funcall( cHeader, rb_intern( "new" ), 1,
+		Data_Wrap_Struct( rb_cObject, 0, 0, hline->header )
+	);	
+}
+
+RBHTP_R_STRING( header_line, line );
+RBHTP_R_INT( header_line, name_offset );
+RBHTP_R_INT( header_line, name_len );
+RBHTP_R_INT( header_line, value_offset );
+RBHTP_R_INT( header_line, value_len );
+RBHTP_R_INT( header_line, has_nulls );
+RBHTP_R_INT( header_line, first_nul_offset );
+RBHTP_R_INT( header_line, flags );
+
+// ---- URI ----
+VALUE rbhtp_uri_initialize( VALUE self, VALUE raw_uri )
+{
+	rb_iv_set( self, "@uri", raw_uri );
+	return Qnil;
+}
+
+RBHTP_R_STRING( uri, scheme );
+RBHTP_R_STRING( uri, username );
+RBHTP_R_STRING( uri, password );
+RBHTP_R_STRING( uri, hostname );
+RBHTP_R_STRING( uri, port );
+RBHTP_R_INT( uri, port_number );
+RBHTP_R_STRING( uri, path );
+RBHTP_R_STRING( uri, query );
+RBHTP_R_STRING( uri, fragment );
+
+//---- Tx ----
+
+VALUE rbhtp_tx_initialize( 
+	VALUE self, 
+	VALUE raw_txn, 
+	VALUE cfg,
+	VALUE connp )
+{
+	rb_iv_set( self, "@tx", raw_txn );
+	rb_iv_set( self, "@cfg", cfg );
+	rb_iv_set( self, "@connp", connp );
+	
+	return Qnil;
+}
+
+RBHTP_R_INT( tx, request_ignored_lines )
+RBHTP_R_INT( tx, request_line_nul )
+RBHTP_R_INT( tx, request_line_nul_offset )
+RBHTP_R_INT( tx, request_method_number )
+RBHTP_R_INT( tx, request_protocol_number )
+RBHTP_R_INT( tx, protocol_is_simple )
+RBHTP_R_INT( tx, request_message_len )
+RBHTP_R_INT( tx, request_entity_len )
+RBHTP_R_INT( tx, request_nonfiledata_len )
+RBHTP_R_INT( tx, request_filedata_len )
+RBHTP_R_INT( tx, request_header_lines_no_trailers )
+RBHTP_R_INT( tx, request_headers_raw_lines )
+RBHTP_R_INT( tx, request_transfer_coding )
+RBHTP_R_INT( tx, request_content_encoding )
+RBHTP_R_INT( tx, request_params_query_reused )
+RBHTP_R_INT( tx, request_params_body_reused )
+RBHTP_R_INT( tx, request_auth_type )
+RBHTP_R_INT( tx, response_ignored_lines )
+RBHTP_R_INT( tx, response_protocol_number )
+RBHTP_R_INT( tx, response_status_number )
+RBHTP_R_INT( tx, response_status_expected_number )
+RBHTP_R_INT( tx, seen_100continue )
+RBHTP_R_INT( tx, response_message_len )
+RBHTP_R_INT( tx, response_entity_len )
+RBHTP_R_INT( tx, response_transfer_coding )
+RBHTP_R_INT( tx, response_content_encoding )
+RBHTP_R_INT( tx, flags )
+RBHTP_R_INT( tx, progress )
+
+RBHTP_R_STRING( tx, request_method )
+RBHTP_R_STRING( tx, request_line )
+RBHTP_R_STRING( tx, request_uri )
+RBHTP_R_STRING( tx, request_uri_normalized )
+RBHTP_R_STRING( tx, request_protocol )
+RBHTP_R_STRING( tx, request_headers_raw )
+RBHTP_R_STRING( tx, request_headers_sep )
+RBHTP_R_STRING( tx, request_content_type )
+RBHTP_R_STRING( tx, request_auth_username )
+RBHTP_R_STRING( tx, request_auth_password )
+RBHTP_R_STRING( tx, response_line )
+RBHTP_R_STRING( tx, response_protocol )
+RBHTP_R_STRING( tx, response_status )
+RBHTP_R_STRING( tx, response_message )
+RBHTP_R_STRING( tx, response_headers_sep )
+
+RBHTP_R_STRING_TABLE( tx, request_params_query )
+RBHTP_R_STRING_TABLE( tx, request_params_body )
+RBHTP_R_STRING_TABLE( tx, request_cookies )
+RBHTP_R_HEADER_TABLE( tx, request_headers )
+RBHTP_R_HEADER_TABLE( tx, response_headers )
+
+RBHTP_R_HEADER_LINE_LIST( tx, request_header_lines );
+RBHTP_R_HEADER_LINE_LIST( tx, response_header_lines );
+
+RBHTP_R_URI( tx, parsed_uri )
+RBHTP_R_URI( tx, parsed_uri_incomplete )
+
+VALUE rbhtp_tx_conn( VALUE self )
+{
+	htp_tx_t* tx = NULL;
+	Data_Get_Struct( rb_iv_get( self, "@tx" ), htp_tx_t, tx );
+	if ( tx->conn == NULL )
+		return Qnil;
+	return rb_funcall( cConn, rb_intern( "new" ), 2,
+		Data_Wrap_Struct( rb_cObject, 0, 0, tx->conn ),
+		rb_iv_get( self, "@connp" )
+	);
+}
+
+// ---- File ----
+VALUE rbhtp_file_initialize( VALUE self, VALUE raw_file )
+{
+	rb_iv_set( self, "@file", raw_file );
+	return Qnil;
+}
+
+RBHTP_R_INT( file, source )
+RBHTP_R_STRING( file, filename )
+RBHTP_R_INT( file, len )
+RBHTP_R_CSTR( file, tmpname )
+RBHTP_R_INT( file, fd )
+
+// ---- Conn ----
+VALUE rbhtp_conn_initialize( VALUE self, VALUE raw_conn, VALUE connp )
+{
+	rb_iv_set( self, "@conn", raw_conn );
+	rb_iv_set( self, "@connp", connp );
+	return Qnil;
+}
+
+RBHTP_R_CSTR( conn, remote_addr )
+RBHTP_R_INT( conn, remote_port )
+RBHTP_R_CSTR( conn, local_addr )
+RBHTP_R_INT( conn, local_port )
+RBHTP_R_INT( conn, flags )
+RBHTP_R_INT( conn, in_data_counter )
+RBHTP_R_INT( conn, out_data_counter )
+RBHTP_R_INT( conn, in_packet_counter )
+RBHTP_R_INT( conn, out_packet_counter )
+RBHTP_R_TV( conn, open_timestamp )
+RBHTP_R_TV( conn, close_timestamp )
+
+VALUE rbhtp_conn_transactions( VALUE self )
+{
+	htp_conn_t* conn = NULL;
+	Data_Get_Struct( rb_iv_get( self, "@conn" ), htp_conn_t, conn );
+	
+	if ( conn->transactions == NULL ) return Qnil;
+	
+	VALUE connp = rb_iv_get( self, "@connp" );
+	VALUE cfg = rb_iv_get( connp, "@cfg" );
+		
+	VALUE r = rb_ary_new();
+	
+    for (int i = 0, n = htp_list_size(conn->transactions); i < n; i++) {
+        htp_tx_t *v = htp_list_get(conn->transactions, i);
+        
+		rb_ary_push( r,
+			rb_funcall( cTx, rb_intern( "new" ), 3,
+				Data_Wrap_Struct( rb_cObject, 0, 0, v ),
+				cfg,
+				connp
+			)
+		);
+	}
+	return r;
+}
+
+//---- Init ----
+void Init_htp( void )
+{
+	mHTP = rb_define_module( "HTP" );
+	
+	rb_define_singleton_method( mHTP, "get_version", rbhtp_get_version, 0 );
+	rb_define_singleton_method( mHTP, "parse_uri", rbhtp_parse_uri, 1 );
+	
+	// All numeric constants from htp.h.
+  rb_define_const( mHTP, "HTP_ERROR", INT2FIX( HTP_ERROR ) );
+  rb_define_const( mHTP, "HTP_OK", INT2FIX( HTP_OK ) );
+  rb_define_const( mHTP, "HTP_DATA", INT2FIX( HTP_DATA ) );
+  rb_define_const( mHTP, "HTP_DATA_OTHER", INT2FIX( HTP_DATA_OTHER ) );
+  rb_define_const( mHTP, "HTP_DECLINED", INT2FIX( HTP_DECLINED ) );
+  rb_define_const( mHTP, "PROTOCOL_UNKNOWN", INT2FIX( HTP_PROTOCOL_UNKNOWN ) );
+  rb_define_const( mHTP, "HTTP_0_9", INT2FIX( HTP_PROTOCOL_0_9 ) );
+  rb_define_const( mHTP, "HTTP_1_0", INT2FIX( HTP_PROTOCOL_1_0 ) );
+  rb_define_const( mHTP, "HTTP_1_1", INT2FIX( HTP_PROTOCOL_1_1 ) );
+  rb_define_const( mHTP, "HTP_LOG_ERROR", INT2FIX( HTP_LOG_ERROR ) );
+  rb_define_const( mHTP, "HTP_LOG_WARNING", INT2FIX( HTP_LOG_WARNING ) );
+  rb_define_const( mHTP, "HTP_LOG_NOTICE", INT2FIX( HTP_LOG_NOTICE ) );
+  rb_define_const( mHTP, "HTP_LOG_INFO", INT2FIX( HTP_LOG_INFO ) );
+  rb_define_const( mHTP, "HTP_LOG_DEBUG", INT2FIX( HTP_LOG_DEBUG ) );
+  rb_define_const( mHTP, "HTP_LOG_DEBUG2", INT2FIX( HTP_LOG_DEBUG2 ) );
+  rb_define_const( mHTP, "HTP_HEADER_MISSING_COLON", INT2FIX( HTP_HEADER_MISSING_COLON ) );
+  rb_define_const( mHTP, "HTP_HEADER_INVALID_NAME", INT2FIX( HTP_HEADER_INVALID_NAME ) );
+  rb_define_const( mHTP, "HTP_HEADER_LWS_AFTER_FIELD_NAME", INT2FIX( HTP_HEADER_LWS_AFTER_FIELD_NAME ) );
+  rb_define_const( mHTP, "HTP_LINE_TOO_LONG_HARD", INT2FIX( HTP_LINE_TOO_LONG_HARD ) );
+  rb_define_const( mHTP, "HTP_LINE_TOO_LONG_SOFT", INT2FIX( HTP_LINE_TOO_LONG_SOFT ) );
+  rb_define_const( mHTP, "HTP_HEADER_LIMIT_HARD", INT2FIX( HTP_HEADER_LIMIT_HARD ) );
+  rb_define_const( mHTP, "HTP_HEADER_LIMIT_SOFT", INT2FIX( HTP_HEADER_LIMIT_SOFT ) );
+  rb_define_const( mHTP, "HTP_VALID_STATUS_MIN", INT2FIX( HTP_VALID_STATUS_MIN ) );
+  rb_define_const( mHTP, "HTP_VALID_STATUS_MAX", INT2FIX( HTP_VALID_STATUS_MAX ) );  
+  rb_define_const( mHTP, "M_UNKNOWN", INT2FIX( M_UNKNOWN ) );
+  rb_define_const( mHTP, "M_GET", INT2FIX( M_GET ) );
+  rb_define_const( mHTP, "M_PUT", INT2FIX( M_PUT ) );
+  rb_define_const( mHTP, "M_POST", INT2FIX( M_POST ) );
+  rb_define_const( mHTP, "M_DELETE", INT2FIX( M_DELETE ) );
+  rb_define_const( mHTP, "M_CONNECT", INT2FIX( M_CONNECT ) );
+  rb_define_const( mHTP, "M_OPTIONS", INT2FIX( M_OPTIONS ) );
+  rb_define_const( mHTP, "M_TRACE", INT2FIX( M_TRACE ) );
+  rb_define_const( mHTP, "M_PATCH", INT2FIX( M_PATCH ) );
+  rb_define_const( mHTP, "M_PROPFIND", INT2FIX( M_PROPFIND ) );
+  rb_define_const( mHTP, "M_PROPPATCH", INT2FIX( M_PROPPATCH ) );
+  rb_define_const( mHTP, "M_MKCOL", INT2FIX( M_MKCOL ) );
+  rb_define_const( mHTP, "M_COPY", INT2FIX( M_COPY ) );
+  rb_define_const( mHTP, "M_MOVE", INT2FIX( M_MOVE ) );
+  rb_define_const( mHTP, "M_LOCK", INT2FIX( M_LOCK ) );
+  rb_define_const( mHTP, "M_UNLOCK", INT2FIX( M_UNLOCK ) );
+  rb_define_const( mHTP, "M_VERSION_CONTROL", INT2FIX( M_VERSION_CONTROL ) );
+  rb_define_const( mHTP, "M_CHECKOUT", INT2FIX( M_CHECKOUT ) );
+  rb_define_const( mHTP, "M_UNCHECKOUT", INT2FIX( M_UNCHECKOUT ) );
+  rb_define_const( mHTP, "M_CHECKIN", INT2FIX( M_CHECKIN ) );
+  rb_define_const( mHTP, "M_UPDATE", INT2FIX( M_UPDATE ) );
+  rb_define_const( mHTP, "M_LABEL", INT2FIX( M_LABEL ) );
+  rb_define_const( mHTP, "M_REPORT", INT2FIX( M_REPORT ) );
+  rb_define_const( mHTP, "M_MKWORKSPACE", INT2FIX( M_MKWORKSPACE ) );
+  rb_define_const( mHTP, "M_MKACTIVITY", INT2FIX( M_MKACTIVITY ) );
+  rb_define_const( mHTP, "M_BASELINE_CONTROL", INT2FIX( M_BASELINE_CONTROL ) );
+  rb_define_const( mHTP, "M_MERGE", INT2FIX( M_MERGE ) );
+  rb_define_const( mHTP, "M_INVALID", INT2FIX( M_INVALID ) );
+  rb_define_const( mHTP, "M_HEAD", INT2FIX( HTP_M_HEAD ) );
+  rb_define_const( mHTP, "HTP_FIELD_UNPARSEABLE", INT2FIX( HTP_FIELD_UNPARSEABLE ) );
+  rb_define_const( mHTP, "HTP_FIELD_INVALID", INT2FIX( HTP_FIELD_INVALID ) );
+  rb_define_const( mHTP, "HTP_FIELD_FOLDED", INT2FIX( HTP_FIELD_FOLDED ) );
+  rb_define_const( mHTP, "HTP_FIELD_REPEATED", INT2FIX( HTP_FIELD_REPEATED ) );
+  rb_define_const( mHTP, "HTP_FIELD_LONG", INT2FIX( HTP_FIELD_LONG ) );
+  rb_define_const( mHTP, "HTP_FIELD_NUL_BYTE", INT2FIX( HTP_FIELD_RAW_NUL ) );
+  rb_define_const( mHTP, "HTP_REQUEST_SMUGGLING", INT2FIX( HTP_REQUEST_SMUGGLING ) );
+  rb_define_const( mHTP, "HTP_INVALID_FOLDING", INT2FIX( HTP_INVALID_FOLDING ) );
+  rb_define_const( mHTP, "HTP_INVALID_CHUNKING", INT2FIX( HTP_REQUEST_INVALID_T_E ) );
+  rb_define_const( mHTP, "HTP_MULTI_PACKET_HEAD", INT2FIX( HTP_MULTI_PACKET_HEAD ) );
+  rb_define_const( mHTP, "HTP_HOST_MISSING", INT2FIX( HTP_HOST_MISSING ) );
+  rb_define_const( mHTP, "HTP_AMBIGUOUS_HOST", INT2FIX( HTP_HOST_AMBIGUOUS ) );
+  rb_define_const( mHTP, "HTP_PATH_ENCODED_NUL", INT2FIX( HTP_PATH_ENCODED_NUL ) );
+  rb_define_const( mHTP, "HTP_PATH_INVALID_ENCODING", INT2FIX( HTP_PATH_INVALID_ENCODING ) );
+  rb_define_const( mHTP, "HTP_PATH_INVALID", INT2FIX( HTP_PATH_INVALID ) );
+  rb_define_const( mHTP, "HTP_PATH_OVERLONG_U", INT2FIX( HTP_PATH_OVERLONG_U ) );
+  rb_define_const( mHTP, "HTP_PATH_ENCODED_SEPARATOR", INT2FIX( HTP_PATH_ENCODED_SEPARATOR ) );
+  rb_define_const( mHTP, "HTP_PATH_UTF8_VALID", INT2FIX( HTP_PATH_UTF8_VALID ) );
+  rb_define_const( mHTP, "HTP_PATH_UTF8_INVALID", INT2FIX( HTP_PATH_UTF8_INVALID ) );
+  rb_define_const( mHTP, "HTP_PATH_UTF8_OVERLONG", INT2FIX( HTP_PATH_UTF8_OVERLONG ) );
+  rb_define_const( mHTP, "HTP_PATH_FULLWIDTH_EVASION", INT2FIX( HTP_PATH_HALF_FULL_RANGE ) );
+  rb_define_const( mHTP, "HTP_STATUS_LINE_INVALID", INT2FIX( HTP_STATUS_LINE_INVALID ) );
+  rb_define_const( mHTP, "PIPELINED_CONNECTION", INT2FIX( HTP_CONN_PIPELINED ) );
+  rb_define_const( mHTP, "HTP_SERVER_MINIMAL", INT2FIX( HTP_SERVER_MINIMAL ) );
+  rb_define_const( mHTP, "HTP_SERVER_GENERIC", INT2FIX( HTP_SERVER_GENERIC ) );
+  rb_define_const( mHTP, "HTP_SERVER_IDS", INT2FIX( HTP_SERVER_IDS ) );
+  rb_define_const( mHTP, "HTP_SERVER_IIS_4_0", INT2FIX( HTP_SERVER_IIS_4_0 ) );
+  rb_define_const( mHTP, "HTP_SERVER_IIS_5_0", INT2FIX( HTP_SERVER_IIS_5_0 ) );
+  rb_define_const( mHTP, "HTP_SERVER_IIS_5_1", INT2FIX( HTP_SERVER_IIS_5_1 ) );
+  rb_define_const( mHTP, "HTP_SERVER_IIS_6_0", INT2FIX( HTP_SERVER_IIS_6_0 ) );
+  rb_define_const( mHTP, "HTP_SERVER_IIS_7_0", INT2FIX( HTP_SERVER_IIS_7_0 ) );
+  rb_define_const( mHTP, "HTP_SERVER_IIS_7_5", INT2FIX( HTP_SERVER_IIS_7_5 ) );
+  rb_define_const( mHTP, "HTP_SERVER_TOMCAT_6_0", INT2FIX( HTP_SERVER_TOMCAT_6_0 ) );
+  rb_define_const( mHTP, "HTP_SERVER_APACHE", INT2FIX( HTP_SERVER_APACHE ) );
+  rb_define_const( mHTP, "HTP_SERVER_APACHE_2_2", INT2FIX( HTP_SERVER_APACHE_2_2 ) );
+  rb_define_const( mHTP, "NONE", INT2FIX( HTP_AUTH_NONE ) );
+  rb_define_const( mHTP, "IDENTITY", INT2FIX( HTP_CODING_IDENTITY ) );
+  rb_define_const( mHTP, "CHUNKED", INT2FIX( HTP_CODING_CHUNKED ) );
+  rb_define_const( mHTP, "TX_PROGRESS_NEW", INT2FIX( HTP_REQUEST_NOT_STARTED ) );
+  rb_define_const( mHTP, "TX_PROGRESS_REQ_LINE", INT2FIX( HTP_REQUEST_LINE ) );
+  rb_define_const( mHTP, "TX_PROGRESS_REQ_HEADERS", INT2FIX( HTP_REQUEST_HEADERS ) );
+  rb_define_const( mHTP, "TX_PROGRESS_REQ_BODY", INT2FIX( HTP_REQUEST_BODY ) );
+  rb_define_const( mHTP, "TX_PROGRESS_REQ_TRAILER", INT2FIX( HTP_REQUEST_TRAILER ) );
+  rb_define_const( mHTP, "RESPONSE_WAIT", INT2FIX( HTP_REQUEST_COMPLETE ) );
+  rb_define_const( mHTP, "TX_PROGRESS_RES_LINE", INT2FIX( HTP_RESPONSE_LINE ) );
+  rb_define_const( mHTP, "RESPONSE_HEADERS", INT2FIX( HTP_RESPONSE_HEADERS ) );
+  rb_define_const( mHTP, "RESPONSE_BODY", INT2FIX( HTP_RESPONSE_BODY ) );
+  rb_define_const( mHTP, "TX_PROGRESS_RES_TRAILER", INT2FIX( HTP_RESPONSE_TRAILER ) );
+  rb_define_const( mHTP, "TX_PROGRESS_COMPLETE", INT2FIX( HTP_RESPONSE_COMPLETE ) );
+  rb_define_const( mHTP, "HTP_STREAM_NEW", INT2FIX( HTP_STREAM_NEW ) );
+  rb_define_const( mHTP, "HTP_STREAM_OPEN", INT2FIX( HTP_STREAM_OPEN ) );
+  rb_define_const( mHTP, "HTP_STREAM_CLOSED", INT2FIX( HTP_STREAM_CLOSED ) );
+  rb_define_const( mHTP, "HTP_STREAM_ERROR", INT2FIX( HTP_STREAM_ERROR ) );
+  rb_define_const( mHTP, "HTP_STREAM_TUNNEL", INT2FIX( HTP_STREAM_TUNNEL ) );
+  rb_define_const( mHTP, "HTP_STREAM_DATA_OTHER", INT2FIX( HTP_STREAM_DATA_OTHER ) );
+  rb_define_const( mHTP, "HTP_STREAM_DATA", INT2FIX( HTP_STREAM_DATA ) );
+  rb_define_const( mHTP, "URL_DECODER_PRESERVE_PERCENT", INT2FIX( HTP_URL_DECODE_PRESERVE_PERCENT ) );
+  rb_define_const( mHTP, "URL_DECODER_REMOVE_PERCENT", INT2FIX( HTP_URL_DECODE_REMOVE_PERCENT ) );
+  rb_define_const( mHTP, "URL_DECODER_DECODE_INVALID", INT2FIX( HTP_URL_DECODE_PROCESS_INVALID ) );
+  rb_define_const( mHTP, "URL_DECODER_STATUS_400", INT2FIX( HTP_URL_DECODE_STATUS_400 ) );
+  rb_define_const( mHTP, "NO", INT2FIX( NO ) );
+  rb_define_const( mHTP, "BESTFIT", INT2FIX( BESTFIT ) );
+  rb_define_const( mHTP, "YES", INT2FIX( YES ) );
+  rb_define_const( mHTP, "TERMINATE", INT2FIX( TERMINATE ) );
+  rb_define_const( mHTP, "STATUS_400", INT2FIX( STATUS_400 ) );
+  rb_define_const( mHTP, "STATUS_404", INT2FIX( STATUS_404 ) );
+  rb_define_const( mHTP, "HTP_AUTH_NONE", INT2FIX( HTP_AUTH_NONE ) );
+  rb_define_const( mHTP, "HTP_AUTH_BASIC", INT2FIX( HTP_AUTH_BASIC ) );
+  rb_define_const( mHTP, "HTP_AUTH_DIGEST", INT2FIX( HTP_AUTH_DIGEST ) );
+  rb_define_const( mHTP, "HTP_AUTH_UNKNOWN", INT2FIX( HTP_AUTH_UNRECOGNIZED ) );
+  rb_define_const( mHTP, "HTP_FILE_MULTIPART", INT2FIX( HTP_FILE_MULTIPART ) );
+  rb_define_const( mHTP, "HTP_FILE_PUT", INT2FIX( HTP_FILE_PUT ) );
+  rb_define_const( mHTP, "CFG_NOT_SHARED", INT2FIX( CFG_NOT_SHARED ) );
+  rb_define_const( mHTP, "CFG_SHARED", INT2FIX( CFG_SHARED ) );
+
+	cCfg = rb_define_class_under( mHTP, "Cfg", rb_cObject );
+	rb_define_method( cCfg, "initialize", rbhtp_config_initialize, 0 );
+	rb_define_method( cCfg, "copy", rbhtp_config_copy, 0 );
+
+	rb_define_method( cCfg, "register_response", rbhtp_config_register_response, 0 );
+	rb_define_method( cCfg, "register_request", rbhtp_config_register_request, 0 );
+	rb_define_method( cCfg, "register_transaction_start", rbhtp_config_register_transaction_start, 0 );
+	rb_define_method( cCfg, "register_request_line", rbhtp_config_register_request_line, 0 );
+	rb_define_method( cCfg, "register_request_headers", rbhtp_config_register_request_headers, 0 );
+	rb_define_method( cCfg, "register_request_trailer", rbhtp_config_register_request_trailer, 0 );
+	rb_define_method( cCfg, "register_response_line", rbhtp_config_register_response_line, 0 );
+	rb_define_method( cCfg, "register_response_headers", rbhtp_config_register_response_headers, 0 );
+	rb_define_method( cCfg, "register_response_trailer", rbhtp_config_register_response_trailer, 0 );
+	
+	rb_define_method( cCfg, "register_urlencoded_parser", rbhtp_config_register_urlencoded_parser, 0 );
+	rb_define_method( cCfg, "register_request_body_data", rbhtp_config_register_request_body_data, 0 );
+	rb_define_method( cCfg, "register_response_body_data", rbhtp_config_register_request_body_data, 0 );
+	rb_define_method( cCfg, "register_request_file_data", rbhtp_config_register_request_file_data, 0 );
+	
+	// server_personality= and server_personality are defined in htp_ruby.rb	
+	rb_define_method( cCfg, "set_server_personality", rbhtp_config_set_server_personality, 1 );
+	rb_define_method( cCfg, "spersonality", rbhtp_cfg_spersonality, 0 );
+	
+	rb_define_method( cCfg, "parse_request_cookies", rbhtp_cfg_parse_request_cookies, 0 );
+	rb_define_method( cCfg, "parse_request_cookies=", rbhtp_cfg_parse_request_cookies_set, 1 );
+	// TODO: Much more to add.
+		
+	cConnp = rb_define_class_under( mHTP, "Connp", rb_cObject );
+	rb_define_method( cConnp, "initialize", rbhtp_connp_initialize, 1 );
+	rb_define_method( cConnp, "req_data", rbhtp_connp_req_data, 2 );	
+	rb_define_method( cConnp, "in_tx", rbhtp_connp_in_tx, 0 );	
+	rb_define_method( cConnp, "conn", rbhtp_connp_conn, 0 );
+	// TODO: Much more to Add.
+	
+	cHeader = rb_define_class_under( mHTP, "Header", rb_cObject );
+	rb_define_method( cHeader, "initialize", rbhtp_header_initialize, 1 );
+	rb_define_method( cHeader, "name", rbhtp_header_name, 0 );
+	rb_define_method( cHeader, "value", rbhtp_header_value, 0 );
+	rb_define_method( cHeader, "flags", rbhtp_header_flags, 0 );
+	
+	cHeaderLine = rb_define_class_under( mHTP, "HeaderLine", rb_cObject );
+	rb_define_method( cHeaderLine, "initialize", rbhtp_header_line_initialize, 1 );
+	rb_define_method( cHeaderLine, "header", rbhtp_header_line_header, 0 );
+	rb_define_method( cHeaderLine, "line", rbhtp_header_line_line, 0 );
+	rb_define_method( cHeaderLine, "name_offset", rbhtp_header_line_name_offset, 0 );
+	rb_define_method( cHeaderLine, "name_len", rbhtp_header_line_name_len, 0 );
+	rb_define_method( cHeaderLine, "value_offset", rbhtp_header_line_value_offset, 0 );
+	rb_define_method( cHeaderLine, "value_len", rbhtp_header_line_value_len, 0 );
+	rb_define_method( cHeaderLine, "has_nulls", rbhtp_header_line_has_nulls, 0 );
+	rb_define_method( cHeaderLine, "first_nul_offset", rbhtp_header_line_first_nul_offset, 0 );
+	rb_define_method( cHeaderLine, "flags", rbhtp_header_line_flags, 0 );
+	
+	cURI = rb_define_class_under( mHTP, "URI", rb_cObject );
+	rb_define_method( cURI, "initialize", rbhtp_uri_initialize, 1 );
+	
+	rb_define_method( cURI, "scheme", rbhtp_uri_scheme, 0 );
+	rb_define_method( cURI, "username", rbhtp_uri_username, 0 );
+	rb_define_method( cURI, "password", rbhtp_uri_password, 0 );
+	rb_define_method( cURI, "hostname", rbhtp_uri_hostname, 0 );
+	rb_define_method( cURI, "port", rbhtp_uri_port, 0 );
+	rb_define_method( cURI, "port_number", rbhtp_uri_port_number, 0 );
+	rb_define_method( cURI, "path", rbhtp_uri_path, 0 );
+	rb_define_method( cURI, "query", rbhtp_uri_query, 0 );
+	rb_define_method( cURI, "fragment", rbhtp_uri_fragment, 0 );
+	
+	cTx = rb_define_class_under( mHTP, "Tx", rb_cObject );
+	rb_define_method( cTx, "initialize", rbhtp_tx_initialize, 3 );
+
+	rb_define_method( cTx, "request_ignored_lines", rbhtp_tx_request_ignored_lines, 0 );
+	rb_define_method( cTx, "request_line_nul", rbhtp_tx_request_line_nul, 0 );
+	rb_define_method( cTx, "request_line_nul_offset", rbhtp_tx_request_line_nul_offset, 0 );
+	rb_define_method( cTx, "request_method_number", rbhtp_tx_request_method_number, 0 );
+	rb_define_method( cTx, "request_line", rbhtp_tx_request_line, 0 );
+	rb_define_method( cTx, "request_method", rbhtp_tx_request_method, 0 );	
+	rb_define_method( cTx, "request_uri", rbhtp_tx_request_uri, 0 );
+	rb_define_method( cTx, "request_uri_normalized", rbhtp_tx_request_uri_normalized, 0 );
+  rb_define_method( cTx, "request_protocol", rbhtp_tx_request_protocol, 0 );
+  rb_define_method( cTx, "request_headers_raw", rbhtp_tx_request_headers_raw, 0 );
+  rb_define_method( cTx, "request_headers_sep", rbhtp_tx_request_headers_sep, 0 );
+  rb_define_method( cTx, "request_content_type", rbhtp_tx_request_content_type, 0 );
+  rb_define_method( cTx, "request_auth_username", rbhtp_tx_request_auth_username, 0 );
+  rb_define_method( cTx, "request_auth_password", rbhtp_tx_request_auth_password, 0 );
+  rb_define_method( cTx, "response_line", rbhtp_tx_response_line, 0 );
+  rb_define_method( cTx, "response_protocol", rbhtp_tx_response_protocol, 0 );
+  rb_define_method( cTx, "response_status", rbhtp_tx_response_status, 0 );
+  rb_define_method( cTx, "response_message", rbhtp_tx_response_message, 0 );
+  rb_define_method( cTx, "response_headers_sep", rbhtp_tx_response_headers_sep, 0 );
+  rb_define_method( cTx, "request_protocol_number", rbhtp_tx_request_protocol_number, 0 );
+  rb_define_method( cTx, "protocol_is_simple", rbhtp_tx_protocol_is_simple, 0 );
+  rb_define_method( cTx, "request_message_len", rbhtp_tx_request_message_len, 0 );
+  rb_define_method( cTx, "request_entity_len", rbhtp_tx_request_entity_len, 0 );
+  rb_define_method( cTx, "request_nonfiledata_len", rbhtp_tx_request_nonfiledata_len, 0 );
+  rb_define_method( cTx, "request_filedata_len", rbhtp_tx_request_filedata_len, 0 );
+  rb_define_method( cTx, "request_header_lines_no_trailers", rbhtp_tx_request_header_lines_no_trailers, 0 );
+  rb_define_method( cTx, "request_headers_raw_lines", rbhtp_tx_request_headers_raw_lines, 0 );
+  rb_define_method( cTx, "request_transfer_coding", rbhtp_tx_request_transfer_coding, 0 );
+  rb_define_method( cTx, "request_content_encoding", rbhtp_tx_request_content_encoding, 0 );
+  rb_define_method( cTx, "request_params_query_reused", rbhtp_tx_request_params_query_reused, 0 );
+  rb_define_method( cTx, "request_params_body_reused", rbhtp_tx_request_params_body_reused, 0 );
+  rb_define_method( cTx, "request_auth_type", rbhtp_tx_request_auth_type, 0 );
+  rb_define_method( cTx, "response_ignored_lines", rbhtp_tx_response_ignored_lines, 0 );
+  rb_define_method( cTx, "response_protocol_number", rbhtp_tx_response_protocol_number, 0 );
+  rb_define_method( cTx, "response_status_number", rbhtp_tx_response_status_number, 0 );
+  rb_define_method( cTx, "response_status_expected_number", rbhtp_tx_response_status_expected_number, 0 );
+  rb_define_method( cTx, "seen_100continue", rbhtp_tx_seen_100continue, 0 );
+  rb_define_method( cTx, "response_message_len", rbhtp_tx_response_message_len, 0 );
+  rb_define_method( cTx, "response_entity_len", rbhtp_tx_response_entity_len, 0 );
+  rb_define_method( cTx, "response_transfer_coding", rbhtp_tx_response_transfer_coding, 0 );
+  rb_define_method( cTx, "response_content_encoding", rbhtp_tx_response_content_encoding, 0 );
+  rb_define_method( cTx, "flags", rbhtp_tx_flags, 0 );
+  rb_define_method( cTx, "progress", rbhtp_tx_progress, 0 );
+
+	rb_define_method( cTx, "request_params_query", rbhtp_tx_request_params_query, 0 );
+	rb_define_method( cTx, "request_params_body", rbhtp_tx_request_params_body, 0 );
+	rb_define_method( cTx, "request_cookies", rbhtp_tx_request_cookies, 0 );
+	rb_define_method( cTx, "request_headers", rbhtp_tx_request_headers, 0 );
+	rb_define_method( cTx, "response_headers", rbhtp_tx_response_headers, 0 );
+	
+	rb_define_method( cTx, "request_header_lines", rbhtp_tx_request_header_lines, 0 );
+	rb_define_method( cTx, "response_header_lines", rbhtp_tx_response_header_lines, 0 );
+	
+	rb_define_method( cTx, "parsed_uri", rbhtp_tx_parsed_uri, 0 );
+	rb_define_method( cTx, "parsed_uri_incomplete", rbhtp_tx_parsed_uri_incomplete, 0 );
+	
+	rb_define_method( cTx, "conn", rbhtp_tx_conn, 0 );
+	
+	cFile = rb_define_class_under( mHTP, "File", rb_cObject );
+	rb_define_method( cFile, "initialize", rbhtp_file_initialize, 1 );
+	
+	rb_define_method( cFile, "source", rbhtp_file_source, 0 );
+	rb_define_method( cFile, "filename", rbhtp_file_filename, 0 );
+	rb_define_method( cFile, "len", rbhtp_file_len, 0 );
+	rb_define_method( cFile, "tmpname", rbhtp_file_tmpname, 0 );
+	rb_define_method( cFile, "fd", rbhtp_file_fd, 0 );
+	
+	cConn = rb_define_class_under( mHTP, "Conn", rb_cObject );
+	rb_define_method( cConn, "initialize", rbhtp_conn_initialize, 2 );
+	
+	rb_define_method( cConn, "remote_addr", rbhtp_conn_remote_addr, 0 );
+	rb_define_method( cConn, "remote_port", rbhtp_conn_remote_port, 0 );
+	rb_define_method( cConn, "local_addr", rbhtp_conn_local_addr, 0 );
+	rb_define_method( cConn, "local_port", rbhtp_conn_local_port, 0 );
+	rb_define_method( cConn, "flags", rbhtp_conn_flags, 0 );
+	rb_define_method( cConn, "in_data_counter", rbhtp_conn_in_data_counter, 0 );
+	rb_define_method( cConn, "out_data_counter", rbhtp_conn_out_data_counter, 0 );
+	rb_define_method( cConn, "in_packet_counter", rbhtp_conn_in_packet_counter, 0 );
+	rb_define_method( cConn, "out_packet_counter", rbhtp_conn_out_packet_counter, 0 );
+	rb_define_method( cConn, "transactions", rbhtp_conn_transactions, 0 );
+	rb_define_method( cConn, "open_timestamp", rbhtp_conn_open_timestamp, 0 );
+	rb_define_method( cConn, "close_timestamp", rbhtp_conn_close_timestamp, 0 );
+	
+	// Load ruby code.
+	rb_require( "htp_ruby" );
+}
diff --git a/extras/ruby/README b/extras/ruby/README
new file mode 100644
index 0000000..f946c41
--- /dev/null
+++ b/extras/ruby/README
@@ -0,0 +1,58 @@
+= Introduction =
+
+Here are ruby bindings for libHTP. This project was intended for rapid
+prototyping (and as an exercise for learning libHTP) and is not intended for
+production use.
+
+The library provides a partial interface to libHTP which, where it exists,
+closely matches the C interface. The main classes are HTP::Cfg and
+HTP::Connp which correspond to htp_config_t and htp_connp, respectively.
+Functions that begin htp_config_ and htp_connp_ are methods of HTP::Cfg and
+HTP::Connp respectively.
+
+All callbacks are taken as blocks.  E.g.,
+
+  config.register_request do |connp|
+    ...
+  end
+  
+See example.rb.
+
+libHTP constants (#defines) exist as constants in HTP.
+
+In addition, classes exist for the other HTP structures: HTP::Tx, HTP::URI,
+HTP::Header, HTP::HeaderLine, etc. These classes provide read accessors for
+the various fields. In addition, some additional methods are provided for more
+Rubyish style, e.g., Header#invalid?. See htp_ruby.rb for a complete list of
+API additions.
+
+HTP::Cfg and HTP::Connp lifetimes are managed by the usual Ruby cycle,
+i.e., garbage collected when no longer references. All other classes are bound
+to the lifetimes of either of those classes. So, make sure you keep your
+config and connection parser around as long as you need any of the data from
+them or copy your data out into non-HTP classes.
+
+If performance is a concern, you should not be using Ruby or these bindings.
+That being said, some small effort has been made to avoid binding performance
+penalties for data you don't use. For example, if you never look at
+Tx#request_headers, that data will not be converted into Rubyspace. A side 
+effect of this behavior, is that return values should be cached.  E.g., 
+Tx#request_cookies generates an array of cookies every time it is called, so
+consider caching the return value if you need to access it multiple times.
+
+
+= Missing =
+
+* Cfg and Connp are only minimally implemented.
+* Conn#messages is missing.
+* Logging is completely missing.
+* Connp, and Cfg lack meaningful to_s or inspect.
+* Bool support.  As per C-interface, 0 and 1 are used instead of false and 
+  true.  Should add ...? accessors which latter values.
+* Automated unit tests.
+* API doc.
+* libHTP version detection.
+* Iterator parsing interface: Takes iterator of chunks and handles the various 
+  parsing return codes.  This allows the user to provide chunks as possible 
+  via an iterator and have the parser just-work.
+
diff --git a/extras/ruby/example.rb b/extras/ruby/example.rb
new file mode 100644
index 0000000..e802003
--- /dev/null
+++ b/extras/ruby/example.rb
@@ -0,0 +1,116 @@
+#!/usr/bin/env ruby
+
+# Copyright (c) 2009-2010 Open Information Security Foundation
+# Copyright (c) 2010-2013 Qualys, Inc.
+# 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 the Qualys, 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
+# HOLDER 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.
+
+$:.unshift( File.dirname( __FILE__ ) )
+
+require 'htp'
+
+# parse_uri example.
+uri = HTP::parse_uri( "http://host.com/hello/world" )
+puts uri
+
+puts "----"
+
+# Config and Connp example.
+cfg = HTP::Cfg.new
+
+cfg.server_personality = :apache
+cfg.register_urlencoded_parser
+# Comment out this line and notice that cookies vanish from output.
+cfg.parse_request_cookies = 1
+
+cfg.register_request do |connp|
+  tx = connp.in_tx
+  
+  puts "Parsed URI: "
+  puts "  " + tx.parsed_uri
+  
+  if tx.request_headers
+    puts "Request Headers: "
+    tx.request_headers.each {|h| puts "  " + h}
+  end
+  
+  if tx.request_cookies
+    puts "Request Cookies: "
+    tx.request_cookies.each {|k,v| puts "  #{k} = #{v}"}
+  end
+  
+  if tx.request_params_query
+    puts "Request Params Query: "
+    tx.request_params_query.each {|k,v| puts "  #{k} = #{v}"}
+  end
+
+  if tx.request_params_body
+    puts "Request Body Query: "
+    tx.request_params_body.each {|k,v| puts "  #{k} = #{v}"}
+  end
+  
+  0
+end
+
+cfg.register_request_body_data do |tx,data|
+  puts "Body Data: #{data}"
+  
+  0
+end
+
+cfg.register_request_file_data do |tx,fileinfo,data|
+  puts "File Data for #{fileinfo}: #{data}"
+  
+  0
+end
+
+connp = HTP::Connp.new( cfg )
+input = DATA.read
+
+connp.req_data( Time.now, input )
+
+# Non-Callback Interface.
+puts "----"
+
+connp.conn.transactions.each do |tx|
+  # Might be an empty transaction.
+  next if ! tx.request_line
+  puts tx
+end
+
+__END__
+POST http://user@password:host/%61/b/c?foo=bar#hi HTTP/1.1
+User-Agent: Mozilla
+Cookie: foo=bar
+Content-Type: text/plain
+Content-Length: 9
+
+Body Text
+
+
diff --git a/extras/ruby/extconf.rb b/extras/ruby/extconf.rb
new file mode 100644
index 0000000..ad66ab0
--- /dev/null
+++ b/extras/ruby/extconf.rb
@@ -0,0 +1,6 @@
+require 'mkmf'
+
+dir_config( 'htp' )
+have_library( 'htp', 'htp_connp_create' ) || abort( "Can't find HTP library." )
+have_header( 'htp/htp.h' ) || abort( "Can't find htp.h" )
+create_makefile( 'htp' )
diff --git a/extras/ruby/htp.gemspec b/extras/ruby/htp.gemspec
new file mode 100644
index 0000000..37223de
--- /dev/null
+++ b/extras/ruby/htp.gemspec
@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name = "htp"
+  s.version = "0.1"
+  
+  s.authors = ["Chrustopher Alfeld"]
+  s.description = "Ruby Bindings for libHTP."
+  s.email = "calfeld@qualys.com"
+  s.files = ["htp_ruby.rb", "HTP.c", "extconf.rb", "example.rb"]
+  s.extensions = ["extconf.rb"]
+  s.summary = "libHTP Ruby bindings."
+  s.require_path = '.'
+end
diff --git a/extras/ruby/htp_ruby.rb b/extras/ruby/htp_ruby.rb
new file mode 100644
index 0000000..0eccaac
--- /dev/null
+++ b/extras/ruby/htp_ruby.rb
@@ -0,0 +1,247 @@
+# Copyright (c) 2009-2010 Open Information Security Foundation
+# Copyright (c) 2010-2013 Qualys, Inc.
+# 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 the Qualys, 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
+# HOLDER 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.
+
+# Author: Christopher Alfeld <calfeld@qualys.com>
+
+module HTP
+  # TODO: Lots to do.  Good inspect for all classes would be a good start.
+  # As would an easier parsing interface that takes care of the return codes.
+  
+  class Cfg
+    # Object.dup will just create a Config that points to the same underlying
+    # htp_cfg_t.  By using #copy which maps to htp_config_copy, we can do
+    # the expected dup behavior.
+    alias :dup :copy
+
+    SERVER_PERSONALITY_ASSOC = [
+      [ :minimal, HTP_SERVER_MINIMAL ],
+      [ :generic, HTP_SERVER_GENERIC ],
+      [ :ids, HTP_SERVER_IDS ],
+      [ :iis_4_0, HTP_SERVER_IIS_4_0 ],
+      [ :iis_5_0, HTP_SERVER_IIS_5_0 ],
+      [ :iis_5_1, HTP_SERVER_IIS_5_1 ],
+      [ :iis_6_0, HTP_SERVER_IIS_6_0 ],
+      [ :iis_7_0, HTP_SERVER_IIS_7_0 ],
+      [ :iis_7_5, HTP_SERVER_IIS_7_5 ],
+      [ :tomcat_6_0, HTP_SERVER_TOMCAT_6_0 ],
+      [ :apache, HTP_SERVER_APACHE ],
+      [ :apache_2_2, HTP_SERVER_APACHE_2_2 ]
+    ].freeze
+    
+    def server_personality
+      personality_id = spersonality
+      personality = SERVER_PERSONALITY_ASSOC.rassoc( personality_id )[0]
+      personality.nil? ? personality_id : personality
+    end
+    def server_personality=( personality )
+      if personality.is_a?( String )
+        personality = personality.to_sym
+      end
+      if personality.is_a?( Symbol )
+        personality_id = SERVER_PERSONALITY_ASSOC.assoc( personality )[1]
+        if personality_id.nil?
+          raise TypeError.new( "Unknown personality: #{personality}" )
+        end
+        personality = personality_id
+      end
+      if ! personality.is_a?( Fixnum )
+        raise TypeError.new( "Can't understand personality." ) 
+      end
+      set_server_personality( personality )
+    end 
+  end
+    
+  class Connp
+    attr_reader :cfg
+  end
+  
+  class Header
+    def invalid?
+      flags & HTP_FIELD_INVALID != 0
+    end
+    
+    def folded?
+      flags & HTP_FIELD_FOLDED != 0
+    end
+    
+    def repeated?
+      flags & HTP_FIELD_REPEATED != 0
+    end
+    
+    def to_s
+      r = "#{name}: #{value}"
+      r += " <INVALID>" if invalid?
+      r += " <FOLDER>" if folded?
+      r += " <REPEATED>" if repeated?
+      r
+    end
+    
+    alias :inspect :to_s
+    alias :to_str :to_s
+  end
+  
+  class HeaderLine
+    def invalid?
+      flags & HTP_FIELD_INVALID != 0
+    end
+    
+    def long?
+      flags & HTP_FIELD_LONG != 0
+    end
+    
+    def nul_byte?
+      flags & HTP_FIELD_NUL_BYTE != 0
+    end
+    
+    def to_s
+      line
+    end
+    
+    alias :inspect :to_s
+    alias :to_str :to_s
+  end
+  
+  class URI
+    def to_s
+      if hostname
+        "http://" +
+        ( username ? username : '' ) +
+        ( password ? ":#{password}" : '' ) +
+        ( hostname && ( username || password ) ? '@' : '' ) +
+        ( hostname ? "#{hostname}:#{port}" : '' )
+      else
+        ''
+      end + 
+      ( path ? path : '' ) +
+      ( query ? "?#{query}" : '' ) +
+      ( fragment ? "##{fragment}" : '' )
+    end
+    
+    alias :inspect :to_s
+    alias :to_str :to_s
+  end
+  
+  class Tx
+    attr_reader :connp
+    attr_reader :cfg
+    
+    # Here we cache a variety of values that are built on demand.
+    [
+      :request_params_query,
+      :request_params_body,
+      :request_cookies,
+      :request_headers,
+      :response_headers,
+      :request_header_lines,
+      :response_header_lines
+    ].each do |name|
+      raw_name = ( "_" + name.to_s ).to_sym
+      alias_method( raw_name, name )
+      private( raw_name )
+      remove_method( name )
+      define_method name do
+        @cache ||= {}
+        @cache[name] ||= send( raw_name )
+      end
+    end
+
+    def invalid_chunking?
+      flags & HTP_INVALID_CHUNKING != 0
+    end
+    
+    def invalid_folding?
+      flags & HTP_INVALID_FOLDING != 0
+    end
+    
+    def request_smuggling?
+      flags & HTP_REQUEST_SMUGGLING != 0
+    end
+    
+    def multi_packet_header?
+      flags & HTP_MULTI_PACKET_HEAD != 0
+    end
+    
+    def field_unparseable?
+      flags & HTP_FIELD_UNPARSABLE != 0
+    end
+    
+    def request_params_as_hash
+      if ! @request_params
+        @request_params = Hash.new {|h,k| h[k] = []}
+        [ request_params_query, request_params_body ].compact.each do |result|
+          result.each do |k,v|
+            @request_params[k] << v
+          end
+        end
+      end
+      @request_params
+    end
+    
+    def request_cookies_as_hash
+      if ! @request_cookies
+        @request_cookies = Hash.new {|h,k| h[k] = []}
+        result = request_cookies
+        if result
+          result.each do |k,v|
+            @request_cookies[k] << v
+          end
+        end
+      end
+      @request_cookies
+    end
+    
+    alias :to_s :request_line
+    alias :to_str :to_s
+    alias :inspect :to_s
+  end
+  
+  class File
+    alias :to_s :filename
+    alias :inspect :to_s
+    alias :to_str :to_s
+  end 
+  
+  class Conn
+    attr_reader :connp
+    
+    def pipelined_connection?
+      flags & PIPELINED_CONNECTION
+    end
+    
+    def to_s
+      ( local_addr || "???" ) + ":#{local_port} -> " +
+      ( remote_addr || "???" ) + ":#{remote_port}"
+    end
+    
+    alias :to_str :to_s
+    alias :inspect :to_s
+  end
+end
\ No newline at end of file