Disable IPv6 lookup by default.

runtime/bin/socket_patch.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.
 
 patch class RawServerSocket  {
-  /* patch */ static Future<RawServerSocket> bind([String address = "127.0.0.1",
+  /* patch */ static Future<RawServerSocket> bind([address = "127.0.0.1",
                                                    int port = 0,
                                                    int backlog = 0]) {
     return _RawServerSocket.bind(address, port, backlog);
   }
 }
 
 
 patch class RawSocket {
   /* patch */ static Future<RawSocket> connect(host, int port) {
     return _RawSocket.connect(host, port);
   }
 }
 
 
 patch class InternetAddress {
   /* patch */ static Future<List<InternetAddress>> lookup(
-      String host, {InternetAddressType type: InternetAddressType.ANY}) {
+      String host, {InternetAddressType type: InternetAddressType.IPv4}) {
     return _NativeSocket.lookup(host, type: type);
   }
 }
 
 class _InternetAddress implements InternetAddress {
   final InternetAddressType type;
   final String address;
   final String host;
   final Uint8List _sockaddr_storage;
 
@@ skipping 64 matching lines @@
   // Holds the port of the socket, null if not known.
   int localPort;
 
   // Holds the address used to connect or bind the socket.
   InternetAddress address;
 
   // Native port for socket services.
   static SendPort socketService;
 
   static Future<List<InternetAddress>> lookup(
-      String host, {InternetAddressType type: InternetAddressType.ANY}) {
+      String host, {InternetAddressType type: InternetAddressType.IPv4}) {
     ensureSocketService();
     return socketService.call([HOST_NAME_LOOKUP, host, type._value])
         .then((response) {
           if (isErrorResponse(response)) {
             throw createError(response, "Failed host name lookup");
           } else {
             return response.skip(1).map((result) {
               var type = new InternetAddressType._from(result[0]);
               return new _InternetAddress(type, result[1], host, result[2]);
             }).toList();
@@ skipping 34 matching lines @@
                   socket.close();
                   completer.completeError(createError(e, "Connection failed"));
                 }
             );
             socket.setListening(read: false, write: true);
             return completer.future;
           }
         });
   }
 
-  static Future<_NativeSocket> bind(String address,
+  static Future<_NativeSocket> bind(host,
                                     int port,
                                     int backlog) {
-    return lookup(address)
-        .then((list) {
-          if (list.length == 0) {
-            throw createError(response, "Failed host name lookup");
-          }
-          return list[0];
+    return new Future.value(host)
+        .then((host) {
+          if (host is _InternetAddress) return host;
+          return lookup(host)
+              .then((list) {
+                if (list.length == 0) {
+                  throw createError(response, "Failed host name lookup");
+                }
+                return list[0];
+              });
         })
         .then((address) {
           var socket = new _NativeSocket.listen();
           socket.address = address;
           var result = socket.nativeCreateBindListen(address._sockaddr_storage,
                                                      port,
                                                      backlog);
           if (result is OSError) {
             throw new SocketIOException(
                 "Failed to create server socket", result);
@@ skipping 297 matching lines @@
 
   static SendPort newServicePort() native "Socket_NewServicePort";
 }
 
 
 class _RawServerSocket extends Stream<RawSocket>
                        implements RawServerSocket {
   final _NativeSocket _socket;
   StreamController<RawSocket> _controller;
 
-  static Future<_RawServerSocket> bind(String address,
+  static Future<_RawServerSocket> bind(address,
                                        int port,
                                        int backlog) {
     if (port < 0 || port > 0xFFFF)
       throw new ArgumentError("Invalid port $port");
     if (backlog < 0) throw new ArgumentError("Invalid backlog $backlog");
     return _NativeSocket.bind(address, port, backlog)
         .then((socket) => new _RawServerSocket(socket));
   }
 
   _RawServerSocket(this._socket) {
@@ skipping 173 matching lines @@
     if (_controller.hasListener) {
       _resume();
     } else {
       close();
     }
   }
 }
 
 
 patch class ServerSocket {
-  /* patch */ static Future<ServerSocket> bind([String address = "127.0.0.1",
+  /* patch */ static Future<ServerSocket> bind([address = "127.0.0.1",
                                                 int port = 0,
                                                 int backlog = 0]) {
     return _ServerSocket.bind(address, port, backlog);
   }
 }
 
 class _ServerSocket extends Stream<Socket>
                     implements ServerSocket {
   final _socket;
 
-  static Future<_ServerSocket> bind(String address,
+  static Future<_ServerSocket> bind(address,
                                     int port,
                                     int backlog) {
     return _RawServerSocket.bind(address, port, backlog)
         .then((socket) => new _ServerSocket(socket));
   }
 
   _ServerSocket(this._socket);
 
   StreamSubscription<Socket> listen(void onData(Socket event),
                                     {void onError(error),
@@ skipping 326 matching lines @@
     _raw.onBadCertificate = callback;
   }
 
   X509Certificate get peerCertificate {
     if (_raw == null) {
      throw new StateError("peerCertificate called on destroyed SecureSocket");
     }
     return _raw.peerCertificate;
   }
 }