Refactoring of the HTTP library

sdk/lib/io/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 const HTTP = const [72, 84, 84, 80];
   // Bytes for "HTTP/1.".
   static const HTTP1DOT = const [72, 84, 84, 80, 47, 49, 46];
@@ skipping 85 matching lines @@
  * HTTP parser which parses the HTTP stream as data is supplied
  * through the [:writeList:] and [:connectionClosed:] methods. As the
  * data is parsed the following callbacks are called:
  *
  *   [:requestStart:]
  *   [:responseStart:]
  *   [:headerReceived:]
  *   [:headersComplete:]
  *   [:dataReceived:]
  *   [:dataEnd:]
+ *   [:closed:]
  *   [:error:]
  *
  * If an HTTP parser error occours it is possible to get an exception
  * thrown from the [:writeList:] and [:connectionClosed:] methods if
  * the error callback is not set.
  *
  * The connection upgrades (e.g. switching from HTTP/1.1 to the
  * WebSocket protocol) is handled in a special way. If connection
  * upgrade is specified in the headers, then on the callback to
  * [:headersComplete:] the [:upgrade:] property on the [:HttpParser:]
  * object will be [:true:] indicating that from now on the protocol is
  * not HTTP anymore and no more callbacks will happen, that is
  * [:dataReceived:] and [:dataEnd:] are not called in this case as
  * there is no more HTTP data. After the upgrade the method
  * [:readUnparsedData:] can be used to read any remaining bytes in the
  * HTTP parser which are part of the protocol the connection is
  * upgrading to. These bytes cannot be processed by the HTTP parser
  * and should be handled according to whatever protocol is being
  * upgraded to.
  */
 class _HttpParser {
-  _HttpParser() {
+  _HttpParser.requestParser() {
+    _requestParser = true;
+    _reset();
+  }
+  _HttpParser.responseParser() {
+    _requestParser = false;
     _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
@@ skipping 20 matching lines @@
             if (byte == _Const.HTTP[0]) {
               // Start parsing method or HTTP version.
               _httpVersionIndex = 1;
               _state = _State.METHOD_OR_RESPONSE_HTTP_VERSION;
             } else {
               // Start parsing method.
               if (!_isTokenChar(byte)) {
                 throw new HttpParserException("Invalid request method");
               }
               _method_or_status_code.addCharCode(byte);
+              if (!_requestParser) {
+                throw new HttpParserException("Invalid response line");
+              }
               _state = _State.REQUEST_LINE_METHOD;
             }
             break;
 
           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.HTTP.length &&
                        byte == _CharCode.SLASH) {
               // HTTP/ parsed. As method is a token this cannot be a
               // method anymore.
               _httpVersionIndex++;
+              if (_requestParser) {
+                throw new HttpParserException("Invalid request line");
+              }
               _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]);
               }
               if (byte == _CharCode.SP) {
                 _state = _State.REQUEST_LINE_URI;
               } else {
                 _method_or_status_code.addCharCode(byte);
                 _httpVersion = _HttpVersion.UNDETERMINED;
+                if (!_requestParser) {
+                  throw new HttpParserException("Invalid response line");
+                }
                 _state = _State.REQUEST_LINE_METHOD;
               }
             }
             break;
 
           case _State.RESPONSE_HTTP_VERSION:
             if (_httpVersionIndex < _Const.HTTP1DOT.length) {
               // Continue parsing HTTP version.
               _expect(byte, _Const.HTTP1DOT[_httpVersionIndex]);
               _httpVersionIndex++;
@@ skipping 64 matching lines @@
               }
             } 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(),
-                           version);
-            }
+            requestStart(_method_or_status_code.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 25 matching lines @@
             _expect(byte, _CharCode.LF);
             _messageType == _MessageType.RESPONSE;
             int statusCode = 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(),
-                            version);
-            }
+            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 {
               // Start of new header field.
@@ skipping 51 matching lines @@
                 List<String> tokens = _tokenizeFieldValue(headerValue);
                 for (int i = 0; i < tokens.length; i++) {
                   String token = tokens[i].toLowerCase();
                   if (token == "keep-alive") {
                     _persistentConnection = true;
                   } else if (token == "close") {
                     _persistentConnection = false;
                   } else if (token == "upgrade") {
                     _connectionUpgrade = true;
                   }
-                  if (headerReceived != null) {
-                    headerReceived(headerField, token);
-                  }
+                  headerReceived(headerField, token);
                 }
                 reportHeader = false;
               } else if (headerField == "transfer-encoding" &&
                          headerValue.toLowerCase() == "chunked") {
                 // Ignore the Content-Length header if Transfer-Encoding
                 // is chunked (RFC 2616 section 4.4)
                 _chunked = true;
                 _contentLength = -1;
               }
