http_parser.rb 0.5.1 → 0.6.0.beta.1

data/ext/ruby_http_parser/vendor/http-parser-java/src/impl/http_parser/lolevel/HTTPParser.java

@@ -1,8 +1,10 @@
 package http_parser.lolevel;
 
+import java.io.UnsupportedEncodingException;
 import java.nio.ByteBuffer;
 import http_parser.HTTPException;
 import http_parser.HTTPMethod;
+import http_parser.HTTPParserUrl;
 import http_parser.ParserType;
 import static http_parser.lolevel.HTTPParser.C.*;
 import static http_parser.lolevel.HTTPParser.State.*;
@@ -20,21 +22,22 @@ public class  HTTPParser {
 	int flags; // TODO
 
 	int nread;
-	int content_length;
+	long content_length;
+
+  int p_start; // updated each call to execute to indicate where the buffer was before we began calling it.
 
-	
   /** READ-ONLY **/
-  protected int http_major;
-  protected int http_minor;
-  protected int status_code;   /* responses only */
-  protected HTTPMethod method; /* requests only */
+  public int http_major;
+  public int http_minor;
+  public int status_code;   /* responses only */
+  public HTTPMethod method; /* requests only */
 
   /* true  = Upgrade header was present and the parser has exited because of that.
    * false = No upgrade header present.
    * Should be checked when http_parser_execute() returns in addition to
    * error checking.
    */
-  protected boolean upgrade; 
+  public boolean upgrade; 
 
   /** PUBLIC **/
 	// TODO : this is used in c to maintain application state.
@@ -50,10 +53,8 @@ public class  HTTPParser {
    */
   int header_field_mark = -1;
   int header_value_mark = -1;
-  int fragment_mark = -1;
-  int query_string_mark = -1;
-  int path_mark = -1;
   int url_mark = -1;
+  int body_mark = -1;
 	
   /**
    * Construct a Parser for ParserType.HTTP_BOTH, meaning it
@@ -77,7 +78,7 @@ public class  HTTPParser {
 				this.state = State.start_res;
 				break;
 			case HTTP_BOTH:
-				this.state = State.start_res_or_res;
+				this.state = State.start_req_or_res;
 				break;
 			default:
 				throw new HTTPException("can't happen, invalid ParserType enum");
@@ -89,27 +90,210 @@ public class  HTTPParser {
    */
 	static void p(Object o) {System.out.println(o);}
 
+  /** Comment from C version follows
+   *
+   * Our URL parser.
+   *
+   * This is designed to be shared by http_parser_execute() for URL validation,
+   * hence it has a state transition + byte-for-byte interface. In addition, it
+   * is meant to be embedded in http_parser_parse_url(), which does the dirty
+   * work of turning state transitions URL components for its API.
+   *
+   * This function should only be invoked with non-space characters. It is
+   * assumed that the caller cares about (and can detect) the transition between
+   * URL and non-URL states by looking for these.
+   */
+  public State parse_url_char(byte ch) {
+
+    int chi = ch & 0xff;            // utility, ch without signedness for table lookups.
+
+    if(SPACE == ch){
+      throw new HTTPException("space as url char");
+    }
+
+    switch(state) {
+      case req_spaces_before_url:
+        /* Proxied requests are followed by scheme of an absolute URI (alpha).
+        * All methods except CONNECT are followed by '/' or '*'.
+        */
+        if(SLASH == ch || STAR == ch){
+          return req_path;
+        }
+        if(isAtoZ(ch)){
+          return req_schema;
+        }
+        break;
+      case req_schema:
+        if(isAtoZ(ch)){
+          return req_schema;
+        }
+        if(COLON == ch){
+          return req_schema_slash;
+        }
+        break;
+      case req_schema_slash:
+        if(SLASH == ch){
+          return req_schema_slash_slash;
+        }
+        break;
+      case req_schema_slash_slash:
+        if(SLASH == ch){
+          return req_host_start;
+        }
+        break;
+      case req_host_start:
+        if (ch == (byte)'[') {
+          return req_host_v6_start;
+        }
+        if (isHostChar(ch)) {
+          return req_host;
+        }
+        break;
+
+      case req_host:
+        if (isHostChar(ch)) {
+          return req_host;
+        }
+
+      /* FALLTHROUGH */
+      case req_host_v6_end:
+        switch (ch) {
+          case ':':
+            return req_port_start;
+          case '/':
+            return req_path;
+          case '?':
+            return req_query_string_start;
+        }
+        break;
+
+      case req_host_v6:
+        if (ch == ']') {
+          return req_host_v6_end;
+        }
+
+      /* FALLTHROUGH */
+      case req_host_v6_start:
+        if (isHex(ch) || ch == ':') {
+          return req_host_v6;
+        }
+        break;
+
+      case req_port:
+        switch (ch) {
+          case '/':
+            return req_path;
+          case '?':
+            return req_query_string_start;
+        }
+
+      /* FALLTHROUGH */
+      case req_port_start:
+        if (isDigit(ch)) {
+          return req_port;
+        }
+        break;
+
+      case req_path:
+        if (isNormalUrlChar(chi)) {
+          return req_path;
+        }
+        switch (ch) {
+          case '?':
+            return req_query_string_start;
+          case '#':
+            return req_fragment_start;
+        }
+
+        break;
+
+      case req_query_string_start:
+      case req_query_string:
+        if (isNormalUrlChar(chi)) {
+          return req_query_string;
+        }
+
+        switch (ch) {
+          case '?':
+            /* allow extra '?' in query string */
+            return req_query_string;
+
+          case '#':
+            return req_fragment_start;
+        }
+
+        break;
+
+      case req_fragment_start:
+        if (isNormalUrlChar(chi)) {
+          return req_fragment;
+        }
+        switch (ch) {
+          case '?':
+            return req_fragment;
+
+          case '#':
+            return req_fragment_start;
+        }
+        break;
+
+      case req_fragment:
+        if (isNormalUrlChar(ch)) {
+          return req_fragment;
+        }
+
+        switch (ch) {
+          case '?':
+          case '#':
+            return req_fragment;
+        }
+
+        break;
+      default:
+        break;
+    }
+
+    /* We should never fall out of the switch above unless there's an error */
+    return dead;
+  }
 
   /** Execute the parser with the currently available data contained in
    * the buffer. The buffers position() and limit() need to be set
    * correctly (obviously) and a will be updated approriately when the
    * method returns to reflect the consumed data.
    */
-  public void execute(ParserSettings settings, ByteBuffer data) {
+  public int execute(ParserSettings settings, ByteBuffer data) {
 
     int p     = data.position();
-    int p_err = p; // this is used for pretty printing errors.
+    this.p_start = p; // this is used for pretty printing errors.
+                      // and returning the amount of processed bytes.
+    
 
     // In case the headers don't provide information about the content
     // length, `execute` needs to be called with an empty buffer to
     // indicate that all the data has been send be the client/server,
     // else there is no way of knowing the message is complete. 
     int len = (data.limit() - data.position());
-		if (0 == len) {
-			if (State.body_identity_eof == state) {
-				settings.call_on_message_complete(this);
-			}
-		}
+    if (0 == len) {
+//      			if (State.body_identity_eof == state) {
+//      				settings.call_on_message_complete(this);
+//      			}
+      switch (state) {
+        case body_identity_eof:
+          settings.call_on_message_complete(this);
+          return data.position() - this.p_start;
+
+        case dead:
+        case start_req_or_res:
+        case start_res:
+        case start_req:
+          return data.position() - this.p_start;
+
+        default:
+          // should we really consider this an error!?
+          throw new HTTPException("empty bytes! "+state); // error
+      }
+    }
 
 		
     // in case the _previous_ call to the parser only has data to get to
@@ -122,44 +306,52 @@ public class  HTTPParser {
       case header_value:
         header_value_mark = p;
         break;
-      case req_fragment:
-        fragment_mark = p;
-        url_mark = p;
-        break;
-      case req_query_string:
-        query_string_mark = p;
-        url_mark = p;
-        break;
       case req_path:
-        path_mark = p;
-
-      case req_host:
       case req_schema:
       case req_schema_slash:
       case req_schema_slash_slash:
+      case req_host_start:
+      case req_host_v6_start:
+      case req_host_v6:
+      case req_host_v6_end:
+      case req_host:
+      case req_port_start:
       case req_port:
       case req_query_string_start:
+      case req_query_string:
       case req_fragment_start:
+      case req_fragment:
         url_mark = p;
         break;
     }
+    boolean reexecute = false;
+    int pe = 0;
+    byte ch = 0;
+    int chi = 0;
+    byte c = -1;
+    int to_read = 0;
 
     // this is where the work gets done, traverse the available data...
-    while (data.position() != data.limit()) {
-
-            p = data.position();
-      int  pe = data.limit();
-
-      byte ch     = data.get();           // the current character to process.
-      byte c      = -1;                   // utility variably used for up- and downcasing etc.
-      int to_read =  0;                   // used to keep track of how much of body, etc. is left to read
-
-      if (parsing_header(state)) {
-        ++nread;
-        if (nread > HTTP_MAX_HEADER_SIZE) {
-          settings.call_on_error(this, "possible buffer overflow", data, p_err);
+    while (data.position() != data.limit() || reexecute) {
+//      p(state + ": r: " + reexecute + " :: " +p );
+
+      if(!reexecute){
+        p = data.position();
+        pe = data.limit();
+        ch     = data.get();           // the current character to process.
+        chi = ch & 0xff;            // utility, ch without signedness for table lookups.
+        c      = -1;                   // utility variably used for up- and downcasing etc.
+        to_read =  0;                   // used to keep track of how much of body, etc. is left to read
+
+        if (parsing_header(state)) {
+          ++nread;
+          if (nread > HTTP_MAX_HEADER_SIZE) {
+            return error(settings, "possible buffer overflow", data);
+          }
         }
       }
+      reexecute = false;
+//      p(state + " ::: " + ch + " : "  + (((CR == ch) || (LF == ch)) ? ch : ("'" + (char)ch + "'")) +": "+p );
 
       switch (state) {
          /*
@@ -167,29 +359,28 @@ public class  HTTPParser {
           * the parser will error out if it reads another message
           */
         case dead:
-          settings.call_on_error(this, "Connection already closed", data, p_err);
+          if (CR == ch || LF == ch){
+            break;
+          }
+          return error(settings, "Connection already closed", data);
 
 
 
-        case start_res_or_res:
+        case start_req_or_res:
           if (CR == ch || LF == ch){
             break;
           }
           flags = 0;
           content_length = -1;
 
-          settings.call_on_message_begin(this);
-          
-          if (H == ch) { 
+          if (H == ch) {
             state = State.res_or_resp_H;
+            settings.call_on_message_begin(this);
           } else {
-            type   = ParserType.HTTP_REQUEST;  
-            method = start_req_method_assign(ch);     
-            if (null == method) {
-              settings.call_on_error(this, "invalid method", data, p_err);
-            }
-            index  = 1;
-            state  = State.req_method;
+            type   = ParserType.HTTP_REQUEST;
+            state  = State.start_req;
+            index = 1;
+            reexecute = true;
           }
           break;
 
@@ -201,7 +392,7 @@ public class  HTTPParser {
             state = State.res_HT;
           } else {
             if (E != ch) {
-              settings.call_on_error(this, "not E", data, p_err);
+              return error(settings, "not E", data);
             }
             type   = ParserType.HTTP_REQUEST;
             method = HTTPMethod.HTTP_HEAD;
@@ -216,8 +407,6 @@ public class  HTTPParser {
           flags = 0;
           content_length = -1;
 
-          settings.call_on_message_begin(this);
-          
           switch(ch) {
             case H:
               state = State.res_H;
@@ -226,33 +415,35 @@ public class  HTTPParser {
             case LF:
               break;
             default:
-              settings.call_on_error(this, "Not H or CR/LF", data, p_err);
+              return error(settings, "Not H or CR/LF", data);
           }
+
+          settings.call_on_message_begin(this);
           break;
 
 
 
         case res_H:
           if (strict && T != ch) {
-            settings.call_on_error(this, "Not T", data, p_err);
+            return error(settings, "Not T", data);
           }
           state = State.res_HT;
           break;
         case res_HT:
           if (strict && T != ch) {
-            settings.call_on_error(this, "Not T2", data, p_err);
+return error(settings, "Not T2", data);
           }
           state = State.res_HTT;
           break;
         case res_HTT:
           if (strict && P != ch) {
-            settings.call_on_error(this, "Not P", data, p_err);
+return error(settings, "Not P", data);
           }
           state = State.res_HTTP;
           break;
         case res_HTTP:
           if (strict && SLASH != ch) {
-            settings.call_on_error(this, "Not '/'", data, p_err);
+return error(settings, "Not '/'", data);
           }
           state = State.res_first_http_major;
           break;
@@ -261,7 +452,7 @@ public class  HTTPParser {
 
         case res_first_http_major:
           if (!isDigit(ch)) {
-            settings.call_on_error(this, "Not a digit", data, p_err);
+return error(settings, "Not a digit", data);
           }
           http_major = (int) ch - 0x30;
           state = State.res_http_major;
@@ -270,24 +461,24 @@ public class  HTTPParser {
         /* major HTTP version or dot */
         case res_http_major:
           if (DOT == ch) {
-            state = State.res_http_minor;
+            state = State.res_first_http_minor;
             break;
           }
           if (!isDigit(ch)) {
-            settings.call_on_error(this, "Not a digit", data, p_err);
+return error(settings, "Not a digit", data);
           }
           http_major *= 10;
           http_major += (ch - 0x30);
 
           if (http_major > 999) {
-            settings.call_on_error(this, "invalid http major version: "+http_major, data, p_err);
+return error(settings, "invalid http major version: ", data);
           }
           break;
           
         /* first digit of minor HTTP version */
         case res_first_http_minor:
           if (!isDigit(ch)) {
-            settings.call_on_error(this, "Not a digit", data, p_err);
+return error(settings, "Not a digit", data);
           }
           http_minor = (int)ch - 0x30;
           state = State.res_http_minor;
@@ -300,13 +491,12 @@ public class  HTTPParser {
             break;
           }
           if (!isDigit(ch)) {
-            settings.call_on_error(this, "Not a digit", data, p_err);
+return error(settings, "Not a digit", data);
           }
           http_minor *= 10;
           http_minor += (ch - 0x30);
-
           if (http_minor > 999) {
-            settings.call_on_error(this, "invalid http minor version: "+http_minor, data, p_err);
+return error(settings, "invalid http minor version: ", data);
           }
           break;
 
@@ -317,7 +507,7 @@ public class  HTTPParser {
             if (SPACE == ch) {
               break;
             }
-            settings.call_on_error(this, "Not a digit (status code)", data, p_err);
+return error(settings, "Not a digit (status code)", data);
           }
           status_code = (int)ch - 0x30;
           state = State.res_status_code;
@@ -336,14 +526,14 @@ public class  HTTPParser {
                 state = State.header_field_start;
                 break;
               default:
-                settings.call_on_error(this, "not a valid status code", data, p_err);
+return error(settings, "not a valid status code", data);
             }
             break;
           }
           status_code *= 10;
           status_code += (int)ch - 0x30;
           if (status_code > 999) {
-            settings.call_on_error(this, "ridiculous status code:"+status_code, data, p_err);
+return error(settings, "ridiculous status code:", data);
           }
           break;
 
@@ -364,7 +554,7 @@ public class  HTTPParser {
 
         case res_line_almost_done:
           if (strict && LF != ch) {
-            settings.call_on_error(this, "not LF", data, p_err);
+return error(settings, "not LF", data);
           }
           state = State.header_field_start;
           break;
@@ -372,25 +562,31 @@ public class  HTTPParser {
 
 
         case start_req:
-          if (CR==ch || LF == LF) {
+          if (CR==ch || LF == ch) {
             break;
           }
           flags = 0;
           content_length = -1;
-          settings.call_on_message_begin(this);
+
+          if(!isAtoZ(ch)){
+            return error(settings, "invalid method", data);
+          }
+
           method = start_req_method_assign(ch);
           if (null == method) {
-            settings.call_on_error(this, "invalid method", data, p_err);
+            return error(settings, "invalid method", data);
           }
           index  = 1;
           state  = State.req_method;
+
+          settings.call_on_message_begin(this);
           break;
         
 
 
         case req_method:
           if (0 == ch) {
-            settings.call_on_error(this, "NULL in method", data, p_err);
+            return error(settings, "NULL in method", data);
           }
           
           byte [] arr = method.bytes;
@@ -410,17 +606,33 @@ public class  HTTPParser {
                 method = HTTPMethod.HTTP_MOVE;
               } else if (1 == index && E == ch) {
                 method = HTTPMethod.HTTP_MERGE;
+              } else if (1 == index && DASH == ch) { /* M-SEARCH */
+                method = HTTPMethod.HTTP_MSEARCH;
               } else if (2 == index && A == ch) {
                 method = HTTPMethod.HTTP_MKACTIVITY;
               }
-          } else if (1 == index && HTTPMethod.HTTP_POST     == method && R == ch) {
-            method = HTTPMethod.HTTP_PROPFIND;
-          } else if (1 == index && HTTPMethod.HTTP_POST     == method && U == ch) {
-            method = HTTPMethod.HTTP_PUT;
-          } else if (4 == index && HTTPMethod.HTTP_PROPFIND == method && P == ch) {
+          } else if (1 == index && HTTPMethod.HTTP_POST     == method) {
+            if(R == ch) {
+              method = HTTPMethod.HTTP_PROPFIND; /* or HTTP_PROPPATCH */
+            }else if(U == ch){
+              method = HTTPMethod.HTTP_PUT; /* or HTTP_PURGE */
+            }else if(A == ch){
+              method = HTTPMethod.HTTP_PATCH;
+            }
+          } else if (2 == index) {
+            if(HTTPMethod.HTTP_PUT == method) {
+              if(R == ch){
+                method = HTTPMethod.HTTP_PURGE; 
+              }
+            }else if(HTTPMethod.HTTP_UNLOCK == method){
+              if(S == ch){
+                method = HTTPMethod.HTTP_UNSUBSCRIBE;
+              }
+            }
+          }else if(4 == index && HTTPMethod.HTTP_PROPFIND == method && P == ch){
             method = HTTPMethod.HTTP_PROPPATCH;
           } else {
-            settings.call_on_error(this, "Invalid HTTP method", data, p_err);
+            return error(settings, "Invalid HTTP method", data);
           }
 
           ++index;
@@ -433,307 +645,68 @@ public class  HTTPParser {
           if (SPACE == ch) {
             break;
           }
-          if (SLASH == ch) {
-            url_mark  = p;
-            path_mark = p;
-            state = State.req_path;
-            break;
-          }
-          if (isAtoZ(ch)) {
-            url_mark = p;
-            state = State.req_schema;
-            break;
-          }
-          settings.call_on_error(this, "Invalid something", data, p_err);
-
-        case req_schema:
-          if (isAtoZ(ch)){
-            break;
-          }
-          if (COLON == ch) {
-            state = State.req_schema_slash;
-            break;
-          } else if (DOT == ch) {
-            state = State.req_host;
-            break;
+          url_mark  = p;
+          if(HTTPMethod.HTTP_CONNECT == method){
+            state = req_host_start;
           }
-          settings.call_on_error(this, "invalid char in schema: "+ch, data, p_err);
 
-        case req_schema_slash:
-          if (strict && SLASH != ch) {
-            settings.call_on_error(this, "invalid char in schema, not /", data, p_err);
+          state = parse_url_char(ch);
+          if(state == dead){
+            return error(settings, "Invalid something", data);
           }
-          state = State.req_schema_slash_slash;
           break;
 
-        case req_schema_slash_slash:
-          if (strict && SLASH != ch) {
-            settings.call_on_error(this, "invalid char in schema, not /", data, p_err);
-          }
-          state = State.req_host;
-          break;
-        
-        case req_host:
-          if (isAtoZ(ch)) {
-            break;
-          }	
-          if (isDigit(ch) || DOT == ch || DASH == ch) break;
-          switch (ch) {
-            case COLON:
-              state = State.req_port;
-              break;
-            case SLASH:
-              path_mark = p;
-              break;
-            case SPACE:
-              /* The request line looks like:
-               *   "GET http://foo.bar.com HTTP/1.1"
-               * That is, there is no path.
-               */
-              settings.call_on_url(this, data, url_mark, p-url_mark);
-              url_mark = -1;
-              state = State.req_http_start;
-              break;
-            default:
-              settings.call_on_error(this, "host error in method line", data, p_err);
-          }
-          break;
 
-        case req_port:
-          if (isDigit(ch)) break;
-          switch (ch) {
-            case SLASH:
-              path_mark = p; 
-              state = State.req_path;
-              break;
-            case SPACE:
-              /* The request line looks like:
-               *   "GET http://foo.bar.com:1234 HTTP/1.1"
-               * That is, there is no path.
-               */
-              settings.call_on_url(this,data,url_mark,p-url_mark);
-              url_mark = -1;
-              state = State.req_http_start;
-              break;
-            default:
-              settings.call_on_error(this, "invalid port", data, p_err);
-          }
-          break;
-      
-        case req_path:
-          if (normal_url_char[ch]) break;
+        case req_schema:
+        case req_schema_slash:
+        case req_schema_slash_slash:
+        case req_host_start:
+        case req_host_v6_start:
+        case req_host_v6:
+        case req_port_start:
           switch (ch) {
+            /* No whitespace allowed here */
             case SPACE:
-              settings.call_on_url(this,data,url_mark, p-url_mark);
-              url_mark = -1;
-
-              settings.call_on_path(this,data,path_mark, p-path_mark);
-              path_mark = -1;
-              
-              state = State.req_http_start;
-              break;
-
-            case CR:
-              settings.call_on_url(this,data,url_mark, p-url_mark);
-              url_mark = -1;
-              
-              settings.call_on_path(this,data,path_mark, p-path_mark);
-              path_mark = -1;
-              
-              http_minor = 9;
-              state = State.res_line_almost_done;
-              break;
-
-            case LF:
-              settings.call_on_url(this,data,url_mark, p-url_mark);
-              url_mark = -1;
-              
-              settings.call_on_path(this,data,path_mark, p-path_mark);
-              path_mark = -1;
-              
-              http_minor = 9;
-              state = State.header_field_start;
-              break;
-
-            case QMARK:
-              settings.call_on_path(this,data,path_mark, p-path_mark);
-              path_mark = -1;
-              
-              state = State.req_query_string_start;
-              break;
-            
-            case HASH:
-              settings.call_on_path(this,data,path_mark, p-path_mark);
-              path_mark = -1;
-              
-              state = State.req_fragment_start;
-              break;
-            
-            default:
-              settings.call_on_error(this, "unexpected char in path", data, p_err);
-          }
-          break;
-      
-        case req_query_string_start:
-          if (normal_url_char[ch]) {
-            query_string_mark = p;
-            state = State.req_query_string;
-            break;
-          }
-
-          switch (ch) {
-            case QMARK: break;
-            case SPACE: 
-              settings.call_on_url(this, data, url_mark, p-url_mark);
-              url_mark = -1;
-              state = State.req_http_start;
-              break;
-            case CR:
-              settings.call_on_url(this,data,url_mark, p-url_mark);
-              url_mark = -1; 
-              http_minor = 9;
-              state = State.res_line_almost_done;
-              break;
-            case LF:
-              settings.call_on_url(this,data,url_mark, p-url_mark);
-              url_mark = -1;
-              http_minor = 9;
-              state = State.header_field_start;
-              break;
-            case HASH:
-              state = State.req_fragment_start;
-              break;
-            default:
-              settings.call_on_error(this, "unexpected char in path", data, p_err);
-          }
-          break;
-        
-        case req_query_string:
-          if (normal_url_char[ch]) {
-            break;
-          }
-
-          switch (ch) {
-            case QMARK: break; // allow extra '?' in query string
-            case SPACE: 
-              settings.call_on_url(this, data, url_mark, p-url_mark);
-              url_mark = -1;
-
-              settings.call_on_query_string(this, data, query_string_mark, p-query_string_mark);
-              query_string_mark = -1;
-
-              state = State.req_http_start;
-              break;
-            case CR:
-              settings.call_on_url(this,data,url_mark, p-url_mark);
-              url_mark = -1; 
-
-              settings.call_on_query_string(this, data, query_string_mark, p-query_string_mark);
-              query_string_mark = -1;
-              
-              http_minor = 9;
-              state = State.res_line_almost_done;
-              break;
-            case LF:
-              settings.call_on_url(this,data,url_mark, p-url_mark);
-              url_mark = -1;
-
-              settings.call_on_query_string(this, data, query_string_mark, p-query_string_mark);
-              query_string_mark = -1;
-              http_minor = 9;
-
-              state = State.header_field_start;
-              break;
-            case HASH:
-              settings.call_on_query_string(this, data, query_string_mark, p-query_string_mark);
-              query_string_mark = -1;
-              
-              state = State.req_fragment_start;
-              break;
-            default:
-              settings.call_on_error(this, "unexpected char in path", data, p_err);
-          }
-          break;
-
-        case req_fragment_start:
-          if (normal_url_char[ch]) {
-            fragment_mark = p;
-            state = State.req_fragment;
-            break;
-          }
-
-          switch (ch) {
-            case SPACE: 
-              settings.call_on_url(this, data, url_mark, p-url_mark);
-              url_mark = -1;
-     
-              state = State.req_http_start;
-              break;
             case CR:
-              settings.call_on_url(this,data,url_mark, p-url_mark);
-              url_mark = -1; 
-
-              http_minor = 9;
-              state = State.res_line_almost_done;
-              break;
             case LF:
-              settings.call_on_url(this,data,url_mark, p-url_mark);
-              url_mark = -1;
-              
-              http_minor = 9;
-              state = State.header_field_start;
-              break;
-            case QMARK:
-              fragment_mark = p;
-              state = State.req_fragment;
-              break;
-            case HASH:
-              break;
+              return error(settings, "unexpected char in path", data);
             default:
-              settings.call_on_error(this, "unexpected char in path", data, p_err);
+              state = parse_url_char(ch);
+              if(dead == state){
+                return error(settings, "unexpected char in path", data);
+              }
           }
           break;
 
+        case req_host:
+        case req_host_v6_end:
+        case req_port:
+        case req_path:
+        case req_query_string_start:
+        case req_query_string:
+        case req_fragment_start:
         case req_fragment:
-          if (normal_url_char[ch]) {
-            break;
-          }
-
           switch (ch) {
             case SPACE: 
               settings.call_on_url(this, data, url_mark, p-url_mark);
+              settings.call_on_path(this, data, url_mark, p - url_mark);
               url_mark = -1;
-          
-              settings.call_on_fragment(this, data, fragment_mark, p-fragment_mark);
-              fragment_mark = -1;
-              
               state = State.req_http_start;
               break;
             case CR:
-              settings.call_on_url(this,data,url_mark, p-url_mark);
-              url_mark = -1; 
-              
-              settings.call_on_fragment(this, data, query_string_mark, p-query_string_mark);
-              fragment_mark = -1;
-              
-              http_minor = 9;
-              state = State.res_line_almost_done;
-              break;
             case LF:
-              settings.call_on_url(this,data,url_mark, p-url_mark);
-              url_mark = -1;
-              
-              settings.call_on_fragment(this, data, query_string_mark, p-query_string_mark);
-              fragment_mark = -1;
-              
+              http_major = 0;
               http_minor = 9;
-              state = State.header_field_start;
-              break;
-            case QMARK:
-            case HASH:
+              state = (CR == ch) ? req_line_almost_done : header_field_start;
+              settings.call_on_url(this, data, url_mark, p-url_mark); //TODO check params!!!
+              settings.call_on_path(this, data, url_mark, p-url_mark);
+              url_mark = -1;
               break;
             default:
-              settings.call_on_error(this, "unexpected char in path", data, p_err);
+              state = parse_url_char(ch);
+              if(dead == state){
+                return error(settings, "unexpected char in path", data);
+              }
           }
           break;
         /******************* URL *******************/
@@ -749,34 +722,34 @@ public class  HTTPParser {
             case SPACE:
               break;
             default:
-              settings.call_on_error(this, "error in req_http_H", data, p_err);
+              return error(settings, "error in req_http_H", data);
           }
           break;
 
         case req_http_H:
           if (strict && T != ch) {
-            settings.call_on_error(this, "unexpected char", data, p_err);
+            return error(settings, "unexpected char", data);
           }
           state = State.req_http_HT;
           break;
 
         case req_http_HT:
           if (strict && T != ch) {
-            settings.call_on_error(this, "unexpected char", data, p_err);
+            return error(settings, "unexpected char", data);
           }
           state = State.req_http_HTT;
           break;
 
         case req_http_HTT:
           if (strict && P != ch) {
-            settings.call_on_error(this, "unexpected char", data, p_err);
+            return error(settings, "unexpected char", data);
           }
           state = State.req_http_HTTP;
           break;
 
         case req_http_HTTP:
           if (strict && SLASH != ch) {
-            settings.call_on_error(this, "unexpected char", data, p_err);
+            return error(settings, "unexpected char", data);
           }
           state = req_first_http_major;
           break;
@@ -784,7 +757,7 @@ public class  HTTPParser {
         /* first digit of major HTTP version */
         case req_first_http_major:
           if (!isDigit(ch)) {
-            settings.call_on_error(this, "non digit in http major", data, p_err);
+return error(settings, "non digit in http major", data);
           }
           http_major = (int)ch - 0x30;
           state = State.req_http_major;
@@ -798,21 +771,21 @@ public class  HTTPParser {
           }
 
           if (!isDigit(ch)) {
-            settings.call_on_error(this, "non digit in http major", data, p_err);
+return error(settings, "non digit in http major", data);
           }
 
           http_major *= 10;
           http_major += (int)ch - 0x30;
 
           if (http_major > 999) {
-            settings.call_on_error(this, "ridiculous http major", data, p_err);
+return error(settings, "ridiculous http major", data);
           };
           break;
         
         /* first digit of minor HTTP version */
         case req_first_http_minor:
           if (!isDigit(ch)) {
-            settings.call_on_error(this, "non digit in http minor", data, p_err);
+return error(settings, "non digit in http minor", data);
           }
           http_minor = (int)ch - 0x30;
           state = State.req_http_minor;
@@ -832,7 +805,7 @@ public class  HTTPParser {
           /* XXX allow spaces after digit? */
 
           if (!isDigit(ch)) {
-            settings.call_on_error(this, "non digit in http minor", data, p_err);
+return error(settings, "non digit in http minor", data);
           }
 
           http_minor *= 10;
@@ -840,7 +813,7 @@ public class  HTTPParser {
 
          
           if (http_minor > 999) {
-            settings.call_on_error(this, "ridiculous http minor", data, p_err);
+return error(settings, "ridiculous http minor", data);
           };
    
           break;
@@ -849,9 +822,9 @@ public class  HTTPParser {
         case req_line_almost_done:
         {
           if (ch != LF) {
-            settings.call_on_error(this, "missing LF after request line", data, p_err);
+return error(settings, "missing LF after request line", data);
           }
-          state = State.header_field_start;
+          state = header_field_start;
           break;
         }
 
@@ -863,7 +836,7 @@ public class  HTTPParser {
         case header_field_start:
         {
           if (ch == CR) {
-            state = State.headers_almost_done;
+            state = headers_almost_done;
             break;
           }
 
@@ -871,17 +844,15 @@ public class  HTTPParser {
             /* they might be just sending \n instead of \r\n so this would be
              * the second \n to denote the end of headers*/
             state = State.headers_almost_done;
-            if (!headers_almost_done(ch, settings)) {
-              settings.call_on_error(this, "header not properly completed", data, p_err);
-            }
+            reexecute = true;
             break;
           }
 
-          c = upper(ch);
+          c = token(ch);
 
-          if (c < A || Z < c) {
-            settings.call_on_error(this, "invalid char in header", data, p_err);
-          };
+          if (0 == c) {
+            return error(settings, "invalid char in header:", data);
+          }
 
           header_field_mark = p;
 
@@ -916,7 +887,7 @@ public class  HTTPParser {
 
         case header_field:
         {
-          c = (byte) acceptable_header[ch];
+          c = token(ch);
           if (0 != c) {  
             switch (header_state) {
               case general:
@@ -1010,7 +981,7 @@ public class  HTTPParser {
                 break;
 
               default:
-                settings.call_on_error(this, "Unknown Header State", data, p_err);
+return error(settings, "Unknown Header State", data);
             } // switch: header_state
             break;
           } // 0 != c
@@ -1039,44 +1010,41 @@ public class  HTTPParser {
             break;
           }
 
-          settings.call_on_error(this, "invalid header field", data, p_err);
+return error(settings, "invalid header field", data);
         }
 
 
 
         case header_value_start:
         {
-          if (SPACE == ch) break;
+          if ((SPACE == ch) || (TAB  == ch)) break;
 
           header_value_mark = p;
 
           state = State.header_value;
           index = 0;
 
-          c = (byte)acceptable_header[ch];
-
-          if (c == 0) {
-            if (CR == ch) {
-              settings.call_on_header_value(this, data, header_value_mark, p-header_value_mark);
-              header_value_mark = -1;
-
-              header_state = HState.general;
-              state = State.header_almost_done;
-              break;
-            }
 
-            if (LF == ch) {
-              settings.call_on_header_value(this, data, header_value_mark, p-header_value_mark);
-              header_value_mark = -1;
-              
-              state = State.header_field_start;
-              break;
-            }
+          if (CR == ch) {
+            settings.call_on_header_value(this, data, header_value_mark, p-header_value_mark);
+            header_value_mark = -1;
 
             header_state = HState.general;
+            state = State.header_almost_done;
+            break;
+          }
+
+          if (LF == ch) {
+            settings.call_on_header_value(this, data, header_value_mark, p-header_value_mark);
+            header_value_mark = -1;
+            
+            state = State.header_field_start;
             break;
           }
 
+
+          c = upper(ch);
+
           switch (header_state) {
             case upgrade:
               flags |= F_UPGRADE;
@@ -1094,7 +1062,7 @@ public class  HTTPParser {
 
             case content_length:
               if (!isDigit(ch)) {
-                settings.call_on_error(this, "Content-Length not numeric", data, p_err);
+return error(settings, "Content-Length not numeric", data);
               } 
               content_length = (int)ch - 0x30;
               break;
@@ -1122,47 +1090,50 @@ public class  HTTPParser {
 
         case header_value:
         {
-          c = (byte)acceptable_header[ch];
 
-          if (c == 0) {
-            if (CR == ch) {
-              settings.call_on_header_value(this, data, header_value_mark, p-header_value_mark);
-              header_value_mark = -1;
+          if (CR == ch) {
+            settings.call_on_header_value(this, data, header_value_mark, p-header_value_mark);
+            header_value_mark = -1;
 
-              state = State.header_almost_done;
-              break;
-            }
+            state = State.header_almost_done;
+            break;
+          }
 
-            if (LF == ch) {
-              settings.call_on_header_value(this, data, header_value_mark, p-header_value_mark);
-              header_value_mark = -1;
-              
-              if (!header_almost_done(ch)) {
-                settings.call_on_error(this,"incorrect header ending, expection LF", data, p_err);
-              }
-              break;
-            }
+          if (LF == ch) {
+            settings.call_on_header_value(this, data, header_value_mark, p-header_value_mark);
+            header_value_mark = -1;
+            state = header_almost_done;
+            reexecute = true;
             break;
           }
 
+          c = upper(ch);
           switch (header_state) {
             case general:
               break;
 
             case connection:
             case transfer_encoding:
-              settings.call_on_error(this, "Shouldn't be here", data, p_err);
+return error(settings, "Shouldn't be here", data);
 
             case content_length:
               if (SPACE == ch) {
                 break;
               }
               if (!isDigit(ch)) {
-                settings.call_on_error(this, "Content-Length not numeric", data, p_err);
+return error(settings, "Content-Length not numeric", data);
               } 
 
-              content_length *= 10;
-              content_length += (int)ch - 0x30;
+              long t = content_length; 
+              t *= 10;
+              t += (long)ch - 0x30;
+
+              /* Overflow? */
+              // t will wrap and become negative ...
+              if (t < content_length) { 
+                return error(settings, "Invalid content length", data);
+              }
+              content_length = t;
               break;
 
             /* Transfer-Encoding: chunked */
@@ -1213,16 +1184,121 @@ public class  HTTPParser {
 
         case header_almost_done:
           if (!header_almost_done(ch)) {
-            settings.call_on_error(this,"incorrect header ending, expection LF", data, p_err);
+            return error(settings, "incorrect header ending, expecting LF", data);
           }
           break;
 
-        case headers_almost_done:
-          if (!headers_almost_done(ch, settings)) {
-            settings.call_on_error(this, "header not properly completed", data, p_err);
+        case header_value_lws:
+          if (SPACE == ch || TAB == ch ){
+            state = header_value_start;
+          } else {
+            state = header_field_start;
+            reexecute = true;
           }
           break;
 
+        case headers_almost_done:
+          if (LF != ch) {
+            return error(settings, "header not properly completed", data);
+          }
+          if (0 != (flags & F_TRAILING)) {
+            /* End of a chunked request */
+            state = new_message();
+            settings.call_on_headers_complete(this);
+            settings.call_on_message_complete(this);
+            break;
+          }
+
+          state = headers_done;
+
+          if (0 != (flags & F_UPGRADE) || HTTPMethod.HTTP_CONNECT == method) {
+            upgrade = true;
+          }
+
+          /* Here we call the headers_complete callback. This is somewhat
+          * different than other callbacks because if the user returns 1, we
+          * will interpret that as saying that this message has no body. This
+          * is needed for the annoying case of receiving a response to a HEAD
+          * request.
+          */
+
+          /* (responses to HEAD request contain a CONTENT-LENGTH header
+          * but no content)
+          *
+          * Consider what to do here: I don't like the idea of the callback
+          * interface having a different contract in the case of HEAD
+          * responses. The alternatives would be either to:
+          *
+          * a.) require the header_complete callback to implement a different
+          * interface or
+          *
+          * b.) provide an overridden execute(bla, bla, boolean
+          * parsingHeader) implementation ...
+          */
+
+//          /*TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO */
+//          if (null != settings.on_headers_complete) {
+//            settings.call_on_headers_complete(this);
+//            //return;
+//          }
+
+        if (null != settings.on_headers_complete) {
+          switch (settings.on_headers_complete.cb(this)) {
+            case 0:
+              break;
+
+            case 1:
+              flags |= F_SKIPBODY;
+              break;
+
+            default:
+              return error(settings, "HPE_CB_headers_complete", data); /* Error */
+          }
+        }
+        reexecute = true;
+        break;
+
+        case headers_done:
+          if (strict && (LF != ch)) {
+            return error(settings, "STRICT CHECK", data); //TODO correct error msg
+          }
+
+          nread = 0;
+
+          // Exit, the rest of the connect is in a different protocol.
+          if (upgrade) {
+            state = new_message();
+            settings.call_on_message_complete(this);
+            return data.position()-this.p_start;
+          }
+
+          if (0 != (flags & F_SKIPBODY)) {
+            state = new_message();
+            settings.call_on_message_complete(this);
+          } else if (0 != (flags & F_CHUNKED)) {
+            /* chunked encoding - ignore Content-Length header */
+            state = State.chunk_size_start;
+          } else {
+            if (content_length == 0) {
+              /* Content-Length header given but zero: Content-Length: 0\r\n */
+              state = new_message();
+              settings.call_on_message_complete(this);
+            } else if (content_length != -1) {
+              /* Content-Length header given and non-zero */
+              state = State.body_identity;
+            } else {
+              if (type == ParserType.HTTP_REQUEST || !http_message_needs_eof()) {
+                /* Assume content-length 0 - read the next */
+                state = new_message();
+                settings.call_on_message_complete(this);
+              } else {
+                /* Read body until EOF */
+                state = State.body_identity_eof;
+              }
+            }
+          }
+
+          break;
         /******************* Header *******************/
 
 
@@ -1230,15 +1306,18 @@ public class  HTTPParser {
 
         /******************* Body *******************/
         case body_identity:
-          to_read = min(pe - p, content_length); //TODO change to use buffer? 
+          to_read = min(pe - p, content_length); //TODO change to use buffer?
+          body_mark = p;
 
           if (to_read > 0) {
-            settings.call_on_body(this, data, p, to_read); 
+            settings.call_on_body(this, data, p, to_read);
             data.position(p+to_read);
             content_length -= to_read;
+
             if (content_length == 0) {
-              settings.call_on_message_complete(this);
-              state = new_message(); 
+              state = message_done;
+              p += to_read;
+              reexecute = true;
             }
           }
           break;
@@ -1248,23 +1327,32 @@ public class  HTTPParser {
         case body_identity_eof:
           to_read = pe - p;  // TODO change to use buffer ?
           if (to_read > 0) {
-            settings.call_on_body(this, data, p, to_read); 
+            settings.call_on_body(this, data, p, to_read);
             data.position(p+to_read);
           }
           break;
+        
+        case message_done:
+          state = new_message();
+          settings.call_on_message_complete(this);
+          break;
         /******************* Body *******************/
 
 
 
         /******************* Chunk *******************/
         case chunk_size_start:
+          if (1 != this.nread) {
+return error(settings, "nread != 1 (chunking)", data);
+          
+          }
           if (0 == (flags & F_CHUNKED)) {
-            settings.call_on_error(this, "not chunked", data, p_err);
+return error(settings, "not chunked", data);
           }
 
-          c = UNHEX[ch];
+          c = UNHEX[chi];
           if (c == -1) {
-            settings.call_on_error(this, "invalid hex char in chunk content length", data, p_err);
+return error(settings, "invalid hex char in chunk content length", data);
           }
           content_length = c;
           state = State.chunk_size;
@@ -1274,7 +1362,7 @@ public class  HTTPParser {
 
         case chunk_size:
           if (0 == (flags & F_CHUNKED)) {
-            settings.call_on_error(this, "not chunked", data, p_err);
+            return error(settings, "not chunked", data);
           }
 
           if (CR == ch) {
@@ -1282,25 +1370,30 @@ public class  HTTPParser {
             break;
           }
 
-          c = UNHEX[ch];
+          c = UNHEX[chi];
 
           if (c == -1) {
             if (SEMI == ch || SPACE == ch) {
               state = State.chunk_parameters;
               break;
             }
-            settings.call_on_error(this, "invalid hex char in chunk content length", data, p_err);
+            return error(settings, "invalid hex char in chunk content length", data);
           }
-
-          content_length *= 16;
-          content_length += c;
+          long t = content_length;
+          
+          t *= 16;
+          t += c;
+          if(t < content_length){
+            return error(settings, "invalid content length", data);
+          }
+          content_length = t;
           break;
 
 
 
         case chunk_parameters:
           if (0 == (flags & F_CHUNKED)) {
-            settings.call_on_error(this, "not chunked", data, p_err);
+return error(settings, "not chunked", data);
           }
           /* just ignore this shit. TODO check for overflow */
           if (CR == ch) {
@@ -1313,12 +1406,14 @@ public class  HTTPParser {
 
         case chunk_size_almost_done:
           if (0 == (flags & F_CHUNKED)) {
-            settings.call_on_error(this, "not chunked", data, p_err);
+return error(settings, "not chunked", data);
           }
           if (strict && LF != ch) {
-            settings.call_on_error(this, "expected LF at end of chunk size", data, p_err);
+return error(settings, "expected LF at end of chunk size", data);
           }
 
+          this.nread = 0;
+
           if (0 == content_length) {
             flags |= F_TRAILING;
             state = State.header_field_start;
@@ -1330,9 +1425,9 @@ public class  HTTPParser {
 
 
         case chunk_data:
-        {
+          //TODO Apply changes from C version for s_chunk_data
           if (0 == (flags & F_CHUNKED)) {
-            settings.call_on_error(this, "not chunked", data, p_err);
+            return error(settings, "not chunked", data);
           }
 
           to_read = min(pe-p, content_length);
@@ -1347,28 +1442,29 @@ public class  HTTPParser {
 
           content_length -= to_read;
           break;
-        }
 
 
 
         case chunk_data_almost_done:
           if (0 == (flags & F_CHUNKED)) {
-            settings.call_on_error(this, "not chunked", data, p_err);
+return error(settings, "not chunked", data);
           }
           if (strict && CR != ch) {
-            settings.call_on_error(this, "chunk data terminated incorrectly, expected CR", data, p_err);
+return error(settings, "chunk data terminated incorrectly, expected CR", data);
           }
           state = State.chunk_data_done;
+          //TODO CALLBACK_DATA(body)
+          // settings.call_on_body(this, data,p,?);
           break;
 
 
 
         case chunk_data_done:
           if (0 == (flags & F_CHUNKED)) {
-            settings.call_on_error(this, "not chunked", data, p_err);
+return error(settings, "not chunked", data);
           }
           if (strict && LF != ch) {
-            settings.call_on_error(this, "chunk data terminated incorrectly, expected LF", data, p_err);
+return error(settings, "chunk data terminated incorrectly, expected LF", data);
           }
           state = State.chunk_size_start;
           break;
@@ -1377,7 +1473,7 @@ public class  HTTPParser {
         
         
         default:
-          settings.call_on_error(this, "unhandled state", data, p_err);
+return error(settings, "unhandled state", data);
           
       } // switch
     } // while
@@ -1390,13 +1486,36 @@ public class  HTTPParser {
     
 	  settings.call_on_header_field(this, data, header_field_mark, p-header_field_mark);
     settings.call_on_header_value(this, data, header_value_mark, p-header_value_mark);
-    settings.call_on_fragment    (this, data, fragment_mark,     p-fragment_mark);
-    settings.call_on_query_string(this, data, query_string_mark, p-query_string_mark);
-    settings.call_on_path        (this, data, path_mark,         p-path_mark);
     settings.call_on_url         (this, data, url_mark,          p-url_mark);
-	
+    settings.call_on_path        (this, data, url_mark,          p-url_mark);
+    
+    return data.position()-this.p_start;	
   } // execute
 
+  int error (ParserSettings settings, String mes, ByteBuffer data) {
+    settings.call_on_error(this, mes, data, this.p_start);
+    this.state = State.dead;
+    return data.position()-this.p_start;
+  }
+
+  public boolean http_message_needs_eof() {
+    if(type == ParserType.HTTP_REQUEST){
+      return false;
+    }
+    /* See RFC 2616 section 4.4 */
+    if ((status_code / 100 == 1) || /* 1xx e.g. Continue */
+        (status_code == 204) ||     /* No Content */
+        (status_code == 304) ||     /* Not Modified */
+        (flags & F_SKIPBODY) != 0) {     /* response to a HEAD request */
+          return false;
+      }
+    if ((flags & F_CHUNKED) != 0 || content_length != -1) {
+      return false;
+    }
+
+    return true;
+  }
+
   /* If http_should_keep_alive() in the on_headers_complete or
    * on_message_complete callback returns true, then this will be should be
    * the last message on the connection.
@@ -1408,19 +1527,153 @@ public class  HTTPParser {
       /* HTTP/1.1 */
       if ( 0 != (flags & F_CONNECTION_CLOSE) ) {
         return false;
-      } else {
-        return true;
       }
     } else {
       /* HTTP/1.0 or earlier */
-      if ( 0 != (flags & F_CONNECTION_KEEP_ALIVE) ) {
-        return true;
-      } else {
+      if ( 0 == (flags & F_CONNECTION_KEEP_ALIVE) ) {
         return false;
       }
     }
+    return !http_message_needs_eof();
+  }
+
+  public int parse_url(ByteBuffer data, boolean is_connect, HTTPParserUrl u) {
+    
+    UrlFields uf = UrlFields.UF_MAX;
+    UrlFields old_uf = UrlFields.UF_MAX;
+    u.port = 0;
+    u.field_set = 0;
+    state = (is_connect ? State.req_host_start : State.req_spaces_before_url);
+    int p_init = data.position();
+    int p = 0;
+    byte ch = 0;
+    while (data.position() != data.limit()) {
+      p = data.position();
+      ch = data.get();
+      state = parse_url_char(ch);
+      switch(state) {
+        case dead:
+          return 1;
+
+        /* Skip delimeters */
+        case req_schema_slash:
+        case req_schema_slash_slash:
+        case req_host_start:
+        case req_host_v6_start:
+        case req_host_v6_end:
+        case req_port_start:
+        case req_query_string_start:
+        case req_fragment_start:
+          continue;
+
+        case req_schema:
+          uf = UrlFields.UF_SCHEMA;
+          break;
+
+        case req_host:
+        case req_host_v6:
+          uf = UrlFields.UF_HOST;
+          break;
+
+        case req_port:
+          uf = UrlFields.UF_PORT;
+          break;
+
+        case req_path:
+          uf = UrlFields.UF_PATH;
+          break;
+
+        case req_query_string:
+          uf = UrlFields.UF_QUERY;
+          break;
+
+        case req_fragment:
+          uf = UrlFields.UF_FRAGMENT;
+          break;
+
+        default:
+          return 1;
+      }
+      /* Nothing's changed; soldier on */
+      if (uf == old_uf) {
+        u.field_data[uf.getIndex()].len++;
+        continue;
+      }
+
+      u.field_data[uf.getIndex()].off = p - p_init;
+      u.field_data[uf.getIndex()].len = 1;
+
+      u.field_set |= (1 << uf.getIndex());
+      old_uf = uf;
+
+    }
+
+    /* CONNECT requests can only contain "hostname:port" */
+    if (is_connect && u.field_set != ((1 << UrlFields.UF_HOST.getIndex())|(1 << UrlFields.UF_PORT.getIndex()))) {
+      return 1;
+    }
+
+    /* Make sure we don't end somewhere unexpected */
+    switch (state) {
+      case req_host_v6_start:
+      case req_host_v6:
+      case req_host_v6_end:
+      case req_host:
+      case req_port_start:
+        return 1;
+      default:
+        break;
+    }
+
+    if (0 != (u.field_set & (1 << UrlFields.UF_PORT.getIndex()))) {
+      /* Don't bother with endp; we've already validated the string */
+      int v = strtoi(data, p_init + u.field_data[UrlFields.UF_PORT.getIndex()].off);
+
+      /* Ports have a max value of 2^16 */
+      if (v > 0xffff) {
+        return 1;
+      }
+
+      u.port = v;
+    }
+    
+    return 0;
   }
 
+  //hacky reimplementation of srttoul, tailored for our simple needs
+  //we only need to parse port val, so no negative values etc
+  int strtoi(ByteBuffer data, int start_pos) {
+    data.position(start_pos);
+    byte ch;
+    int start = data.position();
+    int end = data.limit();
+    while(data.position() < data.limit()) {
+      ch = data.get();
+      if(Character.isWhitespace((char)ch)){
+        start++;
+        continue;
+      }
+      if(isDigit(ch)){
+        continue;
+      }else{
+        end = data.position() - 1;
+        break;
+      }
+    }
+    byte[] s = new byte[end - start];
+    int cur_pos = data.position();
+    data.position(start);
+    data.get(s);
+    int result = 0;
+    try{
+      result = Integer.parseInt(new String(s, "UTF8"));
+    } catch (UnsupportedEncodingException e) {
+      result = 0;
+    }
+    data.position(cur_pos);
+    return result;
+  }
+  
   boolean isDigit(byte b) {
     if (b >= 0x30 && b <=0x39) {
       return true;
@@ -1428,6 +1681,10 @@ public class  HTTPParser {
     return false;
   }
 
+  boolean isHex(byte b) {
+    return isDigit(b) || (lower(b) >= 0x61 /*a*/ && lower(b) <= 0x66 /*f*/);
+  }
+
   boolean isAtoZ(byte b) {
     byte c = lower(b);
     return (c>= 0x61 /*a*/ && c <=  0x7a /*z*/);
@@ -1442,7 +1699,30 @@ public class  HTTPParser {
     char c = (char)(b);
     return (byte)Character.toUpperCase(c);
   }
-	
+
+  byte token(byte b) {
+    if(!strict){
+        return (b == (byte)' ') ? (byte)' ' : (byte)tokens[b] ;
+    }else{
+        return (byte)tokens[b];
+    }
+  }
+
+  boolean isHostChar(byte ch){
+    if(!strict){
+      return (isAtoZ(ch)) || isDigit(ch) || DOT == ch || DASH == ch || UNDER == ch ;
+    }else{
+      return (isAtoZ(ch)) || isDigit(ch) || DOT == ch || DASH == ch;
+    }
+  }
+
+  boolean isNormalUrlChar(int chi) {
+    if(!strict){
+      return (chi > 0x80) || normal_url_char[chi];
+    }else{
+      return normal_url_char[chi];
+    }
+  }
 
   HTTPMethod start_req_method_assign(byte c){
     switch (c) {
@@ -1451,12 +1731,14 @@ public class  HTTPParser {
       case G: return HTTPMethod.HTTP_GET;     
       case H: return HTTPMethod.HTTP_HEAD;    
       case L: return HTTPMethod.HTTP_LOCK;    
-      case M: return HTTPMethod.HTTP_MKCOL;    /* or MOVE, MKACTIVITY, MERGE */
+      case M: return HTTPMethod.HTTP_MKCOL;    /* or MOVE, MKACTIVITY, MERGE, M-SEARCH */
+      case N: return HTTPMethod.HTTP_NOTIFY; 
       case O: return HTTPMethod.HTTP_OPTIONS; 
-      case P: return HTTPMethod.HTTP_POST;     /* or PROPFIND, PROPPATH, PUT */
+      case P: return HTTPMethod.HTTP_POST;     /* or PROPFIND|PROPPATCH|PUT|PATCH|PURGE */
       case R: return HTTPMethod.HTTP_REPORT;
+      case S: return HTTPMethod.HTTP_SUBSCRIBE;
       case T: return HTTPMethod.HTTP_TRACE;   
-      case U: return HTTPMethod.HTTP_UNLOCK;  
+      case U: return HTTPMethod.HTTP_UNLOCK; /* or UNSUBSCRIBE */ 
     }
     return null; // ugh.
   }
@@ -1466,7 +1748,7 @@ public class  HTTPParser {
       return false;
     }
 
-    state = State.header_field_start;
+    state = State.header_value_lws;
     // TODO java enums support some sort of bitflag mechanism !?
     switch (header_state) {
       case connection_keep_alive:
@@ -1484,111 +1766,17 @@ public class  HTTPParser {
     return true;
   }
 
-  boolean headers_almost_done (byte ch, ParserSettings settings) {
-
-    if (LF != ch) {
-      return false;
-    }
-
-    if (0 != (flags & F_TRAILING)) {
-      /* End of a chunked request */
-
-      settings.call_on_headers_complete(this);
-      settings.call_on_message_complete(this);
-
-      state = new_message(); 
-
-      return true;
-    }
-
-    nread = 0;
-
-    if (0 != (flags & F_UPGRADE) || HTTPMethod.HTTP_CONNECT == method) {
-      upgrade = true;
-    }
-    
-
-    /* Here we call the headers_complete callback. This is somewhat
-     * different than other callbacks because if the user returns 1, we
-     * will interpret that as saying that this message has no body. This
-     * is needed for the annoying case of recieving a response to a HEAD
-     * request.
-     */
-
-    /* (responses to HEAD request contain a CONTENT-LENGTH header
-     * but no content)
-     *
-     * Consider what to do here: I don't like the idea of the callback
-     * interface having a different contract in the case of HEAD
-     * responses. The alternatives would be either to:
-     *
-     * a.) require the header_complete callback to implement a different
-     * interface or
-     *
-     * b.) provide an overridden execute(bla, bla, boolean
-     * parsingHeader) implementation ...
-     */
-
-    /*TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO */ 
-    if (null != settings.on_headers_complete) {
-      settings.call_on_headers_complete(this);
-      //return;
-    }
-    
-    //        if (null != settings.on_headers_complete) {
-    //          switch (settings.on_headers_complete.cb(parser)) {
-    //            case 0:
-    //              break;
-    //
-    //            case 1:
-    //              flags |= F_SKIPBODY;
-    //              break;
-    //
-    //            default:
-    //              return p - data; /* Error */ // TODO // RuntimeException ?
-    //          }
-    //        }
-
-
-    // Exit, the rest of the connect is in a different protocol.
-    if (upgrade) {
-      settings.call_on_message_complete(this);
-      return true;
-    }
-
-    if (0 != (flags & F_SKIPBODY)) {
-      settings.call_on_message_complete(this);
-      state = new_message(); 
-    } else if (0 != (flags & F_CHUNKED)) {
-      /* chunked encoding - ignore Content-Length header */
-      state = State.chunk_size_start;
-    } else {
-      if (content_length == 0) {
-        /* Content-Length header given but zero: Content-Length: 0\r\n */
-        settings.call_on_message_complete(this);
-        state = new_message(); 
-      } else if (content_length > 0) {
-        /* Content-Length header given and non-zero */
-        state = State.body_identity;
-      } else {
-        if (type == ParserType.HTTP_REQUEST || http_should_keep_alive()) {
-          /* Assume content-length 0 - read the next */
-          settings.call_on_message_complete(this);
-          state = new_message(); 
-        } else {
-          /* Read body until EOF */
-          state = State.body_identity_eof;
-        }
-      }
-    }
-    return true;
-  } // headers_almost_fone
+//  boolean headers_almost_done (byte ch, ParserSettings settings) {
+//  } // headers_almost_done
 
 
   final int min (int a, int b) {
     return a < b ? a : b;
   }
   
+  final int min (int a, long b) {
+    return a < b ? a : (int)b;
+  }
   /* probably not the best place to hide this ... */
 	public boolean HTTP_PARSER_STRICT;
   State new_message() {
@@ -1608,19 +1796,16 @@ public class  HTTPParser {
 	boolean parsing_header(State state) {
 
 		switch (state) {
-			case chunk_size_start :
-			case chunk_size :
-			case chunk_size_almost_done :
-			case chunk_parameters :
 			case chunk_data :
 			case chunk_data_almost_done :
 			case chunk_data_done :
 			case body_identity :
 			case body_identity_eof :
+      case message_done :
 				return false;
 
 		}
-		return (0==(flags & F_TRAILING));
+    return true;
 	}
 
 	/* "Dial C for Constants" */
@@ -1676,12 +1861,16 @@ public class  HTTPParser {
     static final byte [] CLOSE = {
       0x43, 0x4c, 0x4f, 0x53, 0x45, 
     };
-    /* 
-     * ' ', '_', '-' and all alpha-numeric ascii characters are accepted by acceptable_header.
-     * The 'A'-'Z' are upper-cased.  
-    */
-    
-    static final char [] acceptable_header = {
+
+    /* Tokens as defined by rfc 2616. Also lowercases them.
+     *        token       = 1*<any CHAR except CTLs or separators>
+     *     separators     = "(" | ")" | "<" | ">" | "@"
+     *                    | "," | ";" | ":" | "\" | <">
+     *                    | "/" | "[" | "]" | "?" | "="
+     *                    | "{" | "}" | SP | HT
+     */
+
+    static final char [] tokens = {
 /*   0 nul    1 soh    2 stx    3 etx    4 eot    5 enq    6 ack    7 bel  */
         0,       0,       0,       0,       0,       0,       0,       0,
 /*   8 bs     9 ht    10 nl    11 vt    12 np    13 cr    14 so    15 si   */
@@ -1691,9 +1880,9 @@ public class  HTTPParser {
 /*  24 can   25 em    26 sub   27 esc   28 fs    29 gs    30 rs    31 us  */
         0,       0,       0,       0,       0,       0,       0,       0,
 /*  32 sp    33  !    34  "    35  #    36  $    37  %    38  &    39  '  */
-       ' ',      0,       0,       0,       0,       0,       0,       0,
+        0,     '!',       0,     '#',     '$',     '%',     '&',    '\'',
 /*  40  (    41  )    42  *    43  +    44  ,    45  -    46  .    47  /  */
-        0,       0,       0,       0,       0,      '-',      0,       0,
+        0,       0,      '*',     '+',       0,     '-',     '.',     0 ,
 /*  48  0    49  1    50  2    51  3    52  4    53  5    54  6    55  7  */
        '0',     '1',     '2',     '3',     '4',     '5',     '6',     '7',
 /*  56  8    57  9    58  :    59  ;    60  <    61  =    62  >    63  ?  */
@@ -1713,7 +1902,24 @@ public class  HTTPParser {
 /* 112  p   113  q   114  r   115  s   116  t   117  u   118  v   119  w  */
        'P',     'Q',     'R',     'S',     'T',     'U',     'V',     'W',
 /* 120  x   121  y   122  z   123  {   124  |   125  }   126  ~   127 del */
-       'X',     'Y',     'Z',      0,       0,       0,       0,       0 };
+       'X',     'Y',     'Z',      0,      '|',      0,      '~',       0,
+/* hi bit set, not ascii                                                  */
+        0,       0,       0,       0,       0,       0,       0,       0,
+        0,       0,       0,       0,       0,       0,       0,       0,
+        0,       0,       0,       0,       0,       0,       0,       0,
+        0,       0,       0,       0,       0,       0,       0,       0,
+        0,       0,       0,       0,       0,       0,       0,       0,
+        0,       0,       0,       0,       0,       0,       0,       0,
+        0,       0,       0,       0,       0,       0,       0,       0,
+        0,       0,       0,       0,       0,       0,       0,       0,
+        0,       0,       0,       0,       0,       0,       0,       0,
+        0,       0,       0,       0,       0,       0,       0,       0,
+        0,       0,       0,       0,       0,       0,       0,       0,
+        0,       0,       0,       0,       0,       0,       0,       0,
+        0,       0,       0,       0,       0,       0,       0,       0,
+        0,       0,       0,       0,       0,       0,       0,       0,
+        0,       0,       0,       0,       0,       0,       0,       0,
+        0,       0,       0,       0,       0,       0,       0,       0, };
 
     static final byte [] UNHEX =
     {    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
@@ -1724,6 +1930,14 @@ public class  HTTPParser {
         ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
         ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1
         ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+        ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+        ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+        ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+        ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+        ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+        ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+        ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+        ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
     };
 
     static final boolean [] normal_url_char = {
@@ -1758,7 +1972,8 @@ public class  HTTPParser {
 /* 112  p   113  q   114  r   115  s   116  t   117  u   118  v   119  w  */
      true,    true,    true,    true,    true,    true,    true,    true,
 /* 120  x   121  y   122  z   123  {   124  |   125  }   126  ~   127 del */
-     true,    true,    true,    true,    true,    true,    true,   false };
+     true,    true,    true,    true,    true,    true,    true,   false,
+    };
 
     public static final byte A = 0x41;
     public static final byte B = 0x42;
@@ -1786,16 +2001,19 @@ public class  HTTPParser {
     public static final byte X = 0x58;
     public static final byte Y = 0x59;
     public static final byte Z = 0x5a;
+    public static final byte UNDER = 0x5f;
     public static final byte CR = 0x0d;
     public static final byte LF = 0x0a;
     public static final byte DOT = 0x2e;
     public static final byte SPACE = 0x20;
+    public static final byte TAB = 0x09;
     public static final byte SEMI = 0x3b;
     public static final byte COLON = 0x3a;
     public static final byte HASH = 0x23;
     public static final byte QMARK = 0x3f;
     public static final byte SLASH = 0x2f;
     public static final byte DASH = 0x2d;
+    public static final byte STAR = 0x2a;
     public static final byte NULL = 0x00;
   }
 
@@ -1803,7 +2021,7 @@ public class  HTTPParser {
 
     dead               
 
-    , start_res_or_res
+    , start_req_or_res
     , res_or_resp_H
     , start_res
     , res_H
@@ -1826,7 +2044,12 @@ public class  HTTPParser {
     , req_schema
     , req_schema_slash
     , req_schema_slash_slash
+    , req_host_start
+    , req_host_v6_start
+    , req_host_v6
+    , req_host_v6_end
     , req_host
+    , req_port_start
     , req_port
     , req_path
     , req_query_string_start
@@ -1848,22 +2071,31 @@ public class  HTTPParser {
     , header_field
     , header_value_start
     , header_value
+    , header_value_lws
 
     , header_almost_done
 
-    , headers_almost_done
-
     , chunk_size_start
     , chunk_size
-    , chunk_size_almost_done
     , chunk_parameters
+    , chunk_size_almost_done
+
+    , headers_almost_done
+    , headers_done
+// This space intentionally not left blank, comment from c, for orientation...
+// the c version uses <= s_header_almost_done in java, we list the states explicitly
+// in `parsing_header()`
+/* Important: 's_headers_done' must be the last 'header' state. All
+ * states beyond this must be 'body' states. It is used for overflow
+ * checking. See the PARSING_HEADER() macro.
+ */
     , chunk_data
     , chunk_data_almost_done
     , chunk_data_done
 
     , body_identity
-    , body_identity_eof;
-
+    , body_identity_eof
+    , message_done
 
   }
   enum HState {
@@ -1891,4 +2123,24 @@ public class  HTTPParser {
     , connection_keep_alive
     , connection_close
   }
+  public enum UrlFields {
+      UF_SCHEMA(0)
+    , UF_HOST(1)
+    , UF_PORT(2)
+    , UF_PATH(3)
+    , UF_QUERY(4)
+    , UF_FRAGMENT(5)
+    , UF_MAX(6);
+
+
+    private final int index;
+
+    private UrlFields(int index) {
+      this.index = index;
+    }
+    public int getIndex() {
+      return index;
+    }
+
+  }
 }