Add HTTP/1.0 support and simplify persistent connections handling

runtime/bin/http_parser.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // Global constants.
 class _Const {
+  // Bytes for "HTTP".
+  static final HTTP = const [72, 84, 84, 80];
+  // Bytes for "HTTP/1.".
+  static final HTTP1DOT = const [72, 84, 84, 80, 47, 49, 46];
   // Bytes for "HTTP/1.0".
   static final HTTP10 = const [72, 84, 84, 80, 47, 49, 46, 48];
   // Bytes for "HTTP/1.1".
   static final HTTP11 = const [72, 84, 84, 80, 47, 49, 46, 49];
 
   static final END_CHUNKED = const [0x30, 13, 10, 13, 10];
 
   // Bytes for '()<>@,;:\\"/[]?={} \t'.
   static final SEPARATORS = const [40, 41, 60, 62, 64, 44, 59, 58, 92, 34, 47,
                                    91, 93, 63, 61, 123, 125, 32, 9];
 
   // Bytes for '()<>@,;:\\"/[]?={} \t\r\n'.
   static final SEPARATORS_AND_CR_LF = const [40, 41, 60, 62, 64, 44, 59, 58, 92,
                                              34, 47, 91, 93, 63, 61, 123, 125,
                                              32, 9, 13, 10];
 }
 
 
 // Frequently used character codes.
 class _CharCode {
   static final int HT = 9;
   static final int LF = 10;
   static final int CR = 13;
   static final int SP = 32;
+  static final int SLASH = 47;
+  static final int ZERO = 48;
+  static final int ONE = 49;
   static final int COLON = 58;
   static final int SEMI_COLON = 59;
 }
 
 
 // States of the HTTP parser state machine.
 class _State {
   static final int START = 0;
-  static final int METHOD_OR_HTTP_VERSION = 1;
-  static final int REQUEST_LINE_METHOD = 2;
-  static final int REQUEST_LINE_URI = 3;
-  static final int REQUEST_LINE_HTTP_VERSION = 4;
-  static final int REQUEST_LINE_ENDING = 5;
-  static final int RESPONSE_LINE_STATUS_CODE = 6;
-  static final int RESPONSE_LINE_REASON_PHRASE = 7;
-  static final int RESPONSE_LINE_ENDING = 8;
-  static final int HEADER_START = 9;
-  static final int HEADER_FIELD = 10;
-  static final int HEADER_VALUE_START = 11;
-  static final int HEADER_VALUE = 12;
-  static final int HEADER_VALUE_FOLDING_OR_ENDING = 13;
-  static final int HEADER_VALUE_FOLD_OR_END = 14;
-  static final int HEADER_ENDING = 15;
+  static final int METHOD_OR_RESPONSE_HTTP_VERSION = 1;
+  static final int RESPONSE_HTTP_VERSION = 2;
+  static final int REQUEST_LINE_METHOD = 3;
+  static final int REQUEST_LINE_URI = 4;
+  static final int REQUEST_LINE_HTTP_VERSION = 5;
+  static final int REQUEST_LINE_ENDING = 6;
+  static final int RESPONSE_LINE_STATUS_CODE = 7;
+  static final int RESPONSE_LINE_REASON_PHRASE = 8;
+  static final int RESPONSE_LINE_ENDING = 9;
+  static final int HEADER_START = 10;
+  static final int HEADER_FIELD = 11;
+  static final int HEADER_VALUE_START = 12;
+  static final int HEADER_VALUE = 13;
+  static final int HEADER_VALUE_FOLDING_OR_ENDING = 14;
+  static final int HEADER_VALUE_FOLD_OR_END = 15;
+  static final int HEADER_ENDING = 16;
 
-  static final int CHUNK_SIZE_STARTING_CR = 16;
-  static final int CHUNK_SIZE_STARTING_LF = 17;
-  static final int CHUNK_SIZE = 18;
-  static final int CHUNK_SIZE_EXTENSION = 19;
-  static final int CHUNK_SIZE_ENDING = 20;
-  static final int CHUNKED_BODY_DONE_CR = 21;
-  static final int CHUNKED_BODY_DONE_LF = 22;
-  static final int BODY = 23;
-  static final int CLOSED = 24;
-  static final int UPGRADED = 25;
-  static final int FAILURE = 26;
+  static final int CHUNK_SIZE_STARTING_CR = 17;
+  static final int CHUNK_SIZE_STARTING_LF = 18;
+  static final int CHUNK_SIZE = 19;
+  static final int CHUNK_SIZE_EXTENSION = 20;
+  static final int CHUNK_SIZE_ENDING = 21;
+  static final int CHUNKED_BODY_DONE_CR = 22;
+  static final int CHUNKED_BODY_DONE_LF = 23;
+  static final int BODY = 24;
+  static final int CLOSED = 25;
+  static final int UPGRADED = 26;
+  static final int FAILURE = 27;
 
   static final int FIRST_BODY_STATE = CHUNK_SIZE_STARTING_CR;
 }
 
