Change the message body handling in the HTTP parser

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/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];
 }
 
 
 // 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 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 CHUNK_SIZE_STARTING_CR = 16;
   static final int CHUNK_SIZE_STARTING_LF = 17;
   static final int CHUNK_SIZE = 18;
-  static final int CHUNK_SIZE_ENDING = 19;
-  static final int CHUNKED_BODY_DONE_CR = 20;
-  static final int CHUNKED_BODY_DONE_LF = 21;
-  static final int BODY = 22;
+  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;
 }
 
 
+// States of the HTTP parser state machine.
+class _MessageType {
+  static final int UNDETERMINED = 0;
+  static final int REQUEST = 1;
+  static final int RESPONSE = 0;
+}
+
+
 /**
  * HTTP parser which parses the HTTP stream as data is supplied
  * through the writeList method. As the data is parsed the events
  *   RequestStart
+ *   ResponseStart
  *   UriReceived
  *   HeaderReceived
  *   HeadersComplete
  *   DataReceived
  *   DataEnd
  * are generated.
  * Currently only HTTP requests with Content-Length header are supported.
  */
 class _HttpParser {
   _HttpParser() {
@@ skipping 67 matching lines @@
             _expect(byte, _Const.HTTP11[_httpVersionIndex]);
             _httpVersionIndex++;
           } 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());
           }
           _method_or_status_code.clear();
           _uri_or_reason_phrase.clear();
           _state = _State.HEADER_START;
           break;
 
         case _State.RESPONSE_LINE_STATUS_CODE:
@@ skipping 12 matching lines @@
         case _State.RESPONSE_LINE_REASON_PHRASE:
           if (byte == _CharCode.CR) {
             _state = _State.RESPONSE_LINE_ENDING;
           } else {
             _uri_or_reason_phrase.addCharCode(byte);
           }
           break;
 
         case _State.RESPONSE_LINE_ENDING:
           _expect(byte, _CharCode.LF);
-          // TODO(sgjesse): Check for valid status code.
+          _messageType == _MessageType.RESPONSE;
           if (responseStart != null) {
-            responseStart(Math.parseInt(_method_or_status_code.toString()),
-                          _uri_or_reason_phrase.toString());
+            int statusCode = Math.parseInt(_method_or_status_code.toString());
+            if (statusCode < 100 || statusCode > 599) {
+              if (error != null) error("Invalid response status code");
+              _failure = true;
+            } else {
+              // Check whether this response will never have a body.
+              _noMessageBody =
+                  statusCode <= 199 || statusCode == 204 || statusCode == 304;
+              responseStart(statusCode, _uri_or_reason_phrase.toString());
+            }
           }
           _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 63 matching lines @@
               _headerField.addCharCode(_toLowerCase(byte));
               _state = _State.HEADER_FIELD;
             }
           }
           break;
 
         case _State.HEADER_ENDING:
           _expect(byte, _CharCode.LF);
           if (headersComplete != null) headersComplete();
 
-          // If there is no data get ready to process the next request.
           if (_chunked) {
             _state = _State.CHUNK_SIZE;
             _remainingContent = 0;
-          } else if (_contentLength == 0) {
+          } else if (_contentLength == 0 ||
+                     (_messageType == _MessageType.REQUEST &&
+                      _contentLength == -1) ||
+                     (_messageType == _MessageType.RESPONSE &&
+                      (_noMessageBody || _responseToMethod == "HEAD"))) {
+            // If there is no message body get ready to process the
+            // next request.
             if (dataEnd != null) dataEnd();
             _state = _State.START;
           } else if (_contentLength > 0) {
             _remainingContent = _contentLength;
             _state = _State.BODY;
           } else {
             // Neither chunked nor content length. End of body
             // indicated by close.
             _state = _State.BODY;
           }
           break;
 
         case _State.CHUNK_SIZE_STARTING_CR:
           _expect(byte, _CharCode.CR);
           _state = _State.CHUNK_SIZE_STARTING_LF;
           break;
 
         case _State.CHUNK_SIZE_STARTING_LF:
           _expect(byte, _CharCode.LF);
           _state = _State.CHUNK_SIZE;
           break;
 
         case _State.CHUNK_SIZE:
           if (byte == _CharCode.CR) {
             _state = _State.CHUNK_SIZE_ENDING;
+          } else if (byte == _CharCode.SEMI_COLON) {
+            _state = _State.CHUNK_SIZE_EXTENSION;
           } else {
             int value = _expectHexDigit(byte);
             _remainingContent = _remainingContent * 16 + value;
           }
           break;
 
+        case _State.CHUNK_SIZE_EXTENSION:
+          if (byte == _CharCode.CR) {
+            _state = _State.CHUNK_SIZE_ENDING;
+          }
+          break;
+
         case _State.CHUNK_SIZE_ENDING:
           _expect(byte, _CharCode.LF);
           if (_remainingContent > 0) {
             _state = _State.BODY;
           } else {
             _state = _State.CHUNKED_BODY_DONE_CR;
           }
           break;
 
         case _State.CHUNKED_BODY_DONE_CR:
@@ skipping 53 matching lines @@
   int connectionClosed() {
     if (!_chunked && _contentLength == -1) {
       if (dataEnd != null) dataEnd();
     } else {
       if (error != null) {
         error("Connection closed before full body was received");
       }
     }
   }
 
+  int get messageType() => _messageType;
   int get contentLength() => _contentLength;
   bool get keepAlive() => _keepAlive;
 
+  void set responseToMethod(String method) => _responseToMethod = method;
+
   _reset() {
     _state = _State.START;
     _failure = false;
+    _messageType = _MessageType.UNDETERMINED;
     _headerField = new StringBuffer();
     _headerValue = new StringBuffer();
     _method_or_status_code = new StringBuffer();
     _uri_or_reason_phrase = new StringBuffer();
 
     _contentLength = -1;
     _keepAlive = false;
     _chunked = false;
+
+    _noMessageBody = false;
+    _responseToMethod = null;
     _remainingContent = null;
   }
 
   int _toLowerCase(int byte) {
     final int aCode = "A".charCodeAt(0);
     final int zCode = "Z".charCodeAt(0);
     final int delta = "a".charCodeAt(0) - aCode;
     return (aCode <= byte && byte <= zCode) ? byte + delta : byte;
   }
 
@@ skipping 13 matching lines @@
       return byte - 0x61 + 10;  // a - f
     } else {
       _failure = true;
       return 0;
     }
   }
 
   int _state;
   bool _failure;
   int _httpVersionIndex;
+  int _messageType;
   StringBuffer _method_or_status_code;
   StringBuffer _uri_or_reason_phrase;
   StringBuffer _headerField;
   StringBuffer _headerValue;
 
   int _contentLength;
   bool _keepAlive;
   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;
 }