Add new InternetAddress class with a static lookup function (including IPv6 results).

sdk/lib/io/secure_socket.dart

 // Copyright (c) 2013, 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.
 
 part of dart.io;
 
 /**
  * A high-level class for communicating securely over a TCP socket, using
  * TLS and SSL. The [SecureSocket] exposes both a [Stream] and an
  * [IOSink] interface, making it ideal for using together with
@@ skipping 17 matching lines @@
    * appropriate certificate will be searched for in the database and
    * sent automatically, based on what the server says it will accept.
    *
    * [onBadCertificate] is an optional handler for unverifiable certificates.
    * The handler receives the [X509Certificate], and can inspect it and
    * decide (or let the user decide) whether to accept
    * the connection or not.  The handler should return true
    * to continue the [SecureSocket] connection.
    */
   static Future<SecureSocket> connect(
-      String host,
+      host,
       int port,
       {bool sendClientCertificate: false,
        String certificateName,
        bool onBadCertificate(X509Certificate certificate)}) {
     return RawSecureSocket.connect(host,
                                    port,
                                    sendClientCertificate: sendClientCertificate,
                                    certificateName: certificateName,
                                    onBadCertificate: onBadCertificate)
         .then((rawSocket) => new SecureSocket._(rawSocket));
@@ skipping 152 matching lines @@
    * appropriate certificate will be searched for in the database and
    * sent automatically, based on what the server says it will accept.
    *
    * [onBadCertificate] is an optional handler for unverifiable certificates.
    * The handler receives the [X509Certificate], and can inspect it and
    * decide (or let the user decide) whether to accept
    * the connection or not.  The handler should return true
    * to continue the [RawSecureSocket] connection.
    */
   static Future<RawSecureSocket> connect(
-      String host,
+      host,
       int port,
       {bool sendClientCertificate: false,
        String certificateName,
        bool onBadCertificate(X509Certificate certificate)}) {
     return  _RawSecureSocket.connect(
         host,
         port,
         certificateName,
         is_server: false,
         sendClientCertificate: sendClientCertificate,
@@ skipping 15 matching lines @@
    * See [connect] for more information on the arguments.
    *
    */
   static Future<RawSecureSocket> secure(
       RawSocket socket,
       {StreamSubscription subscription,
        bool sendClientCertificate: false,
        String certificateName,
        bool onBadCertificate(X509Certificate certificate)}) {
     return  _RawSecureSocket.connect(
-        socket.host,
+        socket.address,
         socket.port,
         certificateName,
         is_server: false,
         socket: socket,
         subscription: subscription,
         sendClientCertificate: sendClientCertificate,
         onBadCertificate: onBadCertificate);
   }
 
   /**
@@ skipping 80 matching lines @@
   static final int NUM_BUFFERS = 4;
 
   RawSocket _socket;
   final Completer<_RawSecureSocket> _handshakeComplete =
       new Completer<_RawSecureSocket>();
   StreamController<RawSocketEvent> _controller;
   Stream<RawSocketEvent> _stream;
   StreamSubscription<RawSocketEvent> _socketSubscription;
   List<int> _carryOverData;
   int _carryOverDataIndex = 0;
-  final String host;
+  final InternetAddress address;
   final bool is_server;
   final String certificateName;
   final bool requestClientCertificate;
   final bool requireClientCertificate;
   final bool sendClientCertificate;
   final Function onBadCertificate;
 
   var _status = NOT_CONNECTED;
   bool _writeEventsEnabled = true;
   bool _readEventsEnabled = true;
   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.
   bool _connectPending = false;
   _SecureFilter _secureFilter = new _SecureFilter();
 
   static Future<_RawSecureSocket> connect(
-      String host,
+      host,
       int requestedPort,
       String certificateName,
       {bool is_server,
        RawSocket socket,
        StreamSubscription subscription,
        List<int> carryOverData,
        bool requestClientCertificate: false,
        bool requireClientCertificate: false,
        bool sendClientCertificate: false,
-       bool onBadCertificate(X509Certificate certificate)}){
-     return new _RawSecureSocket(host,
+       bool onBadCertificate(X509Certificate certificate)}) {
+    var future;
+    if (host is String) {
+      future = InternetAddress.lookup(host).then((addrs) => addrs.first);
+    } else {
+      future = new Future.value(host);
+    }
+    return future.then((addr) {
+     return new _RawSecureSocket(addr,
                                  requestedPort,
                                  certificateName,
                                  is_server,
                                  socket,
                                  subscription,
                                  carryOverData,
                                  requestClientCertificate,
                                  requireClientCertificate,
                                  sendClientCertificate,
                                  onBadCertificate)
          ._handshakeComplete.future;
+    });
   }
 
   _RawSecureSocket(
-      String this.host,
+      InternetAddress this.address,
       int requestedPort,
       String this.certificateName,
       bool this.is_server,
       RawSocket socket,
       StreamSubscription this._socketSubscription,
       List<int> this._carryOverData,
       bool this.requestClientCertificate,
       bool this.requireClientCertificate,
       bool this.sendClientCertificate,
       bool this.onBadCertificate(X509Certificate certificate)) {
     _controller = new StreamController<RawSocketEvent>(
         onListen: _onSubscriptionStateChange,
         onPause: _onPauseStateChange,
         onResume: _onPauseStateChange,
         onCancel: _onSubscriptionStateChange);
     _stream = _controller.stream;
     // Throw an ArgumentError if any field is invalid.  After this, all
     // errors will be reported through the future or the stream.
     _verifyFields();
     _secureFilter.init();
     if (_carryOverData != null) _readFromCarryOver();
     _secureFilter.registerHandshakeCompleteCallback(
         _secureHandshakeCompleteHandler);
     if (onBadCertificate != null) {
       _secureFilter.registerBadCertificateCallback(onBadCertificate);
     }
     var futureSocket;
     if (socket == null) {
-      futureSocket = RawSocket.connect(host, requestedPort);
+      futureSocket = RawSocket.connect(address, requestedPort);
     } else {
       futureSocket = new Future.value(socket);
     }
     futureSocket.then((rawSocket) {
       _socket = rawSocket;
       _socket.readEventsEnabled = true;
       _socket.writeEventsEnabled = false;
       if (_socketSubscription == null) {
         // If a current subscription is provided use this otherwise
         // create a new one.
         _socketSubscription = _socket.listen(_eventDispatcher,
                                              onError: _errorHandler,
                                              onDone: _doneHandler);
       } else {
         _socketSubscription.onData(_eventDispatcher);
         _socketSubscription.onError(_errorHandler);
         _socketSubscription.onDone(_doneHandler);
       }
       _connectPending = true;
-      _secureFilter.connect(host,
+      _secureFilter.connect(rawSocket.address.host,
                             port,
                             is_server,
                             certificateName,
                             requestClientCertificate ||
                                 requireClientCertificate,
                             requireClientCertificate,
                             sendClientCertificate);
       _status = HANDSHAKE;
       _secureHandshake();
     })
@@ skipping 13 matching lines @@
     }
     return _stream.listen(onData,
                           onError: onError,
                           onDone: onDone,
                           cancelOnError: cancelOnError);
   }
 
   void _verifyFields() {
     assert(is_server is bool);
     assert(_socket == null || _socket is RawSocket);
-    if (host is! String) {
+    if (address is! InternetAddress) {
       throw new ArgumentError(
-          "RawSecureSocket constructor: host is not a String");
+          "RawSecureSocket constructor: host is not an InternetAddress");
     }
     if (certificateName != null && certificateName is! String) {
       throw new ArgumentError("certificateName is not null or a String");
     }
     if (certificateName == null && is_server) {
       throw new ArgumentError("certificateName is null on a server");
     }
     if (requestClientCertificate is! bool) {
       throw new ArgumentError("requestClientCertificate is not a bool");
     }
@@ skipping 454 matching lines @@
   void destroy();
   void handshake();
   void init();
   X509Certificate get peerCertificate;
   int processBuffer(int bufferIndex);
   void registerBadCertificateCallback(Function callback);
   void registerHandshakeCompleteCallback(Function handshakeCompleteHandler);
 
   List<_ExternalBuffer> get buffers;
 }