Refactor the close and error handling of HTTP connections

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];
@@ skipping 33 matching lines @@
   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_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 FAILURE = 24;
+  static final int CLOSED = 24;
+  static final int FAILURE = 25;
+
+  static final int FIRST_BODY_STATE = CHUNK_SIZE_STARTING_CR;
 }
 
 
 // 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 29 matching lines @@
   //                   CRLF
   //                   [ message-body ]
   // start-line      = Request-Line | Status-Line
   // Request-Line    = Method SP Request-URI SP HTTP-Version CRLF
   // Status-Line     = HTTP-Version SP Status-Code SP Reason-Phrase CRLF
   // message-header  = field-name ":" [ field-value ]
   int writeList(List<int> buffer, int offset, int count) {
     int index = offset;
     int lastIndex = offset + count;
     try {
+      if (_state == _State.CLOSED) {
+        throw new HttpParserException("Data on closed connection");
+      }
       while ((index < lastIndex) && _state != _State.FAILURE) {
         int byte = buffer[index];
         switch (_state) {
           case _State.START:
             if (byte == _Const.HTTP11[0]) {
               // Start parsing HTTP method.
               _httpVersionIndex = 1;
               _state = _State.METHOD_OR_HTTP_VERSION;
             } else {
               // Start parsing method.
@@ skipping 158 matching lines @@
           case _State.HEADER_VALUE_FOLD_OR_END:
             if (byte == _CharCode.SP || byte == _CharCode.HT) {
               _state = _State.HEADER_VALUE_START;
             } else {
               String headerField = _headerField.toString();
               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" &&
-                         headerValue == "keep-alive") {
-                _keepAlive = true;
+              } else if (headerField == "connection") {
+                if (headerValue == "keep-alive") {
+                  _keepAlive = true;
+                } else if (headerValue == "close") {
+                  _connectionClose = true;
+                }
               } else if (headerField == "transfer-encoding" &&
                          headerValue == "chunked") {
                 _chunked = true;
                 _contentLength = -1;
               }
               if (headerReceived != null) {
                 headerReceived(headerField, headerValue);
               }
               _headerField.clear();
               _headerValue.clear();
 
               if (byte == _CharCode.CR) {
                 _state = _State.HEADER_ENDING;
               } else {
                 // Start of new header field.
                 _headerField.addCharCode(_toLowerCase(byte));
                 _state = _State.HEADER_FIELD;
               }
             }
             break;
 
           case _State.HEADER_ENDING:
             _expect(byte, _CharCode.LF);
             if (headersComplete != null) headersComplete();
-
             if (_chunked) {
               _state = _State.CHUNK_SIZE;
               _remainingContent = 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;
+              _bodyEnd();
+              _reset();
             } 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;
 
@@ skipping 33 matching lines @@
             }
             break;
 
           case _State.CHUNKED_BODY_DONE_CR:
             _expect(byte, _CharCode.CR);
             _state = _State.CHUNKED_BODY_DONE_LF;
             break;
 
           case _State.CHUNKED_BODY_DONE_LF:
             _expect(byte, _CharCode.LF);
-            if (dataEnd != null) dataEnd();
+            _bodyEnd();
             _reset();
             break;
 
           case _State.BODY:
             // The body is not handled one byte at the time but in blocks.
             int dataAvailable = lastIndex - index;
             ByteArray data;
             if (_remainingContent == null ||
                 dataAvailable <= _remainingContent) {
               data = new ByteArray(dataAvailable);
               data.setRange(0, dataAvailable, buffer, index);
             } else {
               data = new ByteArray(_remainingContent);
               data.setRange(0, _remainingContent, buffer, index);
             }
 
             if (dataReceived != null) dataReceived(data);
             if (_remainingContent != null) {
               _remainingContent -= data.length;
             }
             index += data.length;
             if (_remainingContent == 0) {
               if (!_chunked) {
-                if (dataEnd != null) dataEnd();
+                _bodyEnd();
                 _reset();
               } else {
                 _state = _State.CHUNK_SIZE_STARTING_CR;
               }
             }
 
             // Hack - as we always do index++ below.
             index--;
             break;
 
@@ skipping 20 matching lines @@
       } else {
         throw e;
       }
     }
 
     // Return the number of bytes parsed.
     return index - offset;
   }
 
   int connectionClosed() {
-    if (!_chunked && _contentLength == -1) {
-      if (dataEnd != null) dataEnd();
-    } else {
+    if (_state < _State.FIRST_BODY_STATE) {
       // Report the error through the error callback if any. Otherwise
       // throw the error.
       var e = new HttpParserException(
+          "Connection closed before full header was received");
+      if (error != null) {
+        error(e);
+      } else {
+        throw e;
+      }
+    }
+
+    if (!_chunked && _contentLength == -1) {
+      if (_state != _State.START) {
+        if (dataEnd != null) dataEnd(true);
+      }
+      _state = _State.CLOSED;
+    } else {
+      _state = _State.FAILURE;
+      // Report the error through the error callback if any. Otherwise
+      // throw the error.
+      var e = new HttpParserException(
           "Connection closed before full body was received");
       if (error != null) {
         error(e);
       } else {
         throw e;
       }
     }
   }
 
   int get messageType() => _messageType;
   int get contentLength() => _contentLength;
   bool get keepAlive() => _keepAlive;
 
   void set responseToMethod(String method) => _responseToMethod = method;
 
+  bool get isIdle() => _state == _State.START;
+
+  void _bodyEnd() {
+    if (dataEnd != null) {
+      dataEnd(_messageType == _MessageType.RESPONSE && _connectionClose);
+    }
+  }
+
   _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();
 
     _contentLength = -1;
     _keepAlive = false;
+    _connectionClose = 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);
@@ skipping 22 matching lines @@
   int _state;
   int _httpVersionIndex;
   int _messageType;
   StringBuffer _method_or_status_code;
   StringBuffer _uri_or_reason_phrase;
   StringBuffer _headerField;
   StringBuffer _headerValue;
 
   int _contentLength;
   bool _keepAlive;
+  bool _connectionClose;
   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;
 }