http_parser.rb 0.5.1-x86-mingw32 → 0.5.2-x86-mingw32

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

@@ -22,19 +22,21 @@ public class  HTTPParser {
 	int nread;
 	int content_length;
 
-	
+  int start_position;
+  ByteBuffer data;
+
   /** 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.
@@ -95,21 +97,39 @@ public class  HTTPParser {
    * 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.start_position = p;
+    this.data           = data;
 
     // 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() - start_position;
+
+        case dead:
+        case start_res_or_res:
+        case start_res:
+        case start_req:
+          return data.position() - start_position;
+
+        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
@@ -151,6 +171,7 @@ public class  HTTPParser {
       int  pe = data.limit();
 
       byte ch     = data.get();           // the current character to process.
+      int  chi    = ch & 0xff;            // utility, ch without signedness for table lookups.
       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
 
@@ -158,9 +179,10 @@ public class  HTTPParser {
         ++nread;
         if (nread > HTTP_MAX_HEADER_SIZE) {
           settings.call_on_error(this, "possible buffer overflow", data, p_err);
+          return error();
         }
       }
-
+//p(state + ":" + ch +":"+p);
       switch (state) {
          /*
           * this state is used after a 'Connection: close' message
@@ -168,6 +190,7 @@ public class  HTTPParser {
           */
         case dead:
           settings.call_on_error(this, "Connection already closed", data, p_err);
+          return error();
 
 
 
@@ -187,6 +210,7 @@ public class  HTTPParser {
             method = start_req_method_assign(ch);     
             if (null == method) {
               settings.call_on_error(this, "invalid method", data, p_err);
+              return error();
             }
             index  = 1;
             state  = State.req_method;
@@ -202,6 +226,7 @@ public class  HTTPParser {
           } else {
             if (E != ch) {
               settings.call_on_error(this, "not E", data, p_err);
+              return error();
             }
             type   = ParserType.HTTP_REQUEST;
             method = HTTPMethod.HTTP_HEAD;
@@ -227,6 +252,7 @@ public class  HTTPParser {
               break;
             default:
               settings.call_on_error(this, "Not H or CR/LF", data, p_err);
+              return error();
           }
           break;
 
@@ -235,24 +261,28 @@ public class  HTTPParser {
         case res_H:
           if (strict && T != ch) {
             settings.call_on_error(this, "Not T", data, p_err);
+            return error();
           }
           state = State.res_HT;
           break;
         case res_HT:
           if (strict && T != ch) {
             settings.call_on_error(this, "Not T2", data, p_err);
+            return error();
           }
           state = State.res_HTT;
           break;
         case res_HTT:
           if (strict && P != ch) {
             settings.call_on_error(this, "Not P", data, p_err);
+            return error();
           }
           state = State.res_HTTP;
           break;
         case res_HTTP:
           if (strict && SLASH != ch) {
             settings.call_on_error(this, "Not '/'", data, p_err);
+            return error();
           }
           state = State.res_first_http_major;
           break;
@@ -262,6 +292,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();
           }
           http_major = (int) ch - 0x30;
           state = State.res_http_major;
@@ -270,17 +301,19 @@ 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();
           }
           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();
           }
           break;
           
@@ -288,6 +321,7 @@ public class  HTTPParser {
         case res_first_http_minor:
           if (!isDigit(ch)) {
             settings.call_on_error(this, "Not a digit", data, p_err);
+            return error();
           }
           http_minor = (int)ch - 0x30;
           state = State.res_http_minor;
@@ -301,12 +335,13 @@ public class  HTTPParser {
           }
           if (!isDigit(ch)) {
             settings.call_on_error(this, "Not a digit", data, p_err);
+            return error();
           }
           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();
           }
           break;
 
@@ -318,6 +353,7 @@ public class  HTTPParser {
               break;
             }
             settings.call_on_error(this, "Not a digit (status code)", data, p_err);
+            return error();
           }
           status_code = (int)ch - 0x30;
           state = State.res_status_code;
@@ -337,6 +373,7 @@ public class  HTTPParser {
                 break;
               default:
                 settings.call_on_error(this, "not a valid status code", data, p_err);
+                return error();
             }
             break;
           }
@@ -344,6 +381,7 @@ public class  HTTPParser {
           status_code += (int)ch - 0x30;
           if (status_code > 999) {
             settings.call_on_error(this, "ridiculous status code:"+status_code, data, p_err);
+            return error();
           }
           break;
 
@@ -365,6 +403,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();
           }
           state = State.header_field_start;
           break;
