Add 'address' and 'port' to SocketException, and include them in toString().

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);
@@ skipping 209 matching lines @@
 
   // Native port for socket services.
   static SendPort socketService;
 
   static Future<List<InternetAddress>> lookup(
       String host, {InternetAddressType type: InternetAddressType.ANY}) {
     ensureSocketService();
     return socketService.call([HOST_NAME_LOOKUP, host, type._value])
         .then((response) {
           if (isErrorResponse(response)) {
-            throw createError(response, "Failed host name lookup");
+            throw createError(response, "Failed host lookup: '$host'");
           } else {
             return response.skip(1).map((result) {
               var type = new InternetAddressType._from(result[0]);
               return new _InternetAddress(type, result[1], host, result[2]);
             }).toList();
           }
         });
   }
 
   static Future<InternetAddress> reverseLookup(InternetAddress addr) {
     ensureSocketService();
     return socketService.call([REVERSE_LOOKUP, addr._sockaddr_storage])
         .then((response) {
           if (isErrorResponse(response)) {
-            throw createError(response, "Failed host name lookup");
+            throw createError(response, "Failed reverse host lookup", addr);
           } else {
             return addr._cloneWithNewHost(response);
           }
         });
   }
 
   static Future<List<NetworkInterface>> listInterfaces({
       bool includeLoopback: false,
       bool includeLinkLocal: false,
       InternetAddressType type: InternetAddressType.ANY}) {
@@ skipping 24 matching lines @@
         });
   }
 
   static Future<_NativeSocket> connect(host, int port) {
     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");
+                  throw createError(response, "Failed host lookup: '$host'");
                 }
                 return list[0];
               });
         })
         .then((address) {
           ensureSocketService();
           var socket = new _NativeSocket.normal();
           socket.address = address;
           var result = socket.nativeCreateConnect(
               address._sockaddr_storage, port);
           if (result is OSError) {
-            throw createError(result, "Connection failed");
+            throw createError(result, "Connection failed", address, port);
           } else {
             var completer = new Completer();
             // Setup handlers for receiving the first write event which
             // indicate that the socket is fully connected.
             socket.setHandlers(
                 write: () {
                   socket.setListening(read: false, write: false);
                   completer.complete(socket);
                 },
                 error: (e) {
                   socket.close();
-                  completer.completeError(createError(e, "Connection failed"));
+                  completer.completeError(
+                      createError(e, "Connection failed", address, port));
                 }
             );
             socket.setListening(read: false, write: true);
             return completer.future;
           }
         });
   }
 
   static Future<_NativeSocket> bind(host,
                                     int port,
                                     int backlog,
                                     bool v6Only) {
     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");
+                  throw createError(response, "Failed host lookup: '$host'");
                 }
                 return list[0];
               });
         })
         .then((address) {
           var socket = new _NativeSocket.listen();
           socket.address = address;
           var result = socket.nativeCreateBindListen(address._sockaddr_storage,
                                                      port,
                                                      backlog,
                                                      v6Only);
           if (result is OSError) {
-            throw new SocketException(
-                "Failed to create server socket", result);
+            throw new SocketException("Failed to create server socket",
+                                      osError: result,
+                                      address: address,
+                                      port: port);
           }
           if (port != 0) socket.localPort = port;
           return socket;
         });
   }
 
   _NativeSocket.normal() : typeFlags = TYPE_NORMAL_SOCKET {
     eventHandlers = new List(EVENT_COUNT + 1);
     _EventHandler._start();
   }
@@ skipping 234 matching lines @@
     }
   }
 
   // Check whether this is an error response from a native port call.
   static bool isErrorResponse(response) {
     return response is List && response[0] != _SUCCESS_RESPONSE;
   }
 
   // Create the appropriate error/exception from different returned
   // error objects.
-  static createError(error, String message) {
+  static createError(error,
+                     String message,
+                     [InternetAddress address,
+                      int port]) {
     if (error is OSError) {
-      return new SocketException(message, error);
+      return new SocketException(
+          message, osError: error, address: address, port: port);
     } else if (error is List) {
       assert(isErrorResponse(error));
       switch (error[0]) {
         case _ILLEGAL_ARGUMENT_RESPONSE:
           return new ArgumentError();
         case _OSERROR_RESPONSE:
-          return new SocketException(
-              message, new OSError(error[2], error[1]));
+          return new SocketException(message,
+                                     osError: new OSError(error[2], error[1]),
+                                     address: address,
+                                     port: port);
         default:
           return new Exception("Unknown error");
       }
     } else {
-      return new SocketException(message);
+      return new SocketException(message, address: address, port: port);
     }
   }
 
   void reportError(error, String message) {
-    var e = createError(error, message);
+    var e = createError(error, message, address, localPort);
     // Invoke the error handler if any.
     if (eventHandlers[ERROR_EVENT] != null) {
       eventHandlers[ERROR_EVENT](e);
     }
     // For all errors we close the socket
     close();
   }
 
   bool setOption(SocketOption option, bool enabled) {
     if (option is! SocketOption) throw new ArgumentError(options);
@@ skipping 564 matching lines @@
     if (_detachReady != null) {
       _detachReady.complete(null);
     } else {
       if (_raw != null) {
         _raw.shutdown(SocketDirection.SEND);
         _disableWriteEvent();
       }
     }
   }
 }