mongrel 1.0.1 → 1.0.2

data/ext/http11/http11_parser.h

@@ -30,6 +30,7 @@ typedef struct http_parser {
   field_cb http_field;
   element_cb request_method;
   element_cb request_uri;
+  element_cb fragment;
   element_cb request_path;
   element_cb query_string;
   element_cb http_version;

data/ext/http11/http11_parser.java.rl

@@ -0,0 +1,170 @@
+package org.jruby.mongrel;
+
+import org.jruby.util.ByteList;
+
+public class Http11Parser {
+
+/** Machine **/
+
+%%{
+  
+  machine http_parser;
+
+  action mark {parser.mark = fpc; }
+
+  action start_field { parser.field_start = fpc; }
+  action write_field { 
+    parser.field_len = fpc-parser.field_start;
+  }
+
+  action start_value { parser.mark = fpc; }
+  action write_value { 
+    if(parser.http_field != null) {
+      parser.http_field.call(parser.data, parser.field_start, parser.field_len, parser.mark, fpc-parser.mark);
+    }
+  }
+  action request_method { 
+    if(parser.request_method != null) 
+      parser.request_method.call(parser.data, parser.mark, fpc-parser.mark);
+  }
+  action request_uri { 
+    if(parser.request_uri != null)
+      parser.request_uri.call(parser.data, parser.mark, fpc-parser.mark);
+  }
+  action fragment { 
+    if(parser.fragment != null)
+      parser.fragment.call(parser.data, parser.mark, fpc-parser.mark);
+  }
+  
+  action start_query {parser.query_start = fpc; }
+  action query_string { 
+    if(parser.query_string != null)
+      parser.query_string.call(parser.data, parser.query_start, fpc-parser.query_start);
+  }
+
+  action http_version {	
+    if(parser.http_version != null)
+      parser.http_version.call(parser.data, parser.mark, fpc-parser.mark);
+  }
+
+  action request_path {
+    if(parser.request_path != null)
+      parser.request_path.call(parser.data, parser.mark, fpc-parser.mark);
+  }
+
+  action done { 
+    parser.body_start = fpc + 1; 
+    if(parser.header_done != null)
+      parser.header_done.call(parser.data, fpc + 1, pe - fpc - 1);
+    fbreak;
+  }
+
+  include http_parser_common "http11_parser_common.rl";
+
+}%%
+
+/** Data **/
+%% write data;
+
+   public static interface ElementCB {
+     public void call(Object data, int at, int length);
+   }
+
+   public static interface FieldCB {
+     public void call(Object data, int field, int flen, int value, int vlen);
+   }
+
+   public static class HttpParser {
+      int cs;
+      int body_start;
+      int content_len;
+      int nread;
+      int mark;
+      int field_start;
+      int field_len;
+      int query_start;
+
+      Object data;
+      ByteList buffer;
+
+      public FieldCB http_field;
+      public ElementCB request_method;
+      public ElementCB request_uri;
+      public ElementCB fragment;
+      public ElementCB request_path;
+      public ElementCB query_string;
+      public ElementCB http_version;
+      public ElementCB header_done;
+
+      public void init() {
+          cs = 0;
+
+          %% write init;
+
+          body_start = 0;
+          content_len = 0;
+          mark = 0;
+          nread = 0;
+          field_len = 0;
+          field_start = 0;
+      }
+   }
+
+   public final HttpParser parser = new HttpParser();
+
+   public int execute(ByteList buffer, int off) {
+     int p, pe;
+     int cs = parser.cs;
+     int len = buffer.realSize;
+     assert off<=len : "offset past end of buffer";
+
+     p = off;
+     pe = len;
+     byte[] data = buffer.bytes;
+     parser.buffer = buffer;
+
+     %% write exec;
+
+     parser.cs = cs;
+     parser.nread += (p - off);
+     
+     assert p <= pe                  : "buffer overflow after parsing execute";
+     assert parser.nread <= len      : "nread longer than length";
+     assert parser.body_start <= len : "body starts after buffer end";
+     assert parser.mark < len        : "mark is after buffer end";
+     assert parser.field_len <= len  : "field has length longer than whole buffer";
+     assert parser.field_start < len : "field starts after buffer end";
+
+     if(parser.body_start>0) {
+        /* final \r\n combo encountered so stop right here */
+        %%write eof;
+        parser.nread++;
+     }
+
+     return parser.nread;
+   }
+
+   public int finish() {
+     int cs = parser.cs;
+
+     %%write eof;
+
+     parser.cs = cs;
+ 
+    if(has_error()) {
+      return -1;
+    } else if(is_finished()) {
+      return 1;
+    } else {
+      return 0;
+    }
+  }
+
+  public boolean has_error() {
+    return parser.cs == http_parser_error;
+  }
+
+  public boolean is_finished() {
+    return parser.cs == http_parser_first_final;
+  }
+}

data/ext/http11/http11_parser.rl

@@ -13,8 +13,10 @@
 #define MARK(M,FPC) (parser->M = (FPC) - buffer)
 #define PTR_TO(F) (buffer + parser->F)
 
-/** machine **/
+/** Machine **/
+
 %%{
+  
   machine http_parser;
 
   action mark {MARK(mark, fpc); }
@@ -39,6 +41,10 @@
     if(parser->request_uri != NULL)
       parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, fpc));
   }