@@ -372,7 +411,7 @@ public class  HTTPParser {
 
 
         case start_req:
-          if (CR==ch || LF == LF) {
+          if (CR==ch || LF == ch) {
             break;
           }
           flags = 0;
@@ -381,6 +420,7 @@ public class  HTTPParser {
           method = start_req_method_assign(ch);
           if (null == method) {
             settings.call_on_error(this, "invalid method", data, p_err);
+            return error();
           }
           index  = 1;
           state  = State.req_method;
@@ -391,6 +431,7 @@ public class  HTTPParser {
         case req_method:
           if (0 == ch) {
             settings.call_on_error(this, "NULL in method", data, p_err);
+            return error();
           }
           
           byte [] arr = method.bytes;
@@ -410,6 +451,8 @@ 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;
               }
@@ -417,10 +460,13 @@ public class  HTTPParser {
             method = HTTPMethod.HTTP_PROPFIND;
           } else if (1 == index && HTTPMethod.HTTP_POST     == method && U == ch) {
             method = HTTPMethod.HTTP_PUT;
+          } else if (2 == index && HTTPMethod.HTTP_UNLOCK   == method && 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();
           }
 
           ++index;
@@ -433,7 +479,7 @@ public class  HTTPParser {
           if (SPACE == ch) {
             break;
           }
-          if (SLASH == ch) {
+          if (SLASH == ch || STAR == ch) {
             url_mark  = p;
             path_mark = p;
             state = State.req_path;
@@ -445,6 +491,7 @@ public class  HTTPParser {
             break;
           }
           settings.call_on_error(this, "Invalid something", data, p_err);
+          return error();
 
         case req_schema:
           if (isAtoZ(ch)){
@@ -453,15 +500,17 @@ public class  HTTPParser {
           if (COLON == ch) {
             state = State.req_schema_slash;
             break;
-          } else if (DOT == ch) {
+          } else if (DOT == ch || isDigit(ch)) {
             state = State.req_host;
             break;
           }
           settings.call_on_error(this, "invalid char in schema: "+ch, data, p_err);
+          return error();
 
         case req_schema_slash:
           if (strict && SLASH != ch) {
             settings.call_on_error(this, "invalid char in schema, not /", data, p_err);
+            return error();
           }
           state = State.req_schema_slash_slash;
           break;
@@ -469,6 +518,7 @@ public class  HTTPParser {
         case req_schema_slash_slash:
           if (strict && SLASH != ch) {
             settings.call_on_error(this, "invalid char in schema, not /", data, p_err);
+            return error();
           }
           state = State.req_host;
           break;
@@ -494,8 +544,12 @@ public class  HTTPParser {
               url_mark = -1;
               state = State.req_http_start;
               break;
+            case QMARK:
+              state = State.req_query_string_start;
+              break;
             default:
               settings.call_on_error(this, "host error in method line", data, p_err);
+              return error();
           }
           break;
 
@@ -515,13 +569,17 @@ public class  HTTPParser {
               url_mark = -1;
               state = State.req_http_start;
               break;
+            case QMARK:
+              state = State.req_query_string_start;
+              break;
             default:
               settings.call_on_error(this, "invalid port", data, p_err);
+              return error();
           }
           break;
       
         case req_path:
-          if (normal_url_char[ch]) break;
+          if (normal_url_char[chi]) break;
           switch (ch) {
             case SPACE:
               settings.call_on_url(this,data,url_mark, p-url_mark);
@@ -571,11 +629,12 @@ public class  HTTPParser {
             
             default:
               settings.call_on_error(this, "unexpected char in path", data, p_err);
+              return error();
           }
           break;
       
         case req_query_string_start:
-          if (normal_url_char[ch]) {
+          if (normal_url_char[chi]) {
             query_string_mark = p;
             state = State.req_query_string;
             break;
@@ -605,11 +664,12 @@ public class  HTTPParser {
               break;
             default:
               settings.call_on_error(this, "unexpected char in path", data, p_err);
+              return error();
           }
           break;
         
         case req_query_string:
-          if (normal_url_char[ch]) {
+          if (normal_url_char[chi]) {
             break;
           }
 
@@ -652,11 +712,12 @@ public class  HTTPParser {
               break;
             default:
               settings.call_on_error(this, "unexpected char in path", data, p_err);
+              return error();
           }
           break;
 
         case req_fragment_start:
-          if (normal_url_char[ch]) {
+          if (normal_url_char[chi]) {
             fragment_mark = p;
             state = State.req_fragment;
             break;
@@ -691,11 +752,12 @@ public class  HTTPParser {
               break;
             default:
               settings.call_on_error(this, "unexpected char in path", data, p_err);
+              return error();
           }
           break;
 
         case req_fragment:
-          if (normal_url_char[ch]) {
+          if (normal_url_char[chi]) {
             break;
           }
 
@@ -734,6 +796,7 @@ public class  HTTPParser {
               break;
             default:
               settings.call_on_error(this, "unexpected char in path", data, p_err);
+              return error();
           }
           break;
         /******************* URL *******************/
@@ -750,12 +813,14 @@ public class  HTTPParser {
               break;
             default:
               settings.call_on_error(this, "error in req_http_H", data, p_err);
+              return error();
           }
           break;
 
         case req_http_H:
           if (strict && T != ch) {
             settings.call_on_error(this, "unexpected char", data, p_err);
+            return error();
           }
           state = State.req_http_HT;
           break;
@@ -763,6 +828,7 @@ public class  HTTPParser {
         case req_http_HT:
           if (strict && T != ch) {
             settings.call_on_error(this, "unexpected char", data, p_err);
+            return error();
           }
           state = State.req_http_HTT;
           break;
@@ -770,6 +836,7 @@ public class  HTTPParser {
         case req_http_HTT:
           if (strict && P != ch) {
             settings.call_on_error(this, "unexpected char", data, p_err);
+            return error();
           }
           state = State.req_http_HTTP;
           break;
@@ -777,6 +844,7 @@ public class  HTTPParser {
         case req_http_HTTP:
           if (strict && SLASH != ch) {
             settings.call_on_error(this, "unexpected char", data, p_err);
+            return error();
           }
           state = req_first_http_major;
           break;
@@ -785,6 +853,7 @@ public class  HTTPParser {
         case req_first_http_major:
           if (!isDigit(ch)) {
             settings.call_on_error(this, "non digit in http major", data, p_err);
+            return error();
           }
           http_major = (int)ch - 0x30;
           state = State.req_http_major;
@@ -799,6 +868,7 @@ public class  HTTPParser {
 
           if (!isDigit(ch)) {
             settings.call_on_error(this, "non digit in http major", data, p_err);
+            return error();
           }
 
           http_major *= 10;
@@ -806,6 +876,7 @@ public class  HTTPParser {
 
           if (http_major > 999) {
             settings.call_on_error(this, "ridiculous http major", data, p_err);
+            return error();
           };
           break;
         
@@ -813,6 +884,7 @@ public class  HTTPParser {
         case req_first_http_minor:
           if (!isDigit(ch)) {
             settings.call_on_error(this, "non digit in http minor", data, p_err);
+            return error();
           }
           http_minor = (int)ch - 0x30;
           state = State.req_http_minor;
@@ -833,6 +905,7 @@ public class  HTTPParser {
 
           if (!isDigit(ch)) {
             settings.call_on_error(this, "non digit in http minor", data, p_err);
+            return error();
           }
 
           http_minor *= 10;
@@ -841,6 +914,7 @@ public class  HTTPParser {
          
           if (http_minor > 999) {
             settings.call_on_error(this, "ridiculous http minor", data, p_err);
+            return error();
           };
    
           break;
@@ -850,6 +924,7 @@ public class  HTTPParser {
         {
           if (ch != LF) {
             settings.call_on_error(this, "missing LF after request line", data, p_err);
+            return error();
           }
           state = State.header_field_start;
           break;
@@ -873,14 +948,19 @@ public class  HTTPParser {
             state = State.headers_almost_done;
             if (!headers_almost_done(ch, settings)) {
               settings.call_on_error(this, "header not properly completed", data, p_err);
+              return error();
+            }
+            if (upgrade) {
+              return data.position() - start_position;
             }
             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) {
+            settings.call_on_error(this, "invalid char in header:"+c, data, p_err);
+            return error();
           };
 
           header_field_mark = p;
@@ -916,7 +996,7 @@ public class  HTTPParser {
 
         case header_field:
         {
-          c = (byte) acceptable_header[ch];
+          c = token(ch);
           if (0 != c) {  
             switch (header_state) {
               case general:
@@ -1011,6 +1091,7 @@ public class  HTTPParser {
 
               default:
                 settings.call_on_error(this, "Unknown Header State", data, p_err);
+                return error();
             } // switch: header_state
             break;
           } // 0 != c
@@ -1040,6 +1121,7 @@ public class  HTTPParser {
           }
 
           settings.call_on_error(this, "invalid header field", data, p_err);
+          return error();
         }
 
 
@@ -1053,30 +1135,27 @@ public class  HTTPParser {
           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;
@@ -1095,6 +1174,7 @@ public class  HTTPParser {
             case content_length:
               if (!isDigit(ch)) {
                 settings.call_on_error(this, "Content-Length not numeric", data, p_err);
+                return error();
               } 
               content_length = (int)ch - 0x30;
               break;
@@ -1122,29 +1202,27 @@ 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;
+            
+            if (!header_almost_done(ch)) {
+              settings.call_on_error(this,"incorrect header ending, expection LF", data, p_err);
+              return error();
             }
             break;
           }
 
+          c = upper(ch);
           switch (header_state) {
             case general:
               break;
@@ -1152,6 +1230,7 @@ public class  HTTPParser {
             case connection:
             case transfer_encoding:
               settings.call_on_error(this, "Shouldn't be here", data, p_err);
+              return error();
 
             case content_length:
               if (SPACE == ch) {
@@ -1159,6 +1238,7 @@ public class  HTTPParser {
               }
               if (!isDigit(ch)) {
                 settings.call_on_error(this, "Content-Length not numeric", data, p_err);
+                return error();
               } 
 
               content_length *= 10;
@@ -1214,12 +1294,17 @@ 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();
           }
           break;
 
         case headers_almost_done:
           if (!headers_almost_done(ch, settings)) {
             settings.call_on_error(this, "header not properly completed", data, p_err);
+            return error();
+          }
+          if (upgrade) {
+            return data.position()-start_position ;
           }
           break;
 
@@ -1258,13 +1343,20 @@ public class  HTTPParser {
 
         /******************* Chunk *******************/
         case chunk_size_start:
+          if (1 != this.nread) {
+            settings.call_on_error(this, "nread != 1 (chunking)", data, p_err);
+            return error();
+          
+          }
           if (0 == (flags & F_CHUNKED)) {
             settings.call_on_error(this, "not chunked", data, p_err);
+            return error();
           }
 
-          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();
           }
           content_length = c;
           state = State.chunk_size;
@@ -1275,6 +1367,7 @@ public class  HTTPParser {
         case chunk_size:
           if (0 == (flags & F_CHUNKED)) {
             settings.call_on_error(this, "not chunked", data, p_err);
+            return error();
           }
 
           if (CR == ch) {
@@ -1282,7 +1375,7 @@ public class  HTTPParser {
             break;
           }
 
-          c = UNHEX[ch];
+          c = UNHEX[chi];
 
           if (c == -1) {
             if (SEMI == ch || SPACE == ch) {
@@ -1290,6 +1383,7 @@ public class  HTTPParser {
               break;
             }
             settings.call_on_error(this, "invalid hex char in chunk content length", data, p_err);
+            return error();
           }
 
           content_length *= 16;
@@ -1301,6 +1395,7 @@ public class  HTTPParser {
         case chunk_parameters:
           if (0 == (flags & F_CHUNKED)) {
             settings.call_on_error(this, "not chunked", data, p_err);
+            return error();
           }
           /* just ignore this shit. TODO check for overflow */
           if (CR == ch) {
@@ -1314,11 +1409,15 @@ 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();
           }
           if (strict && LF != ch) {
             settings.call_on_error(this, "expected LF at end of chunk size", data, p_err);
+            return error();
           }
 
+          this.nread = 0;
+
           if (0 == content_length) {
             flags |= F_TRAILING;
             state = State.header_field_start;
@@ -1333,6 +1432,7 @@ public class  HTTPParser {
         {
           if (0 == (flags & F_CHUNKED)) {
             settings.call_on_error(this, "not chunked", data, p_err);
+            return error();
           }
 
           to_read = min(pe-p, content_length);
@@ -1354,9 +1454,11 @@ public class  HTTPParser {
         case chunk_data_almost_done:
           if (0 == (flags & F_CHUNKED)) {
             settings.call_on_error(this, "not chunked", data, p_err);
+            return error();
           }
           if (strict && CR != ch) {
             settings.call_on_error(this, "chunk data terminated incorrectly, expected CR", data, p_err);
+            return error();
           }
           state = State.chunk_data_done;
           break;
@@ -1366,9 +1468,11 @@ public class  HTTPParser {
         case chunk_data_done:
           if (0 == (flags & F_CHUNKED)) {
             settings.call_on_error(this, "not chunked", data, p_err);
+            return error();
           }
           if (strict && LF != ch) {
             settings.call_on_error(this, "chunk data terminated incorrectly, expected LF", data, p_err);
+            return error();
           }
           state = State.chunk_size_start;
           break;
@@ -1378,6 +1482,7 @@ public class  HTTPParser {
         
         default:
           settings.call_on_error(this, "unhandled state", data, p_err);
+          return error();
           
       } // switch
     } // while
@@ -1394,9 +1499,15 @@ public class  HTTPParser {
     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);
-	
+    
+    return data.position()-start_position;	
   } // execute
 
+  int error () {
+    this.state = State.dead;
+    return this.data.position()-start_position;
+  }
+
   /* 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.
@@ -1442,6 +1553,10 @@ public class  HTTPParser {
     char c = (char)(b);
     return (byte)Character.toUpperCase(c);
   }
+
+  byte token(byte b) {
+    return (byte)tokens[b];
+  }
 	
 
   HTTPMethod start_req_method_assign(byte c){
@@ -1451,12 +1566,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 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.
   }
@@ -1489,7 +1606,6 @@ public class  HTTPParser {
     if (LF != ch) {
       return false;
     }
-
     if (0 != (flags & F_TRAILING)) {
       /* End of a chunked request */
 
@@ -1553,6 +1669,7 @@ public class  HTTPParser {
     // Exit, the rest of the connect is in a different protocol.
     if (upgrade) {
       settings.call_on_message_complete(this);
+      state = State.body_identity_eof;
       return true;
     }
 
@@ -1608,10 +1725,6 @@ 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 :
@@ -1620,7 +1733,7 @@ public class  HTTPParser {
 				return false;
 
 		}
-		return (0==(flags & F_TRAILING));
+    return true;
 	}
 
 	/* "Dial C for Constants" */
@@ -1676,12 +1789,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 +1808,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,
+       ' ',     '!',     '"',     '#',     '$',     '%',     '&',    '\'',
 /*  40  (    41  )    42  *    43  +    44  ,    45  -    46  .    47  /  */
-        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 +1830,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 +1858,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 +1900,31 @@ 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,
+
+/*    hi bit set, not ascii                                                  */
+/*    Remainder of non-ASCII range are accepted as-is to support implicitly UTF-8
+ *    encoded paths. This is out of spec, but clients generate this and most other
+ *    HTTP servers support it. We should, too. */
+
+     true,    true,    true,    true,    true,    true,    true,    true, 
+     true,    true,    true,    true,    true,    true,    true,    true, 
+     true,    true,    true,    true,    true,    true,    true,    true, 
+     true,    true,    true,    true,    true,    true,    true,    true, 
+     true,    true,    true,    true,    true,    true,    true,    true, 
+     true,    true,    true,    true,    true,    true,    true,    true, 
+     true,    true,    true,    true,    true,    true,    true,    true, 
+     true,    true,    true,    true,    true,    true,    true,    true, 
+     true,    true,    true,    true,    true,    true,    true,    true, 
+     true,    true,    true,    true,    true,    true,    true,    true, 
+     true,    true,    true,    true,    true,    true,    true,    true, 
+     true,    true,    true,    true,    true,    true,    true,    true, 
+     true,    true,    true,    true,    true,    true,    true,    true, 
+     true,    true,    true,    true,    true,    true,    true,    true, 
+     true,    true,    true,    true,    true,    true,    true,    true, 
+     true,    true,    true,    true,    true,    true,    true,    true, 
+    
+    };
 
     public static final byte A = 0x41;
     public static final byte B = 0x42;
@@ -1796,6 +1962,7 @@ public class  HTTPParser {
     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;
   }
 
@@ -1851,12 +2018,19 @@ public class  HTTPParser {
 
     , header_almost_done
 
-    , headers_almost_done
-
     , chunk_size_start
     , chunk_size
-    , chunk_size_almost_done
     , chunk_parameters
+    , chunk_size_almost_done
+
+    , headers_almost_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_almost_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