Added timeout parameter to RawSocket and Socket connect, which allows for the specification of a ma…

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(address, int port,
       {int backlog: 0, bool v6Only: false, bool shared: false}) {
     return _RawServerSocket.bind(address, port, backlog, v6Only, shared);
   }
 }
 
 @patch
 class RawSocket {
   @patch
-  static Future<RawSocket> connect(host, int port, {sourceAddress}) {
-    return _RawSocket.connect(host, port, sourceAddress);
+  static Future<RawSocket> connect(host, int port,
+      {sourceAddress, Duration timeout}) {
+    return _RawSocket.connect(host, port, sourceAddress, timeout);
   }
 }
 
 @patch
 class InternetAddress {
   @patch
   static InternetAddress get LOOPBACK_IP_V4 {
     return _InternetAddress.LOOPBACK_IP_V4;
   }
 
@@ skipping 358 matching lines @@
           if (!includeLoopback && address.isLoopback) return map;
           map.putIfAbsent(name, () => new _NetworkInterface(name, index));
           map[name].addresses.add(address);
           return map;
         });
         return map.values.toList();
       }
     });
   }
 
-  static Future<_NativeSocket> connect(host, int port, sourceAddress) {
+  static Future<_NativeSocket> connect(
+      host, int port, sourceAddress, Duration timeout) {
     _throwOnBadPort(port);
     if (sourceAddress != null && sourceAddress is! _InternetAddress) {
       if (sourceAddress is String) {
         sourceAddress = new InternetAddress(sourceAddress);
       }
     }
     return new Future.value(host).then((host) {
       if (host is _InternetAddress) return [host];
       return lookup(host).then((addresses) {
         if (addresses.isEmpty) {
           throw createError(null, "Failed host lookup: '$host'");
         }
         return addresses;
       });
     }).then((addresses) {
       assert(addresses is List);
       var completer = new Completer();
       var it = addresses.iterator;
       var error = null;
       var connecting = new HashMap();
+      Timer timeoutTimer = null;
+      void timeoutHandler() {
+        connecting.forEach((s, t) {
+          t.cancel();
+          s.close();
+          s.setHandlers();
+          s.setListening(read: false, write: false);
+          error = createError(
+              null, "Connection timed out, host: ${host}, port: ${port}");
+          completer.completeError(error);
+        });
+      }
+
       void connectNext() {
+        if ((timeout != null) && (timeoutTimer == null)) {
+          timeoutTimer = new Timer(timeout, timeoutHandler);
+        }
         if (!it.moveNext()) {
           if (connecting.isEmpty) {
             assert(error != null);
             completer.completeError(error);

[zra, 2017/06/21 20:32:31]

It shouldn't be necessary, but I would be a little extra paranoid, and cancel
the timeoutTimer here.

           }
           return;
         }
         var address = it.current;
         var socket = new _NativeSocket.normal();
         socket.localAddress = address;
         var result;
         if (sourceAddress == null) {
           result = socket.nativeCreateConnect(address._in_addr, port);
         } else {
@@ skipping 24 matching lines @@
           // (if any).
           var duration =
               address.isLoopback ? _RETRY_DURATION_LOOPBACK : _RETRY_DURATION;
           var timer = new Timer(duration, connectNext);
           setupResourceInfo(socket);
 
           connecting[socket] = timer;
           // Setup handlers for receiving the first write event which
           // indicate that the socket is fully connected.
           socket.setHandlers(write: () {
             timer.cancel();

[zra, 2017/06/21 20:32:31]

And here.

             socket.setListening(read: false, write: false);
             completer.complete(socket);
             connecting.remove(socket);
             connecting.forEach((s, t) {
               t.cancel();
               s.close();
               s.setHandlers();
               s.setListening(read: false, write: false);
             });
           }, error: (e) {
@@ skipping 700 matching lines @@
 
 class _RawSocket extends Stream<RawSocketEvent> implements RawSocket {
   final _NativeSocket _socket;
   StreamController<RawSocketEvent> _controller;
   bool _readEventsEnabled = true;
   bool _writeEventsEnabled = true;
 
   // Flag to handle Ctrl-D closing of stdio on Mac OS.
   bool _isMacOSTerminalInput = false;
 
-  static Future<RawSocket> connect(host, int port, sourceAddress) {
+  static Future<RawSocket> connect(
+      host, int port, sourceAddress, Duration timeout) {
     return _NativeSocket
-        .connect(host, port, sourceAddress)
+        .connect(host, port, sourceAddress, timeout)
         .then((socket) => new _RawSocket(socket));
   }
 
   _RawSocket(this._socket) {
     var zone = Zone.current;
     _controller = new StreamController(
         sync: true,
         onListen: _onSubscriptionStateChange,
         onCancel: _onSubscriptionStateChange,
         onPause: _onPauseStateChange,
@@ skipping 158 matching lines @@
   Future close() => _socket.close().then((_) => this);
 
   void set _owner(owner) {
     _socket._owner = owner;
   }
 }
 
 @patch
 class Socket {
   @patch
-  static Future<Socket> connect(host, int port, {sourceAddress}) {
+  static Future<Socket> connect(host, int port,
+      {sourceAddress, Duration timeout}) {
     return RawSocket
-        .connect(host, port, sourceAddress: sourceAddress)
+        .connect(host, port, sourceAddress: sourceAddress, timeout: timeout)
         .then((socket) => new _Socket(socket));
   }
 }
 
 class _SocketStreamConsumer extends StreamConsumer<List<int>> {
   StreamSubscription subscription;
   final _Socket socket;
   int offset;
   List<int> buffer;
   bool paused = false;
@@ skipping 421 matching lines @@
     } else {
       _socket.close();
     }
   }
 }
 
 Datagram _makeDatagram(
     List<int> data, String address, List<int> in_addr, int port) {
   return new Datagram(data, new _InternetAddress(address, null, in_addr), port);
 }