+  action fragment { 
+    if(parser->fragment != NULL)
+      parser->fragment(parser->data, PTR_TO(mark), LEN(mark, fpc));
+  }
 
   action start_query {MARK(query_start, fpc); }
   action query_string { 
@@ -63,54 +69,8 @@
     fbreak;
   }
 
+  include http_parser_common "http11_parser_common.rl";
 
-#### HTTP PROTOCOL GRAMMAR
-# line endings
-  CRLF = "\r\n";
-
-# character types
-  CTL = (cntrl | 127);
-  safe = ("$" | "-" | "_" | ".");
-  extra = ("!" | "*" | "'" | "(" | ")" | ",");
-  reserved = (";" | "/" | "?" | ":" | "@" | "&" | "=" | "+");
-  unsafe = (CTL | " " | "\"" | "#" | "%" | "<" | ">");
-  national = any -- (alpha | digit | reserved | extra | safe | unsafe);
-  unreserved = (alpha | digit | safe | extra | national);
-  escape = ("%" xdigit xdigit);
-  uchar = (unreserved | escape);
-  pchar = (uchar | ":" | "@" | "&" | "=" | "+");
-  tspecials = ("(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\\" | "\"" | "/" | "[" | "]" | "?" | "=" | "{" | "}" | " " | "\t");
-
-# elements
-  token = (ascii -- (CTL | tspecials));
-
-# URI schemes and absolute paths
-  scheme = ( alpha | digit | "+" | "-" | "." )* ;
-  absolute_uri = (scheme ":" (uchar | reserved )*);
-
-  path = (pchar+ ( "/" pchar* )*) ;
-  query = ( uchar | reserved )* %query_string ;
-  param = ( pchar | "/" )* ;
-  params = (param ( ";" param )*) ;
-  rel_path = (path? %request_path (";" params)?) ("?" %start_query query)?;
-  absolute_path = ("/"+ rel_path);
-
-  Request_URI = ("*" | absolute_uri | absolute_path) >mark %request_uri;
-  Method = (upper | digit | safe){1,20} >mark %request_method;
-
-  http_number = (digit+ "." digit+) ;
-  HTTP_Version = ("HTTP/" http_number) >mark %http_version ;
-  Request_Line = (Method " " Request_URI " " HTTP_Version CRLF) ;
-
-  field_name = (token -- ":")+ >start_field %write_field;
-
-  field_value = any* >start_value %write_value;
-
-  message_header = field_name ":" " "* field_value :> CRLF;
-
-  Request = Request_Line (message_header)* ( CRLF @done);
-
-main := Request;
 }%%
 
 /** Data **/

data/ext/http11/http11_parser_common.rl

