Implement input and output streams for secure network sockets.

sdk/lib/io/tls_socket.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.
 
 /**
  * TlsSocket provides a secure (SSL or TLS) client connection to a server.
  * The certificate provided by the server is checked
  * using the certificate database provided in setCertificateDatabase.
  */
 abstract class TlsSocket implements Socket {
@@ skipping 64 matching lines @@
     if (_socket == null) {
       _socket = new Socket(host, port);
     }
     _socket.onConnect = _tlsConnectHandler;
     _socket.onData = _tlsDataHandler;
     _socket.onClosed = _tlsCloseHandler;
     _tlsFilter.init();
     _tlsFilter.registerHandshakeCompleteCallback(_tlsHandshakeCompleteHandler);
   }
 
-  InputStream get inputStream {
-    // TODO(6701): Implement stream interfaces on TlsSocket.
-    throw new UnimplementedError("TlsSocket.inputStream not implemented yet");
-  }
-
   int get port => _socket.port;
 
   String get remoteHost => _socket.remoteHost;
 
   int get remotePort => _socket.remotePort;
 
   void set onClosed(void callback()) {
+    if (_inputStream != null) {
+      throw new StreamException(
+           "Cannot set close handler when input stream is used");
+    }
+    _onClosed = callback;
+  }
+
+  void set _onClosed(void callback()) {
     _socketCloseHandler = callback;
   }
 
   void set onConnect(void callback()) {
+    if (_outputStream != null) {
+      throw new StreamException(
+          "Cannot set connect handler when output stream is used");
+    }
+    if (_status == CONNECTED || _status == CLOSED) {
+      throw new StreamException(
+          "Cannot set connect handler when already connected");
+    }
+    _onConnect = callback;
+  }
+
+  void set _onConnect(void callback()) {
     _socketConnectHandler = callback;
   }
 
   void set onData(void callback()) {
+    if (_outputStream != null) {
+      throw new StreamException(
+          "Cannot set data handler when input stream is used");
+    }
+    _onData = callback;
+  }
+
+  void set _onData(void callback()) {
     _socketDataHandler = callback;
   }
 
   void set onWrite(void callback()) {
+    if (_outputStream != null) {
+      throw new StreamException(
+          "Cannot set write handler when output stream is used");
+    }
+    _onWrite = callback;
+  }
+
+  void set _onWrite(void callback()) {
     _socketWriteHandler = callback;
     // Reset the one-shot onWrite handler.
     _socket.onWrite = _tlsWriteHandler;
   }
 
+  InputStream get inputStream {
+    if (_inputStream == null) {
+      if (_socketDataHandler != null || _socketCloseHandler != null) {
+        throw new StreamException(
+            "Cannot get input stream when socket handlers are used");
+      }
+      _inputStream = new _SocketInputStream(this);
+    }
+    return _inputStream;
+  }
+
   OutputStream get outputStream {
-    // TODO(6701): Implement stream interfaces on TlsSocket.
-    throw new UnimplementedError("TlsSocket.inputStream not implemented yet");
+    if (_outputStream == null) {
+      if (_socketConnectHandler != null || _socketWriteHandler != null) {
+        throw new StreamException(
+            "Cannot get output stream when socket handlers are used");
+      }
+      _outputStream = new _SocketOutputStream(this);
+    }
+    return _outputStream;
   }
 
   int available() {
     throw new UnimplementedError("TlsSocket.available not implemented yet");
   }
 
   void close([bool halfClose]) {
     if (halfClose) {
       _closedWrite = true;
       _writeEncryptedData();
       if (_filterWriteEmpty) {
         _socket.close(true);
         _socketClosedWrite = true;
       }
     } else {
       _closedWrite = true;
       _closedRead = true;
       _socket.close(false);
       _socketClosedWrite = true;
       _socketClosedRead = true;
       _tlsFilter.destroy();
       _tlsFilter = null;
       if (scheduledDataEvent != null) {
         scheduledDataEvent.cancel();
       }
       _status = CLOSED;
     }
   }
 