+// HTTP version of the request or response being parsed.
+class _HttpVersion {
+  static final int UNDETERMINED = 0;
+  static final int HTTP10 = 1;
+  static final int HTTP11 = 2;
+}
 
 // States of the HTTP parser state machine.
 class _MessageType {
   static final int UNDETERMINED = 0;
   static final int REQUEST = 1;
   static final int RESPONSE = 0;
 }
 
 
 /**
@@ skipping 47 matching lines @@
       if (_state == _State.CLOSED) {
         throw new HttpParserException("Data on closed connection");
       }
       if (_state == _State.UPGRADED) {
         throw new HttpParserException("Data on upgraded connection");
       }
       while ((index < lastIndex) && _state != _State.FAILURE && _state != _State.UPGRADED) {
         int byte = buffer[index];
         switch (_state) {
           case _State.START:
-            if (byte == _Const.HTTP11[0]) {
-              // Start parsing HTTP method.
+            if (byte == _Const.HTTP[0]) {
+              // Start parsing method or HTTP version.
               _httpVersionIndex = 1;
-              _state = _State.METHOD_OR_HTTP_VERSION;
+              _state = _State.METHOD_OR_RESPONSE_HTTP_VERSION;
             } else {
               // Start parsing method.
-              if (_Const.SEPARATORS_AND_CR_LF.indexOf(byte) != -1) {
+              if (!_isTokenChar(byte)) {
                 throw new HttpParserException("Invalid request method");
               }
               _method_or_status_code.addCharCode(byte);
               _state = _State.REQUEST_LINE_METHOD;
             }
             break;
 
-          case _State.METHOD_OR_HTTP_VERSION:
-            if (_httpVersionIndex < _Const.HTTP11.length &&
-                byte == _Const.HTTP11[_httpVersionIndex]) {
+          case _State.METHOD_OR_RESPONSE_HTTP_VERSION:
+            if (_httpVersionIndex < _Const.HTTP.length &&
+                byte == _Const.HTTP[_httpVersionIndex]) {
               // Continue parsing HTTP version.
               _httpVersionIndex++;
-            } else if (_httpVersionIndex == _Const.HTTP11.length &&
-                       byte == _CharCode.SP) {
+            } else if (_httpVersionIndex == _Const.HTTP.length &&
+                       byte == _CharCode.SLASH) {
+              // HTTP/ parsed. As method is a token this cannot be a method anymore.
+              _httpVersionIndex++;
+              _state = _State.RESPONSE_HTTP_VERSION;
+            } else {
+              // Did not parse HTTP version. Expect method instead.
+              for (int i = 0; i < _httpVersionIndex; i++) {
+                _method_or_status_code.addCharCode(_Const.HTTP[i]);
+              }
+              //_method_or_status_code.addCharCode(byte);
+              _httpVersion = _HttpVersion.UNDETERMINED;
+              _state = _State.REQUEST_LINE_URI;
+            }
+            break;
+
+          case _State.RESPONSE_HTTP_VERSION:
+            if (_httpVersionIndex < _Const.HTTP1DOT.length) {
+              // Continue parsing HTTP version.
+              _expect(byte, _Const.HTTP1DOT[_httpVersionIndex]);
+              _httpVersionIndex++;
+            } else if (_httpVersionIndex == _Const.HTTP1DOT.length &&
+                       byte == _CharCode.ONE) {
+              // HTTP/1.1 parsed.
+              _httpVersion = _HttpVersion.HTTP11;
+              _persistentConnection = true;
+              _httpVersionIndex++;
+            } else if (_httpVersionIndex == _Const.HTTP1DOT.length &&
+                       byte == _CharCode.ZERO) {
+              // HTTP/1.0 parsed.
+              _httpVersion = _HttpVersion.HTTP10;
+              _persistentConnection = false;
+              _httpVersionIndex++;
+            } else if (_httpVersionIndex == _Const.HTTP1DOT.length + 1) {
+              _expect(byte, _CharCode.SP);
               // HTTP version parsed.
               _state = _State.RESPONSE_LINE_STATUS_CODE;
             } else {
-              // Did not parse HTTP version. Expect method instead.
-              for (int i = 0; i < _httpVersionIndex; i++) {
-                _method_or_status_code.addCharCode(_Const.HTTP11[i]);
-              }
-              _state = _State.REQUEST_LINE_URI;
+              throw new HttpParserException("Invalid response line");
             }
             break;
 
           case _State.REQUEST_LINE_METHOD:
             if (byte == _CharCode.SP) {
               _state = _State.REQUEST_LINE_URI;
             } else {
               if (_Const.SEPARATORS_AND_CR_LF.indexOf(byte) != -1) {
                 throw new HttpParserException("Invalid request method");
               }
               _method_or_status_code.addCharCode(byte);
             }
             break;
 
           case _State.REQUEST_LINE_URI:
             if (byte == _CharCode.SP) {
               _state = _State.REQUEST_LINE_HTTP_VERSION;
               _httpVersionIndex = 0;
             } else {
               if (byte == _CharCode.CR || byte == _CharCode.LF) {
                 throw new HttpParserException("Invalid request URI");
               }
               _uri_or_reason_phrase.addCharCode(byte);
             }
             break;
 
           case _State.REQUEST_LINE_HTTP_VERSION:
-            if (_httpVersionIndex < _Const.HTTP11.length) {
+            if (_httpVersionIndex < _Const.HTTP1DOT.length) {
               _expect(byte, _Const.HTTP11[_httpVersionIndex]);
               _httpVersionIndex++;
+            } else if (_httpVersionIndex == _Const.HTTP1DOT.length) {
+              if (byte == _CharCode.ONE) {
+                // HTTP/1.1 parsed.
+                _httpVersion = _HttpVersion.HTTP11;
+                _persistentConnection = true;
+                _httpVersionIndex++;
+              } else if (byte == _CharCode.ZERO) {
+                // HTTP/1.0 parsed.
+                _httpVersion = _HttpVersion.HTTP10;
+                _persistentConnection = false;
+                _httpVersionIndex++;
+              } else {
+                throw new HttpParserException("Invalid response line");
+              }
             } else {
               _expect(byte, _CharCode.CR);
               _state = _State.REQUEST_LINE_ENDING;
             }
             break;
 
           case _State.REQUEST_LINE_ENDING:
             _expect(byte, _CharCode.LF);
             _messageType = _MessageType.REQUEST;
             if (requestStart != null) {
               requestStart(_method_or_status_code.toString(),
-                           _uri_or_reason_phrase.toString());
+                           _uri_or_reason_phrase.toString(),
+                           version);
             }
             _method_or_status_code.clear();
             _uri_or_reason_phrase.clear();
             _state = _State.HEADER_START;
             break;
 
           case _State.RESPONSE_LINE_STATUS_CODE:
             if (byte == _CharCode.SP) {
               if (_method_or_status_code.length != 3) {
                 throw new HttpParserException("Invalid response status code");
@@ skipping 27 matching lines @@
             _messageType == _MessageType.RESPONSE;
             int statusCode = Math.parseInt(_method_or_status_code.toString());
             if (statusCode < 100 || statusCode > 599) {
               throw new HttpParserException("Invalid response status code");
             } else {
               // Check whether this response will never have a body.
               _noMessageBody =
                   statusCode <= 199 || statusCode == 204 || statusCode == 304;
             }
             if (responseStart != null) {
-              responseStart(statusCode, _uri_or_reason_phrase.toString());
+              responseStart(statusCode, _uri_or_reason_phrase.toString(), version);
             }
             _method_or_status_code.clear();
             _uri_or_reason_phrase.clear();
             _state = _State.HEADER_START;
             break;
 
           case _State.HEADER_START:
             if (byte == _CharCode.CR) {
               _state = _State.HEADER_ENDING;
             } else {
@@ skipping 45 matching lines @@
               String headerValue =_headerValue.toString();
               // Ignore the Content-Length header if Transfer-Encoding
               // is chunked (RFC 2616 section 4.4)
               if (headerField == "content-length" && !_chunked) {
                 _contentLength = Math.parseInt(headerValue);
               } else if (headerField == "connection") {
                 List<String> tokens = _tokenizeFieldValue(headerValue);
                 for (int i = 0; i < tokens.length; i++) {
                   String token = tokens[i].toLowerCase();
                   if (token == "keep-alive") {
-                    _keepAlive = true;
+                    _persistentConnection = true;
                   } else if (token == "close") {
-                    _connectionClose = true;
+                    _persistentConnection = false;
                   } else if (token == "upgrade") {
                     _connectionUpgrade = true;
                   }
                 }
               } else if (headerField == "transfer-encoding" &&

[Anders Johnsen, 2012/04/13 09:02:38]

toLowerCase here as well. Actually, maybe we should change the definition of
headerField to say toLowerCase?

[Søren Gjesse, 2012/04/13 10:58:31]

This is not required. When the header name is parsed it is turned into lower
case. The header value is not as it can be case dependent.

-                         headerValue == "chunked") {
+                         headerValue.toLowerCase() == "chunked") {
                 _chunked = true;
                 _contentLength = -1;
               }
               if (headerReceived != null) {
                 headerReceived(headerField, headerValue);
               }
               _headerField.clear();
               _headerValue.clear();
 
               if (byte == _CharCode.CR) {
@@ skipping 169 matching lines @@
       var e = new HttpParserException(
           "Connection closed before full body was received");
       if (error != null) {
         error(e);
         return;
       }
       throw e;
     }
   }
 
+  String get version() {
+    switch (_httpVersion) {
+      case _HttpVersion.HTTP10:
+        return "1.0";
+        break;
+      case _HttpVersion.HTTP11:
+        return "1.1";
+        break;
+    }
+    return null;
+  }
+
   int get messageType() => _messageType;
   int get contentLength() => _contentLength;
-  bool get keepAlive() => _keepAlive;
   bool get upgrade() => _connectionUpgrade && _state == _State.UPGRADED;
+  bool get persistentConnection() => _persistentConnection;
 
   void set responseToMethod(String method) => _responseToMethod = method;
 
   bool get isIdle() => _state == _State.START;
 
   void _bodyEnd() {
     if (dataEnd != null) {
-      dataEnd(_messageType == _MessageType.RESPONSE && _connectionClose);
+      dataEnd(_messageType == _MessageType.RESPONSE && !_persistentConnection);
     }
   }
 
   _reset() {
     _state = _State.START;
     _messageType = _MessageType.UNDETERMINED;
     _headerField = new StringBuffer();
     _headerValue = new StringBuffer();
     _method_or_status_code = new StringBuffer();
     _uri_or_reason_phrase = new StringBuffer();
 
+    _httpVersion = _HttpVersion.UNDETERMINED;
     _contentLength = -1;
-    _keepAlive = false;
-    _connectionClose = false;
+    _persistentConnection = false;
     _connectionUpgrade = false;
     _chunked = false;
 
     _noMessageBody = false;
     _responseToMethod = null;
     _remainingContent = null;
   }
 
   bool _isTokenChar(int byte) {
     return byte > 31 && byte < 128 && _Const.SEPARATORS.indexOf(byte) == -1;
@@ skipping 42 matching lines @@
   }
 
   int _state;
   int _httpVersionIndex;
   int _messageType;
   StringBuffer _method_or_status_code;
   StringBuffer _uri_or_reason_phrase;
   StringBuffer _headerField;
   StringBuffer _headerValue;
 
+  int _httpVersion;
   int _contentLength;
-  bool _keepAlive;
-  bool _connectionClose;
+  bool _persistentConnection;
   bool _connectionUpgrade;
   bool _chunked;
 
   bool _noMessageBody;
   String _responseToMethod;  // Indicates the method used for the request.
   int _remainingContent;
 
   // Callbacks.
   Function requestStart;
   Function responseStart;
   Function headerReceived;
   Function headersComplete;
   Function dataReceived;
   Function dataEnd;
   Function error;
 }
 
 
 class HttpParserException implements Exception {
   const HttpParserException([String this.message = ""]);
   String toString() => "HttpParserException: $message";
   final String message;
 }