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

runtime/bin/socket.h

 // 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.
 
 #ifndef BIN_SOCKET_H_
 #define BIN_SOCKET_H_
 
 #include <map>
 
 #include "platform/globals.h"
@@ skipping 15 matching lines @@
 #include "bin/thread.h"
 #include "bin/utils.h"
 
 
 namespace dart {
 namespace bin {
 
 union RawAddr {
   struct sockaddr_in in;
   struct sockaddr_in6 in6;
+  struct sockaddr_un un;
   struct sockaddr_storage ss;
   struct sockaddr addr;
 };
 
 class SocketAddress {
  public:
   enum {
     TYPE_ANY = -1,
     TYPE_IPV4,
     TYPE_IPV6,
+    TYPE_UNIX,
   };
 
   enum {
     ADDRESS_LOOPBACK_IP_V4,
     ADDRESS_LOOPBACK_IP_V6,
     ADDRESS_ANY_IP_V4,
     ADDRESS_ANY_IP_V6,
     ADDRESS_FIRST = ADDRESS_LOOPBACK_IP_V4,
     ADDRESS_LAST = ADDRESS_ANY_IP_V6,
   };
 
   explicit SocketAddress(struct sockaddr* sa);
 
   ~SocketAddress() {}
 
   int GetType() {
-    if (addr_.ss.ss_family == AF_INET6) return TYPE_IPV6;
-    return TYPE_IPV4;
+    switch (addr_.ss.ss_family) {
+      case AF_INET: return TYPE_IPV4;
+      case AF_INET6: return TYPE_IPV6;
+      case AF_UNIX: return TYPE_UNIX;
+      default:
+        UNREACHABLE();
+        return TYPE_ANY;
+    }
   }
 
-  const char* as_string() const { return as_string_; }
+  const char* as_string() const {
+    if (addr_.ss.ss_family == AF_UNIX) {
+      return addr_.un.sun_path;
+    } else {
+      return as_string_;
+    }
+  }
+
   const RawAddr& addr() const { return addr_; }
 
   static intptr_t GetAddrLength(const RawAddr& addr) {
-    ASSERT(addr.ss.ss_family == AF_INET || addr.ss.ss_family == AF_INET6);
-    return addr.ss.ss_family == AF_INET6 ?
-        sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in);
+    ASSERT(addr.ss.ss_family == AF_INET ||
+           addr.ss.ss_family == AF_INET6 ||
+           addr.ss.ss_family == AF_UNIX);
+    switch (addr.ss.ss_family) {
+      case AF_INET: return sizeof(struct sockaddr_in);
+      case AF_INET6: return sizeof(struct sockaddr_in6);
+      case AF_UNIX: return sizeof(struct sockaddr_un);
+      default:
+        UNREACHABLE();
+        return 0;
+    }
   }
 
   static intptr_t GetInAddrLength(const RawAddr& addr) {
     ASSERT(addr.ss.ss_family == AF_INET || addr.ss.ss_family == AF_INET6);
     return addr.ss.ss_family == AF_INET6 ?
         sizeof(struct in6_addr) : sizeof(struct in_addr);
   }
 
   static bool AreAddressesEqual(const RawAddr& a, const RawAddr& b) {
     if (a.ss.ss_family == AF_INET) {
       if (b.ss.ss_family != AF_INET) return false;
       return memcmp(&a.in.sin_addr, &b.in.sin_addr, sizeof(a.in.sin_addr)) == 0;
     } else if (a.ss.ss_family == AF_INET6) {
       if (b.ss.ss_family != AF_INET6) return false;
       return memcmp(&a.in6.sin6_addr,
                     &b.in6.sin6_addr,
                     sizeof(a.in6.sin6_addr)) == 0;
+    } else if (a.ss.ss_family == AF_UNIX) {
+      int len = sizeof(a.un.sun_path);
+      for (int i = 0; i < len; i++) {
+        if (a.un.sun_path[i] != b.un.sun_path[i]) return false;
+        if (a.un.sun_path[i] == '\0') return true;
+      }
+      return true;
     } else {
       UNREACHABLE();
       return false;
     }
   }
 
   static void GetSockAddr(Dart_Handle obj, RawAddr* addr) {
     Dart_TypedData_Type data_type;
     uint8_t* data = NULL;
     intptr_t len;
@@ skipping 20 matching lines @@
   static int16_t FromType(int type) {
     if (type == TYPE_ANY) return AF_UNSPEC;
     if (type == TYPE_IPV4) return AF_INET;
     ASSERT(type == TYPE_IPV6 && "Invalid type");
     return AF_INET6;
   }
 
   static void SetAddrPort(RawAddr* addr, intptr_t port) {
     if (addr->ss.ss_family == AF_INET) {
       addr->in.sin_port = htons(port);
+    } else if (addr->ss.ss_family == AF_INET6) {
+      addr->in6.sin6_port = htons(port);
     } else {
-      addr->in6.sin6_port = htons(port);
+      UNREACHABLE();
     }
   }
 
   static intptr_t GetAddrPort(const RawAddr& addr) {
     if (addr.ss.ss_family == AF_INET) {
       return ntohs(addr.in.sin_port);
+    } else if (addr.ss.ss_family == AF_INET6) {
+      return ntohs(addr.in6.sin6_port);
+    } else if (addr.ss.ss_family == AF_UNIX) {
+      return 1;  // TODO(sgjesse): Should be -1.
     } else {
-      return ntohs(addr.in6.sin6_port);
+      UNREACHABLE();
+      return -1;
     }
   }
 
   static Dart_Handle ToTypedData(const RawAddr& addr) {
     int len = GetInAddrLength(addr);
     Dart_Handle result = Dart_NewTypedData(Dart_TypedData_kUint8, len);
     if (Dart_IsError(result)) Dart_PropagateError(result);
     Dart_Handle err;
     RawAddr& raw = const_cast<RawAddr&>(addr);
     if (addr.addr.sa_family == AF_INET6) {
@@ skipping 99 matching lines @@
       intptr_t fd, const void* buffer, intptr_t num_bytes, const RawAddr& addr);
   static intptr_t RecvFrom(
       intptr_t fd, void* buffer, intptr_t num_bytes, RawAddr* addr);
   // Creates a socket which is bound and connected. The port to connect to is
   // specified as the port component of the passed RawAddr structure.
   static intptr_t CreateConnect(const RawAddr& addr);
   // Creates a socket which is bound and connected. The port to connect to is
   // specified as the port component of the passed RawAddr structure.
   static intptr_t CreateBindConnect(const RawAddr& addr,
                                     const RawAddr& source_addr);
+  static intptr_t CreateConnectUnix(const RawAddr& addr);
   // Creates a datagram socket which is bound. The port to bind
   // to is specified as the port component of the RawAddr structure.
   static intptr_t CreateBindDatagram(const RawAddr& addr, bool reuseAddress);
   static intptr_t GetPort(intptr_t fd);
   static SocketAddress* GetRemotePeer(intptr_t fd, intptr_t* port);
   static void GetError(intptr_t fd, OSError* os_error);
   static int GetType(intptr_t fd);
   static intptr_t GetStdioHandle(intptr_t num);
   static void Close(intptr_t fd);
   static bool GetNoDelay(intptr_t fd, bool* enabled);
@@ skipping 57 matching lines @@
   //
   // Returns a positive integer if the call is successful. In case of failure
   // it returns:
   //
   //   -1: system error (errno set)
   //   -5: invalid bindAddress
   static intptr_t CreateBindListen(const RawAddr& addr,
                                    intptr_t backlog,
                                    bool v6_only = false);
 
+  static intptr_t CreateBindListenUnix(const RawAddr& addr,
+                                       intptr_t backlog);
+
   // Start accepting on a newly created listening socket. If it was unable to
   // start accepting incoming sockets, the fd is invalidated.
   static bool StartAccept(intptr_t fd);
 
  private:
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(ServerSocket);
 };
 
 class ListeningSocketRegistry {
@@ skipping 30 matching lines @@
     delete mutex_;
     mutex_ = NULL;
   }
 
   // This function should be called from a dart runtime call in order to create
   // a new (potentially shared) socket.
   Dart_Handle CreateBindListen(Dart_Handle socket_object,
                                RawAddr addr,
                                intptr_t backlog,
                                bool v6_only,
-                               bool shared);
+                               bool shared,
+                               bool uds);
 
   // This should be called from the event handler for every kCloseEvent it gets
   // on listening sockets.
   //
   // Returns `true` if the last reference has been dropped and the underlying
   // socket can be closed.
   //
   // The caller is responsible for obtaining the mutex first, before calling
   // this function.
   bool CloseSafe(intptr_t socketfd);
@@ skipping 26 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ListeningSocketRegistry);
 };
 
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // BIN_SOCKET_H_