+  void _closeWrite() => close(true);
+
   List<int> read([int len]) {
     if (_closedRead) {
       throw new SocketException("Reading from a closed socket");
     }
+    if (_status != CONNECTED) {
+      return new List<int>(0);
+    }
     var buffer = _tlsFilter.buffers[READ_PLAINTEXT];
     _readEncryptedData();
     int toRead = buffer.length;
     if (len != null) {
       if (len is! int || len < 0) {
         throw new ArgumentError(
             "Invalid len parameter in TlsSocket.read (len: $len)");
       }
       if (len < toRead) {
         toRead = len;
       }
     }
     List<int> result = buffer.data.getRange(buffer.start, toRead);
     buffer.advanceStart(toRead);
     _setHandlersAfterRead();
     return result;
   }
 
   int readList(List<int> data, int offset, int bytes) {
     if (_closedRead) {
       throw new SocketException("Reading from a closed socket");
     }
     if (offset < 0 || bytes < 0 || offset + bytes > data.length) {
       throw new ArgumentError(
           "Invalid offset or bytes in TlsSocket.readList");
     }
+    if (_status != CONNECTED && _status != CLOSED) {
+      return 0;
+    }
 
     int bytesRead = 0;
     var buffer = _tlsFilter.buffers[READ_PLAINTEXT];
     // TODO(whesse): Currently this fails if the if is turned into a while loop.
     // Fix it so that it can loop and read more than one buffer's worth of data.
     if (bytes > bytesRead) {
       _readEncryptedData();
       if (buffer.length > 0) {
         int toRead = min(bytes - bytesRead, buffer.length);
         data.setRange(offset, toRead, buffer.data, buffer.start);
         buffer.advanceStart(toRead);
         bytesRead += toRead;
         offset += toRead;
       }
     }
 
     _setHandlersAfterRead();
     return bytesRead;
   }
 
   // Write the data to the socket, and flush it as much as possible
   // until it would block.  If the write would block, _writeEncryptedData sets
   // up handlers to flush the pipeline when possible.
   int writeList(List<int> data, int offset, int bytes) {
     if (_closedWrite) {
       throw new SocketException("Writing to a closed socket");
     }
+    if (_status != CONNECTED) return 0;
     var buffer = _tlsFilter.buffers[WRITE_PLAINTEXT];
     if (bytes > buffer.free) {
       bytes = buffer.free;
     }
     if (bytes > 0) {
       buffer.data.setRange(buffer.start + buffer.length, bytes, data, offset);
       buffer.length += bytes;
     }
     _writeEncryptedData();  // Tries to flush all pipeline stages.
     return bytes;
@@ skipping 65 matching lines @@
       _socket.onWrite = _tlsWriteHandler;
     }
   }
 
   void _tlsHandshakeCompleteHandler() {
     _status = CONNECTED;
     if (_connectPending && _socketConnectHandler != null) {
       _connectPending = false;
       _socketConnectHandler();
     }
+    if (_socketWriteHandler != null) {
+      _socket.onWrite = _tlsWriteHandler;
+    }
   }
 
+  // True if the underlying socket is closed, the filter has been emptied of
+  // all data, and the close event has been fired.
+  get _closed => _socketClosed && !_fireCloseEventPending;
+
   void _fireCloseEvent() {
     if (scheduledDataEvent != null) {
       scheduledDataEvent.cancel();
     }
     if (_socketCloseHandler != null) {
       _socketCloseHandler();
     }
   }
 
   void _readEncryptedData() {
@@ skipping 101 matching lines @@
         _readEncryptedData();
       }
       if (_filterReadEmpty) {
         // This can't be an else clause: the value of _filterReadEmpty changes.
         // This must be asynchronous, because we are in a read or readList call.
         new Timer(0, (_) => _fireCloseEvent());
       }
     }
   }
 
+  bool get _socketClosed => _closedRead;
+
   // _TlsSocket cannot extend _Socket and use _Socket's factory constructor.
   Socket _socket;
   String _host;
   int _port;
   bool _is_server;
   String _certificateName;
 
   var _status = NOT_CONNECTED;
   bool _socketClosedRead = false;  // The network socket is closed for reading.
   bool _socketClosedWrite = false;  // The network socket is closed for writing.
   bool _closedRead = false;  // The secure socket has fired an onClosed event.
   bool _closedWrite = false;  // The secure socket has been closed for writing.
   bool _filterReadEmpty = true;  // There is no buffered data to read.
   bool _filterWriteEmpty = true;  // There is no buffered data to be written.
+  _SocketInputStream _inputStream;
+  _SocketOutputStream _outputStream;
   bool _connectPending = false;
   Function _socketConnectHandler;
   Function _socketWriteHandler;
   Function _socketDataHandler;
   Function _socketCloseHandler;
   Timer scheduledDataEvent;
 
   _TlsFilter _tlsFilter;
 }
 
@@ skipping 27 matching lines @@
                bool is_server,
                String certificateName);
   void destroy();
   void handshake();
   void init();
   int processBuffer(int bufferIndex);
   void registerHandshakeCompleteCallback(Function handshakeCompleteHandler);
 
   List<_TlsExternalBuffer> get buffers;
 }