Add a web socket client

runtime/bin/websocket_impl.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.
 
+final String _webSocketGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+
 class _WebSocketMessageType {
   static final int NONE = 0;
   static final int BINARY = 1;
   static final int TEXT = 2;
   static final int CLOSE = 3;
 }
 
 
 class _WebSocketOpcode {
   static final int CONTINUATION = 0;
@@ skipping 230 matching lines @@
     } catch (var e) {
       _reportError(e);
     }
   }
 
   /**
    * Indicate that the underlying communication channel has been closed.
    */
   void closed() {
     if (_state == START || _state == CLOSED || _state == FAILURE) return;
-    _reportError(new WebSocketException("Protocol error"));
+    _reportError(new WebSocketException("Protocol error $_state"));
     _state = CLOSED;
   }
 
   void _lengthDone() {
     if (_masked) {
       _state = MASK;
       _remainingMaskingKeyBytes = 4;
     } else {
       _remainingPayloadBytes = _len;
       _startPayload();
     }
   }
 
   void _maskDone() {
     _remainingPayloadBytes = _len;
     _startPayload();
   }
 
   void _startPayload() {
     // Check whether there is any payload. If not indicate empty
     // message or close without state and reason.
     if (_remainingPayloadBytes == 0) {
       if (_currentMessageType ==_WebSocketMessageType.CLOSE) {
         if (onClosed != null) onClosed(null, null);
+        _state = CLOSED;
       } else {
         _frameEnd();
       }
     } else {
       _state = PAYLOAD;
     }
   }
 
   void _frameEnd() {
     if (_remainingPayloadBytes != 0) {
@@ skipping 45 matching lines @@
   List<int> _closePayload;
 
   Function onMessageStart;
   Function onMessageData;
   Function onMessageEnd;
   Function onClosed;
   Function onError;
 }
 
 
-class _WebSocketConnection implements WebSocketConnection {
-  _WebSocketConnection(Socket this._socket) {
+class _WebSocketConnectionBase  {
+  void _socketReady(DetachedSocket detached) {
+    assert(detached.socket != null);
+    _socket = detached.socket;
     _WebSocketProtocolProcessor processor = new _WebSocketProtocolProcessor();
     processor.onMessageStart = _onWebSocketMessageStart;
     processor.onMessageData = _onWebSocketMessageData;
     processor.onMessageEnd = _onWebSocketMessageEnd;
     processor.onClosed = _onWebSocketClosed;
     processor.onError = _onWebSocketError;
-
+    if (detached.unparsedData != null) {
+      processor.update(detached.unparsedData, 0, detached.unparsedData.length);
+    }
     _socket.onData = () {
       int available = _socket.available();
       List<int> data = new List<int>(available);
       int read = _socket.readList(data, 0, available);
       processor.update(data, 0, read);
     };
     _socket.onClosed = () {
       processor.closed();
       if (_closeSent) {
         // Got socket close in response to close frame. Don't treat
         // that as an error.
         if (_closeTimer != null) _closeTimer.cancel();
       } else {
-        if (_onError != null) {
-          _onError(new WebSocketException("Unexpected close"));
-        }
+        _reportError(new WebSocketException("Unexpected close"));
       }
       _socket.close();
     };
     _socket.onError = (e) {
-      if (_onError != null) _onError(e);
+      _reportError(e);
       _socket.close();
     };
   }
 
   void set onMessage(void callback(Object message)) {
     _onMessage = callback;
   }
 
   void set onClosed(void callback(int status, String reason)) {
     _onClosed = callback;
   }
 
   void set onError(void callback(e)) {
     _onError = callback;
   }
 
-  send(Object message) {
+  send(message) {
     if (_closeSent) {
       throw new WebSocketException("Connection closed");
     }
     List<int> data;
     int opcode;
     if (message != null) {
       if (message is String) {
         opcode = _WebSocketOpcode.TEXT;
         data = _StringEncoders.encoder(Encoding.UTF_8).encodeString(message);
       } else {
@@ skipping 19 matching lines @@
       if (reason != null) {
         data.addAll(
            _StringEncoders.encoder(Encoding.UTF_8).encodeString(reason));
       }
     }
     _sendFrame(_WebSocketOpcode.CLOSE, data);
 
     if (_closeReceived) {
       // Close the socket when the close frame has been sent - if it
       // does not take too long.
+      _socket.close(true);
       _socket.outputStream.onNoPendingWrites = () {
         if (_closeTimer != null) _closeTimer.cancel();
         _socket.close();
       };
       _closeTimer = new Timer(5000, (t) {
         _socket.close();
       });
     } else {
       // Half close the socket and expect a close frame in response
       // before closing the socket. If a close frame does not arrive
@@ skipping 41 matching lines @@
     if (_closeSent) {
       // Got close frame in response to close frame. Now close the socket.
       if (_closeTimer != null) _closeTimer.cancel();
       _socket.close();
     } else {
       close(status);
     }
   }
 
   _onWebSocketError(e) {
-    if (_onError != null) _onError(e);
+    _reportError(e);
     _socket.close();
   }
 
   _sendFrame(int opcode, List<int> data) {
     bool mask = false;  // Masking not implemented for server.
     int dataLength = data == null ? 0 : data.length;
     // Determine the header size.
     int headerSize = (mask) ? 6 : 2;
     if (dataLength > 65535) {
       headerSize += 8;
@@ skipping 18 matching lines @@
     for (int i = 0; i < lengthBytes; i++) {
       header[index++] = dataLength >> (((lengthBytes - 1) - i) * 8) & 0xFF;
     }
     assert(index == headerSize);
     _socket.outputStream.write(header);
     if (data != null) {
       _socket.outputStream.write(data);
     }
   }
 
+  void _reportError(e) {
+    if (_onError != null) {
+      _onError(e);
+    } else {
+      throw e;
+    }
+  }
+
   Socket _socket;
   Timer _closeTimer;
 
   Function _onMessage;
   Function _onClosed;
   Function _onError;
 
   int _currentMessageType = _WebSocketMessageType.NONE;
   _StringDecoder _decoder;
   ListOutputStream _outputStream;
   bool _closeReceived = false;
   bool _closeSent = false;
 }
 
 
+class _WebSocketConnection
+    extends _WebSocketConnectionBase implements WebSocketConnection {
+  _WebSocketConnection(DetachedSocket detached) {
+    _socketReady(detached);
+  }
+}
+
+
 class _WebSocketHandler implements WebSocketHandler {
   void onRequest(HttpRequest request, HttpResponse response) {
     // Check that this is a web socket upgrade.
     if (!_isWebSocketUpgrade(request)) {
       response.statusCode = HttpStatus.BAD_REQUEST;
+      response.outputStream.close();
       return;
     }
 
     // Send the upgrade response.
     response.statusCode = HttpStatus.SWITCHING_PROTOCOLS;
     response.headers.add(HttpHeaders.CONNECTION, "Upgrade");
     response.headers.add(HttpHeaders.UPGRADE, "websocket");
-    String x = request.headers.value("Sec-WebSocket-Key");
-    String y = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
-    String z = _Base64._encode(_Sha1._hash("$x$y".charCodes()));
-    response.headers.add("Sec-WebSocket-Accept", z);
+    String key = request.headers.value("Sec-WebSocket-Key");
+    String accept =
+        _Base64._encode(_Sha1._hash("$key$_webSocketGUID".charCodes()));
+    response.headers.add("Sec-WebSocket-Accept", accept);
     response.contentLength = 0;
 
     // Upgrade the connection and get the underlying socket.
-    Socket socket = response.detachSocket();
-    WebSocketConnection conn = new _WebSocketConnection(socket);
+    WebSocketConnection conn =
+        new _WebSocketConnection(response.detachSocket());
     if (_onOpen != null) _onOpen(conn);
   }
 
   void set onOpen(callback(WebSocketConnection connection)) {
     _onOpen = callback;
   }
 
   bool _isWebSocketUpgrade(HttpRequest request) {
+    if (request.method != "GET") {
+      return false;
+    }
     if (request.headers[HttpHeaders.CONNECTION] == null) {
       return false;
     }
     bool isUpgrade = false;
     request.headers[HttpHeaders.CONNECTION].forEach((String value) {
       if (value.toLowerCase() == "upgrade") isUpgrade = true;
     });
     if (!isUpgrade) return false;
     String upgrade = request.headers.value(HttpHeaders.UPGRADE);
     if (upgrade == null || upgrade.toLowerCase() != "websocket") {
       return false;
     }
     String version = request.headers.value("Sec-WebSocket-Version");
     if (version == null || version != "13") {
       return false;
     }
     String key = request.headers.value("Sec-WebSocket-Key");
     if (key == null) {
       return false;
     }
     return true;
   }
 
   Function _onOpen;
 }
+
+
+class _WebSocketClientConnection
+    extends _WebSocketConnectionBase implements WebSocketClientConnection {
+  _WebSocketClientConnection(HttpClientConnection this._conn,
+                             [List<String> protocols]) {
+    _conn.onRequest = _onHttpClientRequest;
+    _conn.onResponse = _onHttpClientResponse;
+    _conn.onError = (e) => _reportError(e);
+  }
+
+  void set onRequest(void callback(HttpClientRequest request)) {
+    _onRequest = callback;
+  }
+
+  void set onOpen(void callback()) {
+    _onOpen = callback;
+  }
+
+  void set onNoUpgrade(void callback(HttpClientResponse request)) {
+    _onNoUpgrade = callback;
+  }
+
+  void _onHttpClientRequest(HttpClientRequest request) {
+    if (_onRequest != null) {
+      _onRequest(request);
+    }
+    // Setup the initial handshake.
+    _generateNonce();
+    request.headers.add(HttpHeaders.CONNECTION, "upgrade");
+    request.headers.set(HttpHeaders.UPGRADE, "websocket");
+    request.headers.set("Sec-WebSocket-Key", _nonce);
+    request.headers.set("Sec-WebSocket-Version", "13");
+    request.contentLength = 0;
+    request.outputStream.close();
+  }
+
+  void _onHttpClientResponse(HttpClientResponse response) {
+    if (response.statusCode != HttpStatus.SWITCHING_PROTOCOLS) {
+      if (_onNoUpgrade != null) {
+        _onNoUpgrade(response);
+      } else {
+        _conn.detachSocket().socket.close();
+        throw new WebSocketException("Protocol upgrade refused");
+      }
+      return;
+    }
+
+    if (!_isWebSocketUpgrade(response)) {
+      _conn.detachSocket().socket.close();
+      throw new WebSocketException("Protocol upgrade failed");
+      return;
+    }
+
+    // Connection upgrade successful.
+    _socketReady(_conn.detachSocket());
+    if (_onOpen != null) _onOpen();
+  }
+
+  void _generateNonce() {
+    assert(_nonce == null);
+    void intToBigEndianBytes(int value, List<int> bytes, int offset) {
+      bytes[offset] = (value >> 24) & 0xFF;
+      bytes[offset + 1] = (value >> 16) & 0xFF;
+      bytes[offset + 2] = (value >> 8) & 0xFF;
+      bytes[offset + 3] = value & 0xFF;
+    }
+
+    // Generate 16 random bytes.
+    List<int> nonce = new List<int>(16);
+    for (int i = 0; i < 4; i++) {
+      int r = (Math.random() * 0x100000000).toInt();
+      intToBigEndianBytes(r, nonce, i * 4);
+    }
+    _nonce = _Base64._encode(nonce);
+  }
+
+  bool _isWebSocketUpgrade(HttpClientResponse response) {
+    if (response.headers[HttpHeaders.CONNECTION] == null) {
+      return false;
+    }
+    bool isUpgrade = false;
+    response.headers[HttpHeaders.CONNECTION].forEach((String value) {
+      if (value.toLowerCase() == "upgrade") isUpgrade = true;
+    });
+    if (!isUpgrade) return false;
+    String upgrade = response.headers.value(HttpHeaders.UPGRADE);
+    if (upgrade == null || upgrade.toLowerCase() != "websocket") {
+      return false;
+    }
+    String accept = response.headers.value("Sec-WebSocket-Accept");
+    if (accept == null) {
+      return false;
+    }
+    List<int> expectedAccept =
+        _Sha1._hash("$_nonce$_webSocketGUID".charCodes());
+    List<int> receivedAccept = _Base64._decode(accept);
+    if (expectedAccept.length != receivedAccept.length) return false;
+    for (int i = 0; i < expectedAccept.length; i++) {
+      if (expectedAccept[i] != receivedAccept[i]) return false;
+    }
+    return true;
+  }
+
+  Function _onRequest;
+  Function _onOpen;
+  Function _onNoUpgrade;
+  HttpClientConnection _conn;
+  String _nonce;
+}