@@ -0,0 +1,54 @@
+%%{
+  
+  machine http_parser_common;
+
+#### HTTP PROTOCOL GRAMMAR
+# line endings
+  CRLF = "\r\n";
+
+# character types
+  CTL = (cntrl | 127);
+  safe = ("$" | "-" | "_" | ".");
+  extra = ("!" | "*" | "'" | "(" | ")" | ",");
+  reserved = (";" | "/" | "?" | ":" | "@" | "&" | "=" | "+");
+  unsafe = (CTL | " " | "\"" | "#" | "%" | "<" | ">");
+  national = any -- (alpha | digit | reserved | extra | safe | unsafe);
+  unreserved = (alpha | digit | safe | extra | national);
+  escape = ("%" xdigit xdigit);
+  uchar = (unreserved | escape);
+  pchar = (uchar | ":" | "@" | "&" | "=" | "+");
+  tspecials = ("(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\\" | "\"" | "/" | "[" | "]" | "?" | "=" | "{" | "}" | " " | "\t");
+
+# elements
+  token = (ascii -- (CTL | tspecials));
+
+# URI schemes and absolute paths
+  scheme = ( alpha | digit | "+" | "-" | "." )* ;
+  absolute_uri = (scheme ":" (uchar | reserved )*);
+
+  path = ( pchar+ ( "/" pchar* )* ) ;
+  query = ( uchar | reserved )* %query_string ;
+  param = ( pchar | "/" )* ;
+  params = ( param ( ";" param )* ) ;
+  rel_path = ( path? %request_path (";" params)? ) ("?" %start_query query)?;
+  absolute_path = ( "/"+ rel_path );
+
+  Request_URI = ( "*" | absolute_uri | absolute_path ) >mark %request_uri;
+  Fragment = ( uchar | reserved )* >mark %fragment;
+  Method = ( upper | digit | safe ){1,20} >mark %request_method;
+
+  http_number = ( digit+ "." digit+ ) ;
+  HTTP_Version = ( "HTTP/" http_number ) >mark %http_version ;
+  Request_Line = ( Method " " Request_URI ("#" Fragment){0,1} " " HTTP_Version CRLF ) ;
+
+  field_name = ( token -- ":" )+ >start_field %write_field;
+
+  field_value = any* >start_value %write_value;
+
+  message_header = field_name ":" " "* field_value :> CRLF;
+
+  Request = Request_Line ( message_header )* ( CRLF @done );
+
+main := Request;
+
+}%%

data/ext/http11/tst.h

@@ -24,14 +24,14 @@ struct node_lines
 
 enum tst_constants
 {
-   TST_OK, TST_ERROR, TST_NULL_KEY, TST_DUPLICATE_KEY, TST_REPLACE
+   TST_OK, TST_ERROR, TST_NULL_KEY, TST_DUPLICATE_KEY, TST_REPLACE, TST_LONGEST_MATCH
 };
 
 struct tst *tst_init(int node_line_width);
 
 int tst_insert(unsigned char *key, void *data, struct tst *tst, int option, void **exist_ptr);
 
-void *tst_search(unsigned char *key, struct tst *tst, int *prefix_len);
+void *tst_search(const unsigned char *key, struct tst *tst, int option, unsigned int *match_len);
 
 void *tst_delete(unsigned char *key, struct tst *tst);
 

data/ext/http11/tst_cleanup.c

@@ -21,4 +21,3 @@ void tst_cleanup(struct tst *tst)
 
    free(tst);
 }
-

data/ext/http11/tst_insert.c

@@ -2,16 +2,16 @@
 #include "tst.h"
 #include <stdio.h>
 #include <stdlib.h>
-
+#include <string.h> 
 
 int tst_grow_node_free_list(struct tst *tst);
 int tst_insert(unsigned char *key, void *data, struct tst *tst, int option, void **exist_ptr)
 {
    struct node *current_node;
    struct node *new_node_tree_begin = NULL;
+   struct node *new_node;
    int key_index;
    int perform_loop = 1;
-
    
    if (key == NULL)
       return TST_NULL_KEY;
@@ -91,7 +91,33 @@ int tst_insert(unsigned char *key, void *data, struct tst *tst, int option, void
             }
          }
       }
