Fixed a number of bugs on RawSocket and Socket

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}) {
@@ skipping 285 matching lines @@
   RawReceivePort eventPort;
   bool flagsSent = false;
 
   // The type flags for this socket.
   final int typeFlags;
 
   // Holds the port of the socket, 0 if not known.
   int localPort = 0;
 
   // Holds the address used to connect or bind the socket.
-  InternetAddress address;
+  InternetAddress localAddress;
 
   int available = 0;
 
   int tokens = 0;
 
   bool sendReadEvents = false;
   bool readEventIssued = false;
 
   bool sendWriteEvents = false;
   bool writeEventIssued = false;
@@ skipping 93 matching lines @@
           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;
+            socket.localAddress = address;
             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.
@@ skipping 52 matching lines @@
           return lookup(host)
               .then((list) {
                 if (list.length == 0) {
                   throw createError(response, "Failed host lookup: '$host'");
                 }
                 return list[0];
               });
         })
         .then((address) {
           var socket = new _NativeSocket.listen();
-          socket.address = address;
+          socket.localAddress = address;
 
           var result = socket.nativeCreateBindListen(address._in_addr,
                                                      port,
                                                      backlog,
                                                      v6Only,
                                                      shared);
           if (result is OSError) {
             throw new SocketException("Failed to create server socket",
                                       osError: result,
                                       address: address,
@@ skipping 26 matching lines @@
             throw new SocketException("Failed to create datagram socket",
                                       osError: result,
                                       address: address,
                                       port: port);
           }
           if (port != 0) socket.localPort = port;
           return socket;
         });
   }
 
-  _NativeSocket.datagram(this.address)
+  _NativeSocket.datagram(this.localAddress)
     : typeFlags = TYPE_NORMAL_SOCKET | TYPE_UDP_SOCKET;
 
   _NativeSocket.normal() : typeFlags = TYPE_NORMAL_SOCKET | TYPE_TCP_SOCKET;
 
   _NativeSocket.listen() : typeFlags = TYPE_LISTENING_SOCKET | TYPE_TCP_SOCKET {
     isClosedWrite = true;
   }
 
   _NativeSocket.pipe() : typeFlags = TYPE_PIPE;
 
@@ skipping 113 matching lines @@
   _NativeSocket accept() {
     // Don't issue accept if we're closing.
     if (isClosing || isClosed) return null;
     assert(available > 0);
     available--;
     tokens++;
     returnTokens(LISTENING_TOKEN_BATCH_SIZE);
     var socket = new _NativeSocket.normal();
     if (nativeAccept(socket) != true) return null;
     socket.localPort = localPort;
-    socket.address = address;
+    socket.localAddress = address;
     totalRead += 1;
     lastRead = timestamp;
     return socket;
   }
 
   int get port {
+    if (isClosing || isClosed) throw const SocketException.closed();
     if (localPort != 0) return localPort;
     var result = nativeGetPort();
     if (result is OSError) throw result;
     return localPort = result;
   }
 
   int get remotePort {
-    return nativeGetRemotePeer()[1];
+    if (isClosing || isClosed) throw const SocketException.closed();
+    var result = nativeGetRemotePeer();
+    if (result is OSError) throw result;
+    return result[1];
+  }
+
+  InternetAddress get address {

[Anders Johnsen, 2015/03/09 12:00:45]

This is a breaking change. Before we allowed the user to read a cached value
after the socket was closed, now we don't. Not sure if we need to announce this.

[Søren Gjesse, 2015/03/09 13:33:46]

Yes (I had to fix a test), it is the same for port if it was already known. I
will think about whether sending out an announcement.

+    if (isClosing || isClosed) throw const SocketException.closed();
+    return localAddress;
   }
 
   InternetAddress get remoteAddress {
-    var result = nativeGetRemotePeer()[0];
-    var type = new InternetAddressType._from(result[0]);
-    return new _InternetAddress(result[1], null, result[2]);
+    if (isClosing || isClosed) throw const SocketException.closed();
+    var result = nativeGetRemotePeer();
+    if (result is OSError) throw result;
+    var addr = result[0];
+    var type = new InternetAddressType._from(addr[0]);
+    return new _InternetAddress(addr[1], null, addr[2]);
   }
 
   void issueReadEvent() {
     if (closedReadEventSent) return;
     if (readEventIssued) return;
     readEventIssued = true;
     void issue() {
       readEventIssued = false;
       if (isClosing) return;
       if (!sendReadEvents) return;
@@ skipping 993 matching lines @@
     _closeRawSocket();
     _controllerClosed = true;
     _controller.close();
   }
 
   bool setOption(SocketOption option, bool enabled) {
     if (_raw == null) return false;
     return _raw.setOption(option, enabled);
   }
 
-  int get port => _raw.port;
-  InternetAddress get address => _raw.address;
-  int get remotePort => _raw.remotePort;
-  InternetAddress get remoteAddress => _raw.remoteAddress;
+  int get port {
+    if (_raw == null) throw const SocketException.closed();;
+    return _raw.port;
+  }
+
+  InternetAddress get address {
+    if (_raw == null) throw const SocketException.closed();;
+    return _raw.address;
+  }
+
+  int get remotePort {
+    if (_raw == null) throw const SocketException.closed();;
+    return _raw.remotePort;
+  }
+
+  InternetAddress get remoteAddress {
+    if (_raw == null) throw const SocketException.closed();;
+    return _raw.remoteAddress;
+  }
 
   Future _detachRaw() {
     _detachReady = new Completer();
     _sink.close();
     return _detachReady.future.then((_) {
       assert(_consumer.buffer == null);
       var raw = _raw;
       _raw = null;
       return [raw, _subscription];
     });
@@ skipping 246 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();