Add support to specify the source address for socket connect

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}) {
     return _RawServerSocket.bind(address, port, backlog, v6Only);
   }
 }
 
 
 patch class RawSocket {
-  /* patch */ static Future<RawSocket> connect(host, int port) {
-    return _RawSocket.connect(host, port);
+  /* patch */ static Future<RawSocket> connect(
+      host, int port, {sourceAddress}) {
+    return _RawSocket.connect(host, port, sourceAddress);
   }
 }
 
 
 patch class InternetAddress {
   /* patch */ static InternetAddress get LOOPBACK_IP_V4 {
     return _InternetAddress.LOOPBACK_IP_V4;
   }
 
   /* patch */ static InternetAddress get LOOPBACK_IP_V6 {
@@ skipping 346 matching lines @@
                   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) {
+  static Future<_NativeSocket> connect(host, int port, sourceAddress) {
+    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(response, "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();
           void connectNext() {
             if (!it.moveNext()) {
               if (connecting.isEmpty) {
                 assert(error != null);
                 completer.completeError(error);
               }
               return;
             }
             var address = it.current;
             var socket = new _NativeSocket.normal();
             socket.address = address;
-            var result = socket.nativeCreateConnect(address._in_addr, port);
+            var result;
+            if (sourceAddress == null) {
+              result = socket.nativeCreateConnect(address._in_addr, port);
+            } else {
+              assert(sourceAddress is _InternetAddress);
+              result = socket.nativeCreateBindConnect(
+                  address._in_addr, port, sourceAddress._in_addr);
+            }
             if (result is OSError) {
               // Keep first error, if present.
               if (error == null) {
                 error = createError(result, "Connection failed", address, port);
               }
               connectNext();
             } else {
               socket.port;  // Query the local port, for error messages.
               // Set up timer for when we should retry the next address
               // (if any).
@@ skipping 685 matching lines @@
   nativeAvailable() native "Socket_Available";
   nativeRead(int len) native "Socket_Read";
   nativeRecvFrom() native "Socket_RecvFrom";
   nativeWrite(List<int> buffer, int offset, int bytes)
       native "Socket_WriteList";
   nativeSendTo(List<int> buffer, int offset, int bytes,
                List<int> address, int port)
       native "Socket_SendTo";
   nativeCreateConnect(List<int> addr,
                       int port) native "Socket_CreateConnect";
+  nativeCreateBindConnect(
+      List<int> addr, int port, List<int> sourceAddr)
+      native "Socket_CreateBindConnect";
   nativeCreateBindListen(List<int> addr, int port, int backlog, bool v6Only)
       native "ServerSocket_CreateBindListen";
   nativeCreateBindDatagram(List<int> addr, int port, bool reuseAddress)
       native "Socket_CreateBindDatagram";
   nativeAccept(_NativeSocket socket) native "ServerSocket_Accept";
   int nativeGetPort() native "Socket_GetPort";
   List nativeGetRemotePeer() native "Socket_GetRemotePeer";
   int nativeGetSocketId() native "Socket_GetSocketId";
   OSError nativeGetError() native "Socket_GetError";
   nativeGetOption(int option, int protocol) native "Socket_GetOption";
@@ skipping 151 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) {
-    return _NativeSocket.connect(host, port)
+  static Future<RawSocket> connect(host, int port, sourceAddress) {
+    return _NativeSocket.connect(host, port, sourceAddress)
         .then((socket) => new _RawSocket(socket));
   }
 
   _RawSocket(this._socket) {
     var zone = Zone.current;
     _controller = new StreamController(sync: true,
         onListen: _onSubscriptionStateChange,
         onCancel: _onSubscriptionStateChange,
         onPause: _onPauseStateChange,
         onResume: _onPauseStateChange);
@@ skipping 181 matching lines @@
   ServerSocketReference get reference {
     return new _ServerSocketReference(_socket.reference);
   }
 
   Map _toJSON(bool ref) => _socket._toJSON(ref);
   void set _owner(owner) { _socket._owner = owner; }
 }
 
 
 patch class Socket {
-  /* patch */ static Future<Socket> connect(host, int port) {
-    return RawSocket.connect(host, port).then(
+  /* patch */ static Future<Socket> connect(host, int port, {sourceAddress}) {
+    return RawSocket.connect(host, port, sourceAddress: sourceAddress).then(
         (socket) => new _Socket(socket));
   }
 }
 
 
 class _SocketStreamConsumer extends StreamConsumer<List<int>> {
   StreamSubscription subscription;
   final _Socket socket;
   int offset;
   List<int> buffer;
@@ skipping 428 matching lines @@
                        String address,
                        List<int> in_addr,
                        int port) {
   return new Datagram(
       data,
       new _InternetAddress(address, null, in_addr),
       port);
 }
 
 String _socketsStats() => _SocketsObservatory.toJSON();