Throw an ArgumentError if the port is out of range

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 52 matching lines @@
       bool includeLinkLocal: false,
       InternetAddressType type: InternetAddressType.ANY}) {
     return _NativeSocket.listInterfaces(includeLoopback: includeLoopback,
                                         includeLinkLocal: includeLinkLocal,
                                         type: type);
   }
 
   static bool _listSupported() native "NetworkInterface_ListSupported";
 }
 
+void _throwOnBadPort(int port) {
+  if ((port == null) || (port < 0) || (port > 0xFFFF)) {
+    throw new ArgumentError("Invalid port $port");
+  }
+}
+
 class _InternetAddress implements InternetAddress {
   static const int _ADDRESS_LOOPBACK_IP_V4 = 0;
   static const int _ADDRESS_LOOPBACK_IP_V6 = 1;
   static const int _ADDRESS_ANY_IP_V4 = 2;
   static const int _ADDRESS_ANY_IP_V6 = 3;
   static const int _IPV4_ADDR_LENGTH = 4;
   static const int _IPV6_ADDR_LENGTH = 16;
 
   static _InternetAddress LOOPBACK_IP_V4 =
       new _InternetAddress.fixed(_ADDRESS_LOOPBACK_IP_V4);
@@ skipping 297 matching lines @@
                       name, () => new _NetworkInterface(name, index));
                   map[name].addresses.add(address);
                   return map;
                 });
             return map.values.toList();
           }
         });
   }
 
   static Future<_NativeSocket> connect(host, int port, sourceAddress) {
+    _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) {
@@ skipping 81 matching lines @@
           connectNext();
           return completer.future;
         });
   }
 
   static Future<_NativeSocket> bind(host,
                                     int port,
                                     int backlog,
                                     bool v6Only,
                                     bool shared) {
+    _throwOnBadPort(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 lookup: '$host'");
                 }
                 return list[0];
               });
@@ skipping 18 matching lines @@
           return socket;
         });
   }
 
   static void setupResourceInfo(_NativeSocket socket) {
     socket.resourceInfo = new _SocketResourceInfo(socket);
   }
 
   static Future<_NativeSocket> bindDatagram(
       host, int port, bool reuseAddress) {
+    _throwOnBadPort(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 lookup: '$host'");
                 }
                 return list[0];
               });
@@ skipping 130 matching lines @@
     // TODO(ricow): Remove when we track internal and pipe uses.
     assert(resourceInfo != null || isPipe || isInternal);
     if (resourceInfo != null) {
       resourceInfo.addWrite(result);
     }
     return result;
   }
 
   int send(List<int> buffer, int offset, int bytes,
            InternetAddress address, int port) {
+    _throwOnBadPort(port);
     if (isClosing || isClosed) return 0;
     _BufferAndStart bufferAndStart =
         _ensureFastAndSerializableByteData(
             buffer, offset, bytes);
     var result = nativeSendTo(
         bufferAndStart.buffer, bufferAndStart.start, bytes,
         address._in_addr, port);
     if (result is OSError) {
       scheduleMicrotask(() => reportError(result, "Send failed"));
       result = 0;
@@ skipping 420 matching lines @@
   final _NativeSocket _socket;
   StreamController<RawSocket> _controller;
   ReceivePort _referencePort;
   bool _v6Only;
 
   static Future<_RawServerSocket> bind(address,
                                        int port,
                                        int backlog,
                                        bool v6Only,
                                        bool shared) {
-    if (port < 0 || port > 0xFFFF)
-      throw new ArgumentError("Invalid port $port");
+    _throwOnBadPort(port);
     if (backlog < 0) throw new ArgumentError("Invalid backlog $backlog");
     return _NativeSocket.bind(address, port, backlog, v6Only, shared)
         .then((socket) => new _RawServerSocket(socket, v6Only));
   }
 
   _RawServerSocket(this._socket, this._v6Only);
 
   StreamSubscription<RawSocket> listen(void onData(RawSocket event),
                                        {Function onError,
                                         void onDone(),
@@ skipping 624 matching lines @@
       },
       error: zone.bindUnaryCallback((e) {
         _controller.addError(e);
         _socket.close();
       })
     );
   }
 
   static Future<RawDatagramSocket> bind(
       host, int port, bool reuseAddress) {
-    if (port < 0 || port > 0xffff)
-      throw new ArgumentError("Invalid port $port");
+    _throwOnBadPort(port);
     return _NativeSocket.bindDatagram(host, port, reuseAddress)
         .then((socket) => new _RawDatagramSocket(socket));
   }
 
   StreamSubscription<RawSocketEvent> listen(void onData(RawSocketEvent event),
                                             {Function onError,
                                              void onDone(),
                                              bool cancelOnError}) {
     return _controller.stream.listen(
         onData,
@@ skipping 87 matching lines @@
 Datagram _makeDatagram(List<int> data,
                        String address,
                        List<int> in_addr,
                        int port) {
   return new Datagram(
       data,
       new _InternetAddress(address, null, in_addr),
       port);
 }