-   
+      if(key[key_index] == 0)
+      {
+      	 if(tst->free_list == NULL)
+	 {
+	     if(tst_grow_node_free_list(tst) != 1)
+		 return TST_ERROR;
+	 }
+	 new_node = tst->free_list;
+	 tst->free_list = tst->free_list->middle;
+
+	 memcpy((void*)new_node, (void*)current_node, sizeof(struct node));
+	 current_node->value = 0;
+	 if(new_node->value < 64)
+	 {
+	    current_node->left = new_node;
+	    current_node->right = '\0';
+	 }
+	 else
+	 {
+	    current_node->left = '\0';
+	    current_node->right = new_node;
+         }
+
+         current_node->middle = data;
+         return TST_OK;
+      }
+
       if( ((current_node->value == 0) && (key[key_index] < 64)) ||
          ((current_node->value != 0) && (key[key_index] <
          current_node->value)) )

data/ext/http11/tst_search.c

@@ -4,65 +4,70 @@
 #include <stdlib.h>
 #include <assert.h>
 
-void *tst_search(unsigned char *key, struct tst *tst, int *prefix_len)
+
+void *tst_search(const unsigned char *key, struct tst *tst, int option,
+		 unsigned int *match_len)
 {
-  struct node *current_node;
-  void *longest_match = NULL;
-  int key_index;
-  
-  assert(key != NULL && "key can't be NULL");
-  assert(tst != NULL && "tst can't be NULL");
-  
-  if(key[0] == 0)
-    return NULL;
-  
-  if(tst->head[(int)key[0]] == NULL)
-    return NULL;
+    struct node *current_node;
+    struct node *longest_match = NULL;
+    unsigned int longest_match_len = 0;
+    int key_index;
+
+    assert(key != NULL && "key can't be NULL");
+    assert(tst != NULL && "tst can't be NULL");
+
+    if (key[0] == 0)
+	return NULL;
+
+    if (tst->head[(int) key[0]] == NULL)
+	return NULL;
+
+    if (match_len)
+	*match_len = 0;
+
+    current_node = tst->head[(int) key[0]];
+    key_index = 1;
 
-  
-  if(prefix_len) *prefix_len = 0;
-  current_node = tst->head[(int)key[0]];
-  key_index = 1;
-  
-  while (current_node != NULL)
-    {
-      if(key[key_index] == current_node->value)
-	{
-	  if(current_node->value == 0) {
-	    if(prefix_len) *prefix_len = key_index;
-	    return current_node->middle;
-	  } else {
-	    current_node = current_node->middle;
-	    if(current_node && current_node->value == 0) {
-	      if(prefix_len) *prefix_len = key_index+1;
-	      longest_match = current_node->middle;
+    while (current_node != NULL) {
+	if (key[key_index] == current_node->value) {
+	    if (current_node->value == 0) {
+		if (match_len)
+		    *match_len = key_index;
+		return current_node->middle;
+	    } else {
+		current_node = current_node->middle;
+		key_index++;
+		continue;
 	    }
+	} else {
+	    if (current_node->value == 0) {
+		if (option & TST_LONGEST_MATCH) {
+		    longest_match = current_node->middle;
+		    longest_match_len = key_index;
+		}
 
-            key_index++;
-	    continue;
-	  }
-	}
-      else if( ((current_node->value == 0) && (key[key_index] < 64)) ||
-	       ((current_node->value != 0) && (key[key_index] <
-					       current_node->value)) )
-	{
-	  if(current_node->value == 0) {
-	    if(prefix_len) *prefix_len = key_index;
-	    longest_match = current_node->middle;
-	  }
-	  current_node = current_node->left;
-	  continue;
-	}
-      else
-	{
-	  if(current_node->value == 0) {
-	    if(prefix_len) *prefix_len = key_index;
-	    longest_match = current_node->middle;
-	  }
-	  current_node = current_node->right;
-	  continue;
+		if (key[key_index] < 64) {
+		    current_node = current_node->left;
+		    continue;
+		} else {
+		    current_node = current_node->right;
+		    continue;
+		}
+	    } else {
+		if (key[key_index] < current_node->value) {
+		    current_node = current_node->left;
+		    continue;
+		} else {
+		    current_node = current_node->right;
+		    continue;
+		}
+	    }
 	}
     }
-  
-  return longest_match;
+
+    if (match_len)
+	*match_len = longest_match_len;
+
+    return longest_match;
+
 }