[NaCl SDK] nacl_io: Add support for basic socketpairs.

native_client_sdk/src/libraries/nacl_io/kernel_proxy.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "nacl_io/kernel_proxy.h"
 
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
@@ skipping 21 matching lines @@
 #include "nacl_io/osinttypes.h"
 #include "nacl_io/osmman.h"
 #include "nacl_io/ossocket.h"
 #include "nacl_io/osstat.h"
 #include "nacl_io/passthroughfs/passthrough_fs.h"
 #include "nacl_io/path.h"
 #include "nacl_io/pepper_interface.h"
 #include "nacl_io/pipe/pipe_node.h"
 #include "nacl_io/socket/tcp_node.h"
 #include "nacl_io/socket/udp_node.h"
+#include "nacl_io/socket/unix_socketpair_node.h"
 #include "nacl_io/stream/stream_fs.h"
 #include "nacl_io/typed_fs_factory.h"
 #include "sdk_util/auto_lock.h"
 #include "sdk_util/ref_object.h"
 #include "sdk_util/string_util.h"
 
 #ifndef MAXPATHLEN
 #define MAXPATHLEN 256
 #endif
 
@@ skipping 1754 matching lines @@
 
   return AllocateFD(handle);
 }
 
 int KernelProxy::socketpair(int domain, int type, int protocol, int* sv) {
   if (NULL == sv) {
     errno = EFAULT;
     return -1;
   }
 
+  if (AF_INET == domain || AF_INET6 == domain) {
+    errno = EOPNOTSUPP;
+    return -1;
+  }
+
   // Catch-22: We don't support AF_UNIX, but any other AF doesn't support
   // socket pairs. Thus, this function always fails.
-  if (AF_UNIX != domain) {
+  if (AF_UNIX == domain) {
+    int open_flags = O_RDWR;
+
+#if defined(SOCK_CLOEXEC)
+    if (type & SOCK_CLOEXEC) {
+#if defined(O_CLOEXEC)
+      // The NaCl newlib version of fcntl.h doesn't currently define
+      // O_CLOEXEC.
+      // TODO(sbc): remove this guard once it gets added.
+      open_flags |= O_CLOEXEC;
+#endif
+      type &= ~SOCK_CLOEXEC;
+    }
+#endif
+
+#if defined(SOCK_NONBLOCK)
+    if (type & SOCK_NONBLOCK) {
+      open_flags |= O_NONBLOCK;
+      type &= ~SOCK_NONBLOCK;
+    }
+#endif
+
+    UnixSocketpairNode* socket = new UnixSocketpairNode(stream_fs_.get());
+    Error rtn = socket->Init(O_RDWR);
+    if (rtn != 0) {
+      errno = rtn;
+      return -1;
+    }
+    ScopedNode node0(socket);
+    socket = new UnixSocketpairNode(stream_fs_.get(), *socket);
+    rtn = socket->Init(O_RDWR);
+    if (rtn != 0) {
+      errno = rtn;
+      return -1;
+    }
+    ScopedNode node1(socket);
+    ScopedKernelHandle handle0(new KernelHandle(stream_fs_, node0));
+    rtn = handle0->Init(open_flags);
+    if (rtn != 0) {
+      errno = rtn;
+      return -1;
+    }
+    ScopedKernelHandle handle1(new KernelHandle(stream_fs_, node1));
+    rtn = handle1->Init(open_flags);
+    if (rtn != 0) {
+      errno = rtn;
+      return -1;
+    }
+
+    sv[0] = AllocateFD(handle0);
+    sv[1] = AllocateFD(handle1);
+
+    return 0;
+  } else {
     errno = EPROTONOSUPPORT;
     return -1;

[Sam Clegg, 2015/09/17 09:40:39]

Can you use early return if domain != AF_UNIX then remove nesting of the success
(return 0) path?

[avallee, 2015/09/17 19:00:31]

Done.

   }
 
-  if (AF_INET != domain && AF_INET6 != domain) {
-    errno = EAFNOSUPPORT;
-    return -1;
-  }
-
   // We cannot reach this point.
   errno = ENOSYS;
   return -1;
 }
 
 int KernelProxy::AcquireSocketHandle(int fd, ScopedKernelHandle* handle) {
   Error error = AcquireHandle(fd, handle);
 
   if (error) {
     errno = error;
     return -1;
   }
 
   if ((handle->get()->node_->GetType() & S_IFSOCK) == 0) {
     errno = ENOTSOCK;
     return -1;
   }
 
   return 0;
 }
 
 #endif  // PROVIDES_SOCKET_API
 
 }  // namespace_nacl_io