Enable client certificates in SecureSocket and SecureServerSocket

sdk/lib/io/secure_server_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.
 
 
 abstract class SecureServerSocket implements ServerSocket {
   /**
    * Constructs a new secure server socket, binds it to a given address
    * and port, and listens on it.  Incoming client connections are
    * promoted to secure connections, using the server certificate given by
    * certificate_name.  The bindAddress must be given as a numeric address,
    * not a host name.  The certificate name is the distinguished name (DN) of
    * the certificate, such as "CN=localhost" or "CN=myserver.mydomain.com".
    * The certificate is looked up in the NSS certificate database set by
    * SecureSocket.setCertificateDatabase.
+   *
+   * To request or require that clients authenticate by providing an SSL (TLS)
+   * client certificate, set the optional parameters requestClientCertificate or
+   * requireClientCertificate to true.  Require implies request, so one doesn't
+   * need to specify both.  To check whether a client certificate was received,
+   * check SecureSocket.peerCertificate after connecting.  If no certificate
+   * was received, the result will be null.
    */
   factory SecureServerSocket(String bindAddress,
-                          int port,
-                          int backlog,
-                          String certificate_name) =>
-      new _SecureServerSocket(bindAddress, port, backlog, certificate_name);
+                             int port,
+                             int backlog,
+                             String certificate_name,
+                             {bool requestClientCertificate: false,

[Søren Gjesse, 2012/12/07 13:00:23]

How about using an "enum" here with the following values:

SecureServerSocket.NO_CLIENT_CERTIFICATE
SecureServerSocket.REQUEST_CLIENT_CERTIFICATE
SecureServerSocket.REQUIRE_CLIENT_CERTIFICATE

I think it will be easier to understand.

[Bill Hesse, 2012/12/10 15:15:48]

I strongly feel that for the user of the API, choosing between
new SecureServerSocket(...., requestClientCertificate: true)
new SecureServerSocket(...., requireClientCertificate: true)
and
new SecureServerSocket(....)

will be easier than writing
new SecureServerSocket(...., SecureServerSocket.REQUEST_CLIENT_CERTIFICATE)
or 
new SecureServerSocket(...., SecureServerSocket.REQUEST_CLIENT_CERTIFICATE),

especially since there should be editor support for the first ones.

I can see combining the flags at the native implementation level, because
parameter passing is such a pain, but here this seems better to me.

+                              bool requireClientCertificate: false}) {
+    return new _SecureServerSocket(bindAddress,
+                                   port,
+                                   backlog,
+                                   certificate_name,
+                                   requestClientCertificate,
+                                   requireClientCertificate);
+  }
 }
 
 
 class _SecureServerSocket implements SecureServerSocket {
 
   _SecureServerSocket(String bindAddress,
-                   int port,
-                   int backlog,
-                   String certificate_name) {
+                      int port,
+                      int backlog,
+                      String certificate_name,
+                      bool requestClientCertificate,
+                      bool requireClientCertificate)
+      : _certificate_name = certificate_name,
+        _requestClientCertificate = requestClientCertificate,
+        _requireClientCertificate = requireClientCertificate {
     _socket = new ServerSocket(bindAddress, port, backlog);
     _socket.onConnection = this._onConnectionHandler;
-    _certificate_name = certificate_name;
   }
 
   void set onConnection(void callback(Socket connection)) {
     _onConnectionCallback = callback;
   }
 
   void set onError(void callback(e)) {
     _socket.onError = callback;
   }
 
@@ skipping 14 matching lines @@
       connection.close();
       throw new SocketIOException(
           "SecureServerSocket with no onConnection callback connected to");
     }
     if (_certificate_name == null) {
       connection.close();
       throw new SocketIOException(
           "SecureServerSocket with server certificate not set connected to");
     }
     var secure_connection = new _SecureSocket.server(connection.remoteHost,
-                                                  connection.remotePort,
-                                                  connection,
-                                                  _certificate_name);
+                                                     connection.remotePort,
+                                                     connection,
+                                                     _certificate_name,
+                                                     _requestClientCertificate,
+                                                     _requireClientCertificate);
     _onConnectionCallback(secure_connection);
   }
 
   ServerSocket _socket;
   var _onConnectionCallback;
-  String _certificate_name;
-}
+  final String _certificate_name;
+  final bool _requestClientCertificate;
+  final bool _requireClientCertificate;}