DO NOT SUBMIT: Unix domain sockets. From CL 1061283003.

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 localAddress;
+  var /* InternetAddress or UnixDomainAddress */ localAddress;
 
   int available = 0;
 
   int tokens = 0;
 
   bool sendReadEvents = false;
   bool readEventIssued = false;
 
   bool sendWriteEvents = false;
   bool writeEventIssued = false;
@@ skipping 69 matching lines @@
 
   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];
+          if (host is UnixDomainAddress) 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.localAddress = address;
             var result;
             if (sourceAddress == null) {
-              result = socket.nativeCreateConnect(address._in_addr, port);
+              if (address is UnixDomainAddress) {
+                result = socket.nativeCreateConnectUnix(address.path);
+              } else {
+                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 {
               // Query the local port, for error messages.
-              socket.port;
+              if (address is !UnixDomainAddress) {
+                socket.port;
+              }
               // Set up timer for when we should retry the next address
               // (if any).
               var duration = address.isLoopback ?
                   _RETRY_DURATION_LOOPBACK :
                   _RETRY_DURATION;
               var timer = new Timer(duration, connectNext);
               connecting[socket] = timer;
               // Setup handlers for receiving the first write event which
               // indicate that the socket is fully connected.
               socket.setHandlers(
@@ skipping 26 matching lines @@
   }
 
   static Future<_NativeSocket> bind(host,
                                     int port,
                                     int backlog,
                                     bool v6Only,
                                     bool shared) {
     return new Future.value(host)
         .then((host) {
           if (host is _InternetAddress) return host;
+          if (host is UnixDomainAddress) return host;
           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.localAddress = address;
 
-          var result = socket.nativeCreateBindListen(address._in_addr,
-                                                     port,
-                                                     backlog,
-                                                     v6Only,
-                                                     shared);
+          var result;
+          if (host is UnixDomainAddress) {
+            result = socket.nativeCreateBindListenUnix(host.path,
+                                                       backlog,
+                                                       shared);
+            if (result is OSError) {
+              throw new SocketException("Failed to create server socket",
+                                        osError: result);
+          }
+          } else {
+            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,
                                       port: port);
           }
           if (port != 0) socket.localPort = port;
           socket.connectToEventHandler();
           return socket;
         });
@@ skipping 175 matching lines @@
     return localPort = result;
   }
 
   int get remotePort {
     if (isClosing || isClosed) throw const SocketException.closed();
     var result = nativeGetRemotePeer();
     if (result is OSError) throw result;
     return result[1];
   }
 
-  InternetAddress get address => localAddress;
+  /* InternetAddress or UnixDomainAddress */ get address => localAddress;
 
   InternetAddress get remoteAddress {
     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]);
+    // TODO(sgjesse): Type enum.
+    if (addr[0] == 2) {
+      return new UnixDomainAddress(addr[1]);
+    } else {
+      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 205 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,
-                     [InternetAddress address,
+                     [address,
                       int port]) {
     if (error is OSError) {
       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:
@@ skipping 201 matching lines @@
   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";
+  nativeCreateConnectUnix(String path) native "Socket_CreateConnectUnix";
   nativeCreateBindListen(List<int> addr, int port, int backlog, bool v6Only,
                          bool shared)
       native "ServerSocket_CreateBindListen";
+  nativeCreateBindListenUnix(String addr, int backlog, bool shared)
+      native "ServerSocket_CreateBindListenUnix";
   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";
   bool nativeSetOption(int option, int protocol, value)
       native "Socket_SetOption";
@@ skipping 39 matching lines @@
     var zone = Zone.current;
     _controller = new StreamController(sync: true,
         onListen: _onSubscriptionStateChange,
         onCancel: _onSubscriptionStateChange,
         onPause: _onPauseStateChange,
         onResume: _onPauseStateChange);
     _socket.setHandlers(
       read: zone.bindCallback(() {
         while (_socket.available > 0) {
           var socket = _socket.accept();
-          if (socket == null) return;
+          if (socket == null) {
+            return;
+          }
           _controller.add(new _RawSocket(socket));
           if (_controller.isPaused) return;
         }
       }),
       error: zone.bindUnaryCallback((e) {
         _controller.addError(e);
         _controller.close();
       }),
       destroyed: () {
         _controller.close();
@@ skipping 768 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();