-              if (reportHeader && headerReceived != null) {
+              if (reportHeader) {
                 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 a request message has neither Content-Length nor
             // Transfer-Encoding the message must not have a body (RFC
             // 2616 section 4.3).
             if (_messageType == _MessageType.REQUEST &&
                 _contentLength < 0 &&
                 _chunked == false) {
               _contentLength = 0;
             }
             if (_connectionUpgrade) {
               _state = _State.UPGRADED;
-              if (headersComplete != null) headersComplete();
+              headersComplete();
             } else {
-              if (headersComplete != null) headersComplete();
+              headersComplete();
               if (_chunked) {
                 _state = _State.CHUNK_SIZE;
                 _remainingContent = 0;
               } else if (_contentLength == 0 ||
                          (_messageType == _MessageType.RESPONSE &&
                           (_noMessageBody || _responseToMethod == "HEAD"))) {
                 // If there is no message body get ready to process the
                 // next request.
                 _bodyEnd();
                 _reset();
@@ skipping 62 matching lines @@
             List<int> data;
             if (_remainingContent == null ||
                 dataAvailable <= _remainingContent) {
               data = new Uint8List(dataAvailable);
               data.setRange(0, dataAvailable, _buffer, _index);
             } else {
               data = new Uint8List(_remainingContent);
               data.setRange(0, _remainingContent, _buffer, _index);
             }
 
-            if (dataReceived != null) dataReceived(data);
+            dataReceived(data);
             if (_remainingContent != null) {
               _remainingContent -= data.length;
             }
             _index += data.length;
             if (_remainingContent == 0) {
               if (!_chunked) {
                 _bodyEnd();
                 _reset();
               } else {
                 _state = _State.CHUNK_SIZE_STARTING_CR;
               }
             }
             break;
 
           case _State.FAILURE:
             // Should be unreachable.
             assert(false);
             break;
 
           default:
             // Should be unreachable.
             assert(false);
             break;
         }
       }
     } catch (e) {
-      // Report the error through the error callback if any. Otherwise
-      // throw the error.
-      if (error != null) {
-        error(e);
-        _state = _State.FAILURE;
-      } else {
-        throw e;
-      }
+      _state = _State.FAILURE;
+      error(e);
     }
 
     // If all data is parsed or not needed due to failure there is no
     // need to hold on to the buffer.
     if (_state != _State.UPGRADED) _releaseBuffer();
   }
 
-  void writeList(List<int> buffer, int offset, int count) {
+  void streamData(List<int> buffer) {
     assert(_buffer == null);
     _buffer = buffer;
-    _index = offset;
-    _lastIndex = offset + count;
+    _index = 0;
+    _lastIndex = buffer.length;
     _parse();
   }
 
-  void connectionClosed() {
+  void streamDone() {
+    // If the connection is idle the HTTP stream is closed.
+    if (_state == _State.START) {
+      if (_requestParser) {
+        closed();
+      } else {
+        error(
+            new HttpParserException(
+                "Connection closed before full header was received"));
+      }
+      return;
+    }
+
     if (_state < _State.FIRST_BODY_STATE) {
       _state = _State.FAILURE;
       // 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);
-        return;
-      }
-      throw e;
+      error(
+          new HttpParserException(
+              "Connection closed before full header was received"));
+      return;
     }
 
     if (!_chunked && _contentLength == -1) {
-      if (_state != _State.START) {
-        if (dataEnd != null) dataEnd(true);
-      }
+      dataEnd(true);
       _state = _State.CLOSED;
+      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);
-        return;
-      }
-      throw e;
+      error(
+          new HttpParserException(
+              "Connection closed before full body was received"));
     }
   }
 
+  void streamError(e) {
+    // Don't report errors when HTTP parser is in idle state. Clients
+    // can close the connection and cause a connection reset by peer
+    // error which is OK.
+    if (_state == _State.START) {
+      closed();
+      return;
+    }
+    error(e);
+  }
+
   String get version {
     switch (_httpVersion) {
       case _HttpVersion.HTTP10:
         return "1.0";
       case _HttpVersion.HTTP11:
         return "1.1";
     }
     return null;
   }
 
   int get messageType => _messageType;
   int get contentLength => _contentLength;
   bool get upgrade => _connectionUpgrade && _state == _State.UPGRADED;
   bool get persistentConnection => _persistentConnection;
 
   void set responseToMethod(String method) { _responseToMethod = method; }
 
-  bool get isIdle => _state == _State.START;
-
   List<int> readUnparsedData() {
     if (_buffer == null) return [];
     if (_index == _lastIndex) return [];
     var result = _buffer.getRange(_index, _lastIndex - _index);
     _releaseBuffer();
     return result;
   }
 
   void _bodyEnd() {
-    if (dataEnd != null) {
-      dataEnd(_messageType == _MessageType.RESPONSE && !_persistentConnection);
-    }
+    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();
 
@@ skipping 58 matching lines @@
     } else {
       throw new HttpParserException("Failed to parse HTTP");
     }
   }
 
   // The data that is currently being parsed.
   List<int> _buffer;
   int _index;
   int _lastIndex;
 
+  bool _requestParser;
   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 _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;
+  Function closed;
 }
 
 
 class HttpParserException implements Exception {
   const HttpParserException([String this.message = ""]);
   String toString() => "HttpParserException: $message";
   final String message;
 }