Support parsing HTTP responses where the body length is not known

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 46 matching lines @@
  *   RequestStart
  *   UriReceived
  *   HeaderReceived
  *   HeadersComplete
  *   DataReceived
  *   DataEnd
  * are generated.
  * Currently only HTTP requests with Content-Length header are supported.
  */
 class _HttpParser {
-  _HttpParser()
-      : _state = _State.START,
-        _failure = false,
-        _headerField = new StringBuffer(),
-        _headerValue = new StringBuffer(),
-        _method_or_status_code = new StringBuffer(),
-        _uri_or_reason_phrase = new StringBuffer();
+  _HttpParser() {
+    _reset();
+  }
 
   // From RFC 2616.
   // generic-message = start-line
   //                   *(message-header CRLF)
   //                   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;
     while ((index < lastIndex) && !_failure) {
       int byte = buffer[index];
       switch (_state) {
         case _State.START:
-          _contentLength = 0;
-          _keepAlive = false;
-          _chunked = false;
-
           if (byte == _Const.HTTP11[0]) {
             // Start parsing HTTP method.
             _httpVersionIndex = 1;
             _state = _State.METHOD_OR_HTTP_VERSION;
           } else {
             // Start parsing method.
             _method_or_status_code.addCharCode(byte);
             _state = _State.REQUEST_LINE_METHOD;
           }
           break;
@@ skipping 52 matching lines @@
           _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) {
             _state = _State.RESPONSE_LINE_REASON_PHRASE;
           } else {
             if (byte < 0x30 && 0x39 < byte) {
+              if (error != null) error("Failed to parse HTTP");
               _failure = true;
             } else {
               _method_or_status_code.addCharCode(byte);
             }
           }
           break;
 
         case _State.RESPONSE_LINE_REASON_PHRASE:
           if (byte == _CharCode.CR) {
             _state = _State.RESPONSE_LINE_ENDING;
@@ skipping 95 matching lines @@
           if (_chunked) {
             _state = _State.CHUNK_SIZE;
             _remainingContent = 0;
           } else if (_contentLength == 0) {
             if (dataEnd != null) dataEnd();
             _state = _State.START;
           } else if (_contentLength > 0) {
             _remainingContent = _contentLength;
             _state = _State.BODY;
           } else {
-            // TODO(sgjesse): Error handling.
+            // 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);
@@ skipping 19 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();
-          _state = _State.START;
+          _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 (dataAvailable <= _remainingContent) {
+          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);
-          _remainingContent -= data.length;
+          if (_remainingContent != null) {
+            _remainingContent -= data.length;
+          }
           index += data.length;
-          if (_remainingContent == 0) {
+          if (_remainingContent != null && _remainingContent == 0) {

[Anders Johnsen, 2012/03/15 11:24:04]

== 0 should be sufficient.

[Søren Gjesse, 2012/03/19 11:31:48]

Done.

             if (!_chunked) {
               if (dataEnd != null) dataEnd();
-              _state = _State.START;
+              _reset();
             } else {
               _state = _State.CHUNK_SIZE_STARTING_CR;
             }
           }
 
           // Hack - as we always do index++ below.
           index--;
           break;
 
         default:
           // Should be unreachable.
           assert(false);
       }
 
       // Move to the next byte.
       index++;
     }
 
     // Return the number of bytes parsed.
     return index - offset;
   }
 
+  int connectionClosed() {
+    if (!_chunked && _contentLength == -1) {
+      if (dataEnd != null) dataEnd();
+    } else {
+      if (error != null) {
+        error("Connection closed before full body was received");
+      }
+    }
+  }
+
   int get contentLength() => _contentLength;
   bool get keepAlive() => _keepAlive;
 
+  _reset() {
+    _state = _State.START;
+    _failure = false;
+    _headerField = new StringBuffer();
+    _headerValue = new StringBuffer();
+    _method_or_status_code = new StringBuffer();
+    _uri_or_reason_phrase = new StringBuffer();
+
+    _contentLength = -1;
+    _keepAlive = false;
+    _chunked = false;
+    _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;
   }
 
   int _expect(int val1, int val2) {
     if (val1 != val2) {
+      if (error != null) error("Failed to parse HTTP");
       _failure = true;
     }
   }
 
   int _expectHexDigit(int byte) {
     if (0x30 <= byte && byte <= 0x39) {
       return byte - 0x30;  // 0 - 9
     } else if (0x41 <= byte && byte <= 0x46) {
       return byte - 0x41 + 10;  // A - F
     } else if (0x61 <= byte && byte <= 0x66) {
@@ skipping 18 matching lines @@
 
   int _remainingContent;
 
   // Callbacks.
   Function requestStart;
   Function responseStart;
   Function headerReceived;
   Function headersComplete;
   Function dataReceived;
   Function dataEnd;
+  Function error;
 }