Be more lean when parsing HTTP headers

sdk/lib/io/http_parser.dart

 // Copyright (c) 2013, 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.
 
 part of dart.io;
 
 // Global constants.
 class _Const {
   // Bytes for "HTTP".
   static const HTTP = const [72, 84, 84, 80];
@@ skipping 316 matching lines @@
 
   void _parse() {
     try {
       _doParse();
     } catch (e, s) {
       _state = _State.FAILURE;
       _reportError(e, s);
     }
   }
 
+  // Process end of headers. Returns true if the parser should stop
+  // parsing and return. This will be in case of either an upgrade
+  // request or a request or response with an empty body.
+  bool _headersEnd() {
+    _headers._mutable = false;
+
+    _transferLength = _headers.contentLength;
+    // Ignore the Content-Length header if Transfer-Encoding
+    // is chunked (RFC 2616 section 4.4)
+    if (_chunked) _transferLength = -1;
+
+    // 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 &&
+        _transferLength < 0 &&
+       _chunked == false) {
+       _transferLength = 0;
+    }
+    if (_connectionUpgrade) {
+      _state = _State.UPGRADED;
+      _transferLength = 0;
+    }
+    _createIncoming(_transferLength);
+    if (_requestParser) {
+      _incoming.method =
+          new String.fromCharCodes(_method);
+      _incoming.uri =
+          Uri.parse(
+              new String.fromCharCodes(_uri_or_reason_phrase));
+    } else {
+      _incoming.statusCode = _statusCode;
+      _incoming.reasonPhrase =
+          new String.fromCharCodes(_uri_or_reason_phrase);
+    }
+    _method.clear();
+    _uri_or_reason_phrase.clear();
+    if (_connectionUpgrade) {
+      _incoming.upgraded = true;
+      _parserCalled = false;
+      var tmp = _incoming;
+      _closeIncoming();
+      _controller.add(tmp);
+      return true;
+    }
+    if (_transferLength == 0 ||
+        (_messageType == _MessageType.RESPONSE && _noMessageBody)) {
+      _reset();
+      var tmp = _incoming;
+      _closeIncoming();
+      _controller.add(tmp);
+      return false;
+    } else if (_chunked) {
+      _state = _State.CHUNK_SIZE;
+      _remainingContent = 0;
+    } else if (_transferLength > 0) {
+      _remainingContent = _transferLength;
+      _state = _State.BODY;
+    } else {
+      // Neither chunked nor content length. End of body
+      // indicated by close.
+      _state = _State.BODY;
+    }
+    _parserCalled = false;
+    _controller.add(_incoming);
+    return true;
+  }
+
   // 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 ]
   void _doParse() {
@@ skipping 133 matching lines @@
               _httpVersionIndex++;
             } else if (byte == _CharCode.ZERO) {
               // HTTP/1.0 parsed.
               _httpVersion = _HttpVersion.HTTP10;
               _persistentConnection = false;
               _httpVersionIndex++;
             } else {
               throw new HttpException("Invalid response line");
             }
           } else {
-            _expect(byte, _CharCode.CR);
-            _state = _State.REQUEST_LINE_ENDING;
+            if (byte == _CharCode.CR) {
+              _state = _State.REQUEST_LINE_ENDING;
+            } else {
+              _expect(byte, _CharCode.LF);
+              _messageType = _MessageType.REQUEST;
+              _state = _State.HEADER_START;
+            }
           }
           break;
 
         case _State.REQUEST_LINE_ENDING:
           _expect(byte, _CharCode.LF);
           _messageType = _MessageType.REQUEST;
           _state = _State.HEADER_START;
           break;
 
         case _State.RESPONSE_LINE_STATUS_CODE:
@@ skipping 36 matching lines @@
               _noMessageBody = true;
             }
           }
           _state = _State.HEADER_START;
           break;
 
         case _State.HEADER_START:
           _headers = new _HttpHeaders(version);
           if (byte == _CharCode.CR) {
             _state = _State.HEADER_ENDING;
+          } else if (byte == _CharCode.LF) {
+            if (_headersEnd()) {
+              return;
+            } else {
+              break;
+            }
           } else {
             // Start of new header field.
             _headerField.add(_toLowerCaseByte(byte));
             _state = _State.HEADER_FIELD;
           }
           break;
 
         case _State.HEADER_FIELD:
           if (byte == _CharCode.COLON) {
             _state = _State.HEADER_VALUE_START;
           } else {
             if (!_isTokenChar(byte)) {
               throw new HttpException("Invalid header field name");
             }
             _headerField.add(_toLowerCaseByte(byte));
           }
           break;
 
         case _State.HEADER_VALUE_START:
           if (byte == _CharCode.CR) {
             _state = _State.HEADER_VALUE_FOLDING_OR_ENDING;
+          } else if (byte == _CharCode.LF) {
+            _state = _State.HEADER_VALUE_FOLD_OR_END;
           } else if (byte != _CharCode.SP && byte != _CharCode.HT) {
             // Start of new header value.
             _headerValue.add(byte);
             _state = _State.HEADER_VALUE;
           }
           break;
 
         case _State.HEADER_VALUE:
           if (byte == _CharCode.CR) {
             _state = _State.HEADER_VALUE_FOLDING_OR_ENDING;
+          } else if (byte == _CharCode.LF) {
+            _state = _State.HEADER_VALUE_FOLD_OR_END;
           } else {
             _headerValue.add(byte);
           }
           break;
 
         case _State.HEADER_VALUE_FOLDING_OR_ENDING:
           _expect(byte, _CharCode.LF);
           _state = _State.HEADER_VALUE_FOLD_OR_END;
           break;
 
@@ skipping 17 matching lines @@
                 _headers._add(headerField, tokens[i]);
               }
             } else {
               _headers._add(headerField, headerValue);
             }
             _headerField.clear();
             _headerValue.clear();
 
             if (byte == _CharCode.CR) {
               _state = _State.HEADER_ENDING;
+            } else if (byte == _CharCode.LF) {
+              if (_headersEnd()) {
+                return;
+              } else {
+                break;
+              }
             } else {
               // Start of new header field.
               _headerField.add(_toLowerCaseByte(byte));
               _state = _State.HEADER_FIELD;
             }
           }
           break;
 
         case _State.HEADER_ENDING:
           _expect(byte, _CharCode.LF);
-          _headers._mutable = false;
-
-          _transferLength = _headers.contentLength;
-          // Ignore the Content-Length header if Transfer-Encoding
-          // is chunked (RFC 2616 section 4.4)
-          if (_chunked) _transferLength = -1;
-
-          // 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 &&
-              _transferLength < 0 &&
-              _chunked == false) {
-            _transferLength = 0;
+          if (_headersEnd()) {
+            return;
+          } else {
+            break;
           }
-          if (_connectionUpgrade) {
-            _state = _State.UPGRADED;
-            _transferLength = 0;
-          }
-          _createIncoming(_transferLength);
-          if (_requestParser) {
-            _incoming.method =
-                new String.fromCharCodes(_method);
-            _incoming.uri =
-                Uri.parse(
-                    new String.fromCharCodes(_uri_or_reason_phrase));
-          } else {
-            _incoming.statusCode = _statusCode;
-            _incoming.reasonPhrase =
-                new String.fromCharCodes(_uri_or_reason_phrase);
-          }
-          _method.clear();
-          _uri_or_reason_phrase.clear();
-          if (_connectionUpgrade) {
-            _incoming.upgraded = true;
-            _parserCalled = false;
-            var tmp = _incoming;
-            _closeIncoming();
-            _controller.add(tmp);
-            return;
-          }
-          if (_transferLength == 0 ||
-              (_messageType == _MessageType.RESPONSE && _noMessageBody)) {
-            _reset();
-            var tmp = _incoming;
-            _closeIncoming();
-            _controller.add(tmp);
-            break;
-          } else if (_chunked) {
-            _state = _State.CHUNK_SIZE;
-            _remainingContent = 0;
-          } else if (_transferLength > 0) {
-            _remainingContent = _transferLength;
-            _state = _State.BODY;
-          } else {
-            // Neither chunked nor content length. End of body
-            // indicated by close.
-            _state = _State.BODY;
-          }
-          _parserCalled = false;
-          _controller.add(_incoming);
           return;
 
         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;
@@ skipping 338 matching lines @@
     }
   }
 
   void _reportError(error, [stackTrace]) {
     if (_socketSubscription != null) _socketSubscription.cancel();
     _state = _State.FAILURE;
     _controller.addError(error, stackTrace);
     _controller.close();
   }
 }