Add a hash code to client and server web socket connections

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;
@@ skipping 437 matching lines @@
       // before closing the socket. If a close frame does not arrive
       // within a reasonable amount of time just close the socket.
       _socket.outputStream.close();
       _closeTimer = new Timer(5000, (t) {
         _socket.close();
       });
     }
     _closeSent = true;
   }
 
+  int hashCode() => _hash;
+
   _onWebSocketMessageStart(int type) {
     _currentMessageType = type;
     if (_currentMessageType == _WebSocketMessageType.TEXT) {
       _decoder = _StringDecoders.decoder(Encoding.UTF_8);
     } else {
       _outputStream = new ListOutputStream();
     }
   }
 
   _onWebSocketMessageData(List<int> buffer, int offset, int count) {
@@ skipping 71 matching lines @@
   void _reportError(e) {
     if (_onError != null) {
       _onError(e);
     } else {
       throw e;
     }
   }
 
   Socket _socket;
   Timer _closeTimer;
+  int _hash;
 
   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) {
+    _hash = detached.socket.hashCode();
     _socketConnected(detached.socket);
     _startProcessing(detached.unparsedData);
   }
 }
 
 
 class _WebSocketHandler implements WebSocketHandler {
   void onRequest(HttpRequest request, HttpResponse response) {
     // Check that this is a web socket upgrade.
     if (!_isWebSocketUpgrade(request)) {
@@ skipping 53 matching lines @@
 }
 
 
 class _WebSocketClientConnection
     extends _WebSocketConnectionBase implements WebSocketClientConnection {
   _WebSocketClientConnection(HttpClientConnection this._conn,
                              [List<String> protocols]) {
     _conn.onRequest = _onHttpClientRequest;
     _conn.onResponse = _onHttpClientResponse;
     _conn.onError = (e) => _reportError(e);
+
+    // Generate the nonce now as it is also used to set the hash code.

[Mads Ager (google), 2012/05/14 09:19:39]

I don't actually know if it would be a security issue to use the nonce in the
hash code. It does sound a little fishy, so maybe we should just generate some
more random bytes for the hash?

[Søren Gjesse, 2012/05/14 15:52:41]

Done.

+    _generateNonceAndHash();
   }
 
   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) {
@@ skipping 12 matching lines @@
       return;
     }
 
     // Connection upgrade successful.
     DetachedSocket detached = _conn.detachSocket();
     _socketConnected(detached.socket);
     if (_onOpen != null) _onOpen();
     _startProcessing(detached.unparsedData);
   }
 
-  void _generateNonce() {
+  void _generateNonceAndHash() {
     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.
+    // Generate 16 random bytes. Use the last four bytes for the hash code.
     List<int> nonce = new List<int>(16);
+    int r;
     for (int i = 0; i < 4; i++) {
-      int r = (Math.random() * 0x100000000).toInt();
+      r = (Math.random() * 0x100000000).toInt();
       intToBigEndianBytes(r, nonce, i * 4);
     }
     _nonce = _Base64._encode(nonce);
+    _hash = r;
   }
 
   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;
     });
@@ skipping 124 matching lines @@
 
 class _WebSocketCloseEvent implements CloseEvent {
   _WebSocketCloseEvent(this._wasClean, this._code, this._reason);
   bool get wasClean() => _wasClean;
   int get code() => _code;
   String get reason() => _reason;
   bool _wasClean;
   int _code;
   String _reason;
 }