Add client certificates to HttpsServer and HttpClient.

sdk/lib/io/http_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.
 
 // The close queue handles graceful closing of HTTP connections. When
 // a connection is added to the queue it will enter a wait state
 // waiting for all data written and possibly socket shutdown from
 // peer.
 class _CloseQueue {
   _CloseQueue() : _q = new Set<_HttpConnectionBase>();
@@ skipping 82 matching lines @@
       if (connection == null) return true;
       return !headers[HttpHeaders.CONNECTION].some(
           (value) => value.toLowerCase() == "close");
     } else {
       if (connection == null) return false;
       return headers[HttpHeaders.CONNECTION].some(
           (value) => value.toLowerCase() == "keep-alive");
     }
   }
 
+  X509Certificate get certificate {
+    var socket = _httpConnection._socket as SecureSocket;
+    return socket == null ? socket : socket.peerCertificate;
+  }
+
   void set persistentConnection(bool persistentConnection) {
     if (_outputStream != null) throw new HttpException("Header already sent");
 
     // Determine the value of the "Connection" header.
     headers.remove(HttpHeaders.CONNECTION, "close");
     headers.remove(HttpHeaders.CONNECTION, "keep-alive");
     if (_protocolVersion == "1.1" && !persistentConnection) {
       headers.add(HttpHeaders.CONNECTION, "close");
     } else if (_protocolVersion == "1.0" && persistentConnection) {
       headers.add(HttpHeaders.CONNECTION, "keep-alive");
@@ skipping 880 matching lines @@
 
   _HttpServer._internal({ bool isSecure: false })
       : _secure = isSecure,
         _connections = new Set<_HttpConnection>(),
         _handlers = new List<_RequestHandlerRegistration>(),
         _closeQueue = new _CloseQueue();
 
   void listen(String host,
               int port,
               {int backlog: 128,
-              String certificate_name}) {
+               String certificate_name,
+               bool requestClientCertificate: false}) {
     if (_secure) {
-      listenOn(new SecureServerSocket(host, port, backlog, certificate_name));
+      listenOn(new SecureServerSocket(
+          host,
+          port,
+          backlog,
+          certificate_name,
+          requestClientCertificate: requestClientCertificate));
     } else {
       listenOn(new ServerSocket(host, port, backlog));
     }
     _closeServer = true;
   }
 
   void listenOn(ServerSocket serverSocket) {
     if (_secure && serverSocket is! SecureServerSocket) {
         throw new HttpException(
             'HttpsServer.listenOn was called with non-secure server socket');
@@ skipping 727 matching lines @@
   void _markReturned() {
     // Any activity on the socket while waiting in the pool will
     // invalidate the connection os that it is not reused.
     _socket.onData = _invalidate;
     _socket.onClosed = _invalidate;
     _socket.onError = (_) => _invalidate();
     _returnTime = new Date.now();
     _httpClientConnection = null;
   }
 
-  void _markRetreived() {
+  void _markRetrieved() {
     _socket.onData = null;
     _socket.onClosed = null;
     _socket.onError = null;
     _httpClientConnection = null;
   }
 
   void _close() {
     _socket.onData = null;
     _socket.onClosed = null;
     _socket.onError = null;
@@ skipping 128 matching lines @@
 
   set authenticate(Future<bool> f(Uri url, String scheme, String realm)) {
     _authenticate = f;
   }
 
   void addCredentials(
       Uri url, String realm, HttpClientCredentials cr) {
     credentials.add(new _Credentials(url, realm, cr));
   }
 
+  set sendClientCertificate(bool send) => _sendClientCertificate = send;
+
+  set clientCertificate(String nickname) => _clientCertificate = nickname;
+
   set findProxy(String f(Uri uri)) => _findProxy = f;
 
   void shutdown({bool force: false}) {
     if (force) _closeQueue.shutdown();
     _openSockets.forEach((String key, Queue<_SocketConnection> connections) {
       while (!connections.isEmpty) {
         _SocketConnection socketConn = connections.removeFirst();
         socketConn._socket.close();
       }
     });
@@ skipping 73 matching lines @@
         connectHost = proxy.host;
         connectPort = proxy.port;
       }
 
       // If there are active connections for this key get the first one
       // otherwise create a new one.
       String key = _connectionKey(connectHost, connectPort);
       Queue socketConnections = _openSockets[key];
       // Remove active connections that are not valid any more or of
       // the wrong type (HTTP or HTTPS).
-      while (socketConnections != null &&
-             !socketConnections.isEmpty &&
-             (!socketConnections.first._valid ||
-              secure != (socketConnections.first._socket is SecureSocket))) {
-        socketConnections.removeFirst()._close();
+      if (socketConnections != null) {
+        while (!socketConnections.isEmpty) {
+          if (socketConnections.first._valid) {
+            // If socket has the same properties, exit loop with found socket.
+            var socket = socketConnections.first._socket;
+            if (!secure && socket is! SecureSocket) break;
+            if (secure && socket is SecureSocket &&
+                 _sendClientCertificate == socket.sendClientCertificate &&
+                 _clientCertificate == socket.certificateName) break;
+          }
+          socketConnections.removeFirst()._close();
+        }
       }
       if (socketConnections == null || socketConnections.isEmpty) {
-        Socket socket = secure ? new SecureSocket(connectHost, connectPort) :
-                                 new Socket(connectHost, connectPort);
+        Socket socket = secure ?
+            new SecureSocket(connectHost,
+                             connectPort,
+                             sendClientCertificate: _sendClientCertificate,
+                             certificateName: _clientCertificate) :
+            new Socket(connectHost, connectPort);
         // Until the connection is established handle connection errors
         // here as the HttpClientConnection object is not yet associated
         // with the socket.
         socket.onError = (e) {
           proxyIndex++;
           if (proxyIndex < proxyConfiguration.proxies.length) {
             // Try the next proxy in the list.
             _establishConnection(
                 host, port, proxyConfiguration, proxyIndex, false, secure);
           } else {
             // Report the error through the HttpClientConnection object to
             // the client.
             connection._onError(e);
           }
         };
         socket.onConnect = () {
           // When the connection is established, clear the error
           // callback as it will now be handled by the
           // HttpClientConnection object which will be associated with
           // the connected socket.
           socket.onError = null;
           _SocketConnection socketConn =
               new _SocketConnection(connectHost, connectPort, socket);
           _activeSockets.add(socketConn);
           _connectionOpened(socketConn, connection, !proxy.isDirect);
         };
       } else {
         _SocketConnection socketConn = socketConnections.removeFirst();
-        socketConn._markRetreived();
+        socketConn._markRetrieved();
         _activeSockets.add(socketConn);
         new Timer(0, (ignored) =>
                   _connectionOpened(socketConn, connection, !proxy.isDirect));
 
         // Get rid of eviction timer if there are no more active connections.
         if (socketConnections.isEmpty) _openSockets.remove(key);
         if (_openSockets.isEmpty) _cancelEvictionTimer();
       }
     }
 
@@ skipping 122 matching lines @@
   }
 
   Function _onOpen;
   Map<String, Queue<_SocketConnection>> _openSockets;
   Set<_SocketConnection> _activeSockets;
   _CloseQueue _closeQueue;
   List<_Credentials> credentials;
   Timer _evictionTimer;
   Function _findProxy;
   Function _authenticate;
+  bool _sendClientCertificate = false;
+  String _clientCertificate;
   bool _shutdown;  // Has this HTTP client been shutdown?
 }
 
 
 class _HttpConnectionInfo implements HttpConnectionInfo {
   String remoteHost;
   int remotePort;
   int localPort;
 }
 
@@ skipping 111 matching lines @@
 
 
 class _RedirectInfo implements RedirectInfo {
   const _RedirectInfo(int this.statusCode,
                       String this.method,
                       Uri this.location);
   final int statusCode;
   final String method;
   final Uri location;
 }