Add basic handling to connection upgrade to 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];
@@ skipping 43 matching lines @@
 
   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 CLOSED = 24;
-  static final int FAILURE = 25;
+  static final int UPGRADED = 25;
+  static final int FAILURE = 26;
 
   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 10 matching lines @@
  *   [:headerReceived:]
  *   [:headersComplete:]
  *   [:dataReceived:]
  *   [:dataEnd:]
  *   [: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.
  *
- * For keep-alive connections where the underlying connection stays
- * open the [:connectionClosed:] method would not be called.
+ * 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 call to
+ * [:writeList:] causing the upgrade will return with the number of
+ * bytes parsed as HTTP. Any unparsed bytes is part of the protocol
+ * the connection is upgrading to and should be handled according to
+ * that protocol.
  */
 class _HttpParser {
   _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;
     try {
       if (_state == _State.CLOSED) {
         throw new HttpParserException("Data on closed connection");
       }
-      while ((index < lastIndex) && _state != _State.FAILURE) {
+      if (_state == _State.UPGRADED) {
+        throw new HttpParserException("Data on upgraded connection");
+      }
+      while ((index < lastIndex) && _state != _State.FAILURE && _state != _State.UPGRADED) {
         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.
               if (_Const.SEPARATORS_AND_CR_LF.indexOf(byte) != -1) {
@@ skipping 163 matching lines @@
             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") {
-                if (headerValue == "keep-alive") {
-                  _keepAlive = true;
-                } else if (headerValue == "close") {
-                  _connectionClose = true;
+                List<String> tokens = _tokenizeFieldValue(headerValue);
+                for (int i = 0; i < tokens.length; i++) {
+                  String token = tokens[i].toLowerCase();
+                  if (token == "keep-alive") {
+                    _keepAlive = true;
+                  } else if (token == "close") {
+                    _connectionClose = true;
+                  } else if (token == "upgrade") {
+                    _connectionUpgrade = 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.
-              _bodyEnd();
-              _reset();
-            } else if (_contentLength > 0) {
-              _remainingContent = _contentLength;
-              _state = _State.BODY;
+            if (_connectionUpgrade) {
+              _state = _State.UPGRADED;
+              if (headersComplete != null) headersComplete();
             } else {
-              // Neither chunked nor content length. End of body
-              // indicated by close.
-              _state = _State.BODY;
+              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.
+                _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;
 
           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 126 matching lines @@
         error(e);
         return;
       }
       throw e;
     }
   }
 
   int get messageType() => _messageType;
   int get contentLength() => _contentLength;
   bool get keepAlive() => _keepAlive;
+  bool get upgrade() => _connectionUpgrade && _state == _State.UPGRADED;
 
   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;
+    _connectionUpgrade = false;
     _chunked = false;
 
     _noMessageBody = false;
     _responseToMethod = null;
     _remainingContent = null;
   }
 
   bool _isTokenChar(int byte) {
     return byte > 31 && byte < 128 && _Const.SEPARATORS.indexOf(byte) == -1;
   }
 
+  List<String> _tokenizeFieldValue(String headerValue) {
+    List<String> tokens = new List<String>();
+    int start = 0;
+    int index = 0;
+    while (index < headerValue.length) {
+      if (headerValue[index] == ",") {
+        tokens.add(headerValue.substring(start, index));
+        start = index + 1;
+      } else if (headerValue[index] == " " || headerValue[index] == "\t") {
+        start++;
+      }
+      index++;
+    }
+    tokens.add(headerValue.substring(start, index));
+    return tokens;
+  }
+
   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) {
       throw new HttpParserException("Failed to parse HTTP");
@@ skipping 16 matching lines @@
   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 _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;
 }
 
 
 class HttpParserException implements Exception {
   const HttpParserException([String this.message = ""]);
   String toString() => "HttpParserException: $message";
   final String message;
 }