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

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

7 files changed, 2016 insertions, 0 deletions

diff --git a/extras/htptest.c b/extras/htptest.c
new file mode 100644
index 0000000..472db5e
--- /dev/null
+++ b/extras/htptest.c
@@ -0,0 +1,569 @@
+/***************************************************************************
+ * 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.
+ ***************************************************************************/
+
+/**
+ * @file
+ * @author Ivan Ristic <ivanr@webkreator.com>
+ */
+
+/*
+ * This program is a simple example of how to use LibHTP to parse a HTTP
+ * connection stream. It uses libnids for TCP reassembly and LibHTP for
+ * HTTP parsing.
+ *
+ * This program is only meant as an demonstration; it is not suitable
+ * to be used in production. Furthermore, libnids itself was unreliable
+ * in my tests.
+ *
+ * Compile with:
+ *
+ *     $ gcc htptest.c -lhtp -lz -lnids -o htptest
+ *
+ */
+            
+#include <errno.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/in_systm.h>
+#include <arpa/inet.h>
+#include <string.h>
+#include <stdio.h>
+#include "nids.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include <htp/htp.h>
+#include <htp/htp_list.h>
+#include <htp/htp_table.h>
+
+#define DIRECTION_CLIENT    1
+#define DIRECTION_SERVER    2
+
+typedef struct chunk_t chunk_t;
+typedef struct stream_data stream_data;
+
+/** Data chunk structure */
+struct chunk_t {
+    char *data;
+    size_t len;
+    int direction;
+    size_t consumed;
+};
+
+/** Per-stream data structure */
+struct stream_data {
+    int id;
+    htp_connp_t *connp;
+    int direction;
+    int fd;    
+    int chunk_counter;
+    int log_level;
+    int req_count;
+    htp_list_t *chunks;
+    htp_list_t *inbound_chunks;
+    htp_list_t *outbound_chunks;
+};
+
+/** LibHTP parser configuration */
+htp_cfg_t *cfg;
+
+/** Connection counter */
+int counter = 1000;
+
+/**
+ * Free stream data.
+ *
+ * @param[in] sd
+ */
+void free_stream_data(stream_data *sd) {
+    if (sd == NULL) return;
+    
+    // Free stream chunks, if any
+    if (sd->chunks != NULL) {
+        for (int i = 0, n = htp_list_size(sd->chunks); i < n; i++) {
+            chunk_t *chunk = htp_list_get(sd->chunks, i);
+            free(chunk->data);
+            free(chunk);
+        }
+        
+        htp_list_destroy(sd->chunks);
+        sd->chunked = NULL;
+    }
+    
+    // Free inbound chunks, if any
+    if (sd->inbound_chunks != NULL) {
+        for (int i = 0, n = htp_list_size(sd->inbound_chunks); i < n; i++) {
+            chunk_t *chunk = htp_list_get(sd->inbound_chunkds, i);
+            free(chunk->data);
+            free(chunk);
+        }
+        
+        htp_list_destroy(sd->inbound_chunks);
+        sd->inbound_chunks = NULL;
+    }
+    
+    // Free outbound chunks, if any
+    if (sd->outbound_chunks != NULL) {
+        for (int i = 0, n = htp_list_size(sd->outbound_chunks); i < n; i++) {
+            chunk_t *chunk = htp_list_get(sd->outbound_chunkds, i);
+            free(chunk->data);
+            free(chunk);
+        }
+        
+        htp_list_destroy(sd->outbound_chunks);
+        sd->outbound_chunks = NULL;
+    }
+
+    // Close the stream file, if we have it open    
+    if (sd->fd != -1) {
+        close(sd->fd);
+    }
+    
+    free(sd);
+}
+
+/**
+ * Process as much buffered inbound and outbound data as possible
+ * (in that order)
+ *
+ * @param[in] sd
+ */
+void process_stored_stream_data(stream_data *sd) {
+    int loop = 0;
+
+    do {
+        // Reset loop
+        loop = 0;
+        
+        // Send as much inbound data as possible    
+        while((sd->connp->in_status == HTP_STREAM_DATA)&&(htp_list_size(sd->inbound_chunks) > 0)) {
+            chunk_t *chunk = (chunk_t *)htp_list_get(sd->inbound_chunks, 0);
+                
+            int rc = htp_connp_req_data(sd->connp, 0, chunk->data + chunk->consumed, chunk->len - chunk->consumed);
+            if (rc == HTP_STREAM_DATA) {
+                // The entire chunk was consumed
+                htp_list_shift(sd->inbound_chunks);
+                free(chunk->data);
+                free(chunk);
+            } else {
+                // Partial consumption
+                chunk->consumed = htp_connp_req_data_consumed(sd->connp);
+            }
+        }
+   
+        // Send as much outbound data as possible          
+        while((sd->connp->out_status == HTP_STREAM_DATA)&&(htp_list_size(sd->outbound_chunks) > 0)) {
+            chunk_t *chunk = (chunk_t *)htp_list_get(sd->outbound_chunks, 0);
+                
+            int rc = htp_connp_res_data(sd->connp, 0, chunk->data + chunk->consumed, chunk->len - chunk->consumed);
+            if (rc == HTP_STREAM_DATA) {
+                // The entire chunk was consumed
+                htp_list_shift(sd->outbound_chunks);
+                free(chunk->data);
+                free(chunk);
+            } else {
+                // Partial consumption
+                chunk->consumed = htp_connp_res_data_consumed(sd->connp);
+            }
+            
+            // Whenever we send some outbound data to the parser,
+            // we need to go back and try to send inbound data
+            // if we have it.
+            loop = 1;
+        }
+    } while(loop);
+}
+
+/**
+ * Process a chunk of the connection stream.
+ *
+ * @param[in] sd
+ * @param[in] direction
+ * @param[in] hlf
+ */
+void process_stream_data(stream_data *sd, int direction, struct half_stream *hlf) {
+    chunk_t *chunk = NULL;
+    int rc;
+    
+    //printf("#DATA direction %d bytes %d\n", sd->direction, hlf->count_new);
+    
+    if (sd->direction == direction) {
+        // Inbound data
+        
+        switch(sd->connp->in_status) {
+            case HTP_STREAM_NEW :
+            case HTP_STREAM_DATA :
+                // Send data to parser
+                
+                rc = htp_connp_req_data(sd->connp, 0, hlf->data, hlf->count_new);
+                if (rc == HTP_STREAM_DATA_OTHER) {
+                    // Encountered inbound parsing block
+                    
+                    // Store partial chunk for later
+                    chunk = calloc(1, sizeof(chunk_t));
+                    // TODO
+                    chunk->len = hlf->count_new - htp_connp_req_data_consumed(sd->connp);
+                    chunk->data = malloc(chunk->len);
+                    // TODO
+                    memcpy(chunk->data, hlf->data + htp_connp_req_data_consumed(sd->connp), chunk->len);
+                    htp_list_add(sd->inbound_chunks, chunk);
+                } else
+                if (rc != HTP_STREAM_DATA) {
+                    // Inbound parsing error
+                    sd->log_level = 0;
+                    fprintf(stderr, "[#%d] Inbound parsing error: %d\n", sd->id, rc);
+                    // TODO Write connection to disk
+                }
+                break;
+                
+            case HTP_STREAM_ERROR :
+                // Do nothing
+                break;
+                
+            case HTP_STREAM_DATA_OTHER :
+                // Store data for later
+                chunk = calloc(1, sizeof(chunk_t));
+                // TODO
+                chunk->len = hlf->count_new;
+                chunk->data = malloc(chunk->len);
+                // TODO
+                memcpy(chunk->data, hlf->data, chunk->len);
+                htp_list_add(sd->inbound_chunks, chunk);
+                break;
+        }
+    } else {
+        // Outbound data
+        switch(sd->connp->out_status) {
+            case HTP_STREAM_NEW :
+            case HTP_STREAM_DATA :
+                // Send data to parser
+                
+                rc = htp_connp_res_data(sd->connp, 0, hlf->data, hlf->count_new);
+                if (rc == HTP_STREAM_DATA_OTHER) {
+                    // Encountered outbound parsing block
+                    
+                    // Store partial chunk for later
+                    chunk = calloc(1, sizeof(chunk_t));
+                    // TODO
+                    chunk->len = hlf->count_new - htp_connp_res_data_consumed(sd->connp);
+                    chunk->data = malloc(chunk->len);
+                    // TODO
+                    memcpy(chunk->data, hlf->data + htp_connp_res_data_consumed(sd->connp), chunk->len);
+                    htp_list_add(sd->outbound_chunks, chunk);
+                } else
+                if (rc != HTP_STREAM_DATA) {
+                    // Outbound parsing error
+                    sd->log_level = 0;
+                    fprintf(stderr, "[#%d] Outbound parsing error: %d\n", sd->id, rc);
+                }
+                break;
+                
+            case HTP_STREAM_ERROR :
+                // Do nothing
+                break;
+                
+            case HTP_STREAM_DATA_OTHER :
+                // Store data for later
+                chunk = calloc(1, sizeof(chunk_t));
+                // TODO
+                chunk->len = hlf->count_new;
+                chunk->data = malloc(chunk->len);
+                // TODO
+                memcpy(chunk->data, hlf->data, chunk->len);
+                htp_list_add(sd->outbound_chunks, chunk);
+                break;
+        }
+    }
+    
+    // Process as much stored data as possible    
+    process_stored_stream_data(sd);
+}
+
+/**
+ * Called by libnids whenever it has an event we have to handle.
+ *
+ * @param[in] tcp
+ * @param[in] user_data
+ */
+void tcp_callback (struct tcp_stream *tcp, void **user_data) {	
+    stream_data *sd = *user_data;
+
+    // New connection
+    if (tcp->nids_state == NIDS_JUST_EST) {
+        tcp->client.collect++;
+        tcp->server.collect++;
+        tcp->server.collect_urg++;
+        tcp->client.collect_urg++;
+
+        // Allocate custom per-stream data      
+        sd = calloc(1, sizeof(stream_data));
+        sd->id = counter++;
+        sd->direction = -1;
+        sd->fd = -1;
+        sd->log_level = -1;
+        sd->chunks = htp_list_array_create(16);
+        sd->inbound_chunks = htp_list_array_create(16);
+        sd->outbound_chunks = htp_list_array_create(16);
+        sd->req_count = 1;
+        
+        // Init LibHTP parser
+        sd->connp = htp_connp_create(cfg);
+        if (sd->connp == NULL) {
+            fprintf(stderr, "Failed to create LibHTP parser instance.\n");
+            exit(1);
+        }
+        
+        // Associate TCP stream information with the HTTP connection parser
+        htp_connp_set_user_data(sd->connp, sd);
+
+        // Associate TCP stream information with the libnids structures
+        *user_data = sd;
+        
+        return;
+    }
+    
+    // Connection close
+    if (tcp->nids_state == NIDS_CLOSE) {
+        if (sd == NULL) return;
+        
+        // Destroy parser
+        htp_connp_destroy_all(sd->connp);
+            
+        // Free custom per-stream data
+        free_stream_data(sd);
+      
+        return;
+    }
+
+    // Connection close (RST)    
+    if (tcp->nids_state == NIDS_RESET) {
+        if (sd == NULL) return;
+        
+        // Destroy parser
+        htp_connp_destroy_all(sd->connp);
+            
+        // Free custom per-stream data
+        free_stream_data(sd);
+      
+        return;
+    }
+
+    if (tcp->nids_state == NIDS_DATA) {
+        struct half_stream *hlf;
+        int direction;
+        
+        if (tcp->client.count_new) {
+            hlf = &tcp->client;
+            direction = DIRECTION_SERVER;
+        } else {
+            hlf = &tcp->server;
+            direction = DIRECTION_CLIENT;
+        }
+    
+        if (sd == NULL) return;
+        
+        if (sd->direction == -1) {
+            sd->direction = direction;
+        }
+
+        // Write data to disk or store for later        
+        if (sd->fd == -1) {
+            // Store data, as we may need it later
+            chunk_t *chunk = calloc(1, sizeof(chunk_t));
+            // TODO
+            chunk->direction = direction;
+            chunk->data = malloc(hlf->count_new);
+            // TODO
+            chunk->len = hlf->count_new;
+            memcpy(chunk->data, hlf->data, chunk->len);
+            
+            htp_list_add(sd->chunks, chunk);
+        } else {        
+            // No need to store, write directly to file
+            
+            if (sd->chunk_counter != 0) {
+                write(sd->fd, "\r\n", 2);
+            }
+            
+            if (sd->direction == direction) {
+                write(sd->fd, ">>>\r\n", 5);
+            } else {
+                write(sd->fd, "<<<\r\n", 5);
+            }
+            
+            write(sd->fd, hlf->data, hlf->count_new);                
+            
+            sd->chunk_counter++;
+        }
+
+        // Process data        
+        process_stream_data(sd, direction, hlf);
+        
+        return;        
+    }
+}
+
+/**
+ * Invoked at the end of every transaction. 
+ *
+ * @param[in] connp
+ */
+int callback_response(htp_connp_t *connp) {
+    stream_data *sd = (stream_data *)htp_connp_get_user_data(connp);
+    
+    char *x = bstr_util_strdup_to_c(connp->out_tx->request_line);
+    fprintf(stdout, "[#%d/%d] %s\n", sd->id, sd->req_count, x);
+    free(x);
+    
+    sd->req_count++;
+}
+
+/**
+ * Invoked every time LibHTP wants to log. 
+ *
+ * @param[in] log
+ */
+int callback_log(htp_log_t *log) {
+    stream_data *sd = (stream_data *)htp_connp_get_user_data(log->connp);
+    
+    if ((sd->log_level == -1)||(sd->log_level > log->level)) {
+        sd->log_level = log->level;
+    }
+
+    if (log->code != 0) {
+        fprintf(stderr, "[#%d/%d][%d][code %d][file %s][line %d] %s\n", sd->id, sd->req_count,
+            log->level, log->code, log->file, log->line, log->msg);
+    } else {
+        fprintf(stderr, "[#%d/%d][%d][file %s][line %d] %s\n", sd->id, sd->req_count,
+            log->level, log->file, log->line, log->msg);
+    }
+    
+    // If this is the first time a log message was generated for this connection,
+    // start writing the entire thing to a file on disk.
+    if (sd->fd == -1) {
+        char filename[256];        
+        
+        // TODO Use IP addresses and ports in filename
+        snprintf(filename, 255, "conn-%d.t", sd->id);
+        
+        sd->fd = open(filename, O_CREAT | O_TRUNC | O_RDWR, S_IRUSR | S_IWUSR);
+        if (sd->fd == -1) {
+            fprintf(stderr, "Failed to create file %s: %s\n", filename, strerror(errno));
+            exit(1);
+        }
+
+        // Write to disk the data we have in memory                
+        for (int i = 0, n = htp_list_size(sd->chunks); i < n; i++) {
+            chunk_t *chunk = htp_list_get(sd->chunks, i);
+
+            if (sd->chunk_counter != 0) {
+                write(sd->fd, "\r\n", 2);
+            }
+            
+            if (sd->direction == chunk->direction) {
+                write(sd->fd, ">>>\r\n", 5);
+            } else {
+                write(sd->fd, "<<<\r\n", 5);
+            }
+            
+            write(sd->fd, chunk->data, chunk->len);
+            
+            sd->chunk_counter++;
+        }
+    }
+}
+
+/**
+ * Prints usage.
+ */
+void print_usage() {
+    fprintf(stdout, "Usage: htpMon [-r file] [\"expression\"]\n");
+}
+
+/**
+ * Main entry point for this program.
+ *
+ * @param[in] argc
+ * @param[in] argv
+ */
+int main(int argc, char *argv[]) {
+    // Check parameters
+    if ((argc < 2)||(argc > 4)) {
+        print_usage();
+        return 1;
+    }
+
+    // Configure libnids
+    if (argc > 2) {
+        if (strcmp(argv[1], "-r") != 0) {
+            print_usage();
+            return 1;
+        }
+        
+        nids_params.filename = argv[2];        
+        
+        if (argc == 4) {
+            nids_params.pcap_filter = argv[3];
+        }
+    } else {
+        nids_params.pcap_filter = argv[1];
+    }
+    
+    // Initialize libnids
+    if (!nids_init()) {
+        fprintf(stderr, "libnids initialization failed: %s\n", nids_errbuf);
+        return 1;
+    }
+
+    // Create LibHTP configuration    
+    cfg = htp_config_create();
+    htp_config_set_server_personality(cfg, HTP_SERVER_APACHE_2_2);
+    
+    htp_config_register_response_complete(cfg, callback_response);
+    htp_config_register_log(cfg, callback_log);
+
+    // Run libnids
+    nids_register_tcp(tcp_callback);
+    nids_run();
+
+    // Destroy LibHTP configuration    
+    htp_config_destroy(cfg);
+    
+    return 0;    
+}
+
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