[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/unixsocket_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;
   }
 
-  // Catch-22: We don't support AF_UNIX, but any other AF doesn't support
-  // socket pairs. Thus, this function always fails.
+  if (AF_INET == domain || AF_INET6 == domain) {
+    errno = EOPNOTSUPP;
+    return -1;
+  }
+
   if (AF_UNIX != domain) {
     errno = EPROTONOSUPPORT;

[Sam Clegg, 2015/09/22 17:53:44]

Can you combine the these two conditionals?   Is EPROTONOSUPPORT really the
correct error here?    Should we also check for supported 'protocol'?

[avallee, 2015/09/22 20:25:06]

Good point, I read the socketpair page many times to make sure the errors made
sense, but EPROTONOSUPPORT means family/protocol mismatch. Currently this means
AF_UNIX/SOCK_DGRAM is EPROTONOSUPPORT

Every other family should return EAFNOSUPPORT if we don't support it and
EOPNOTSUPP if we somehow support the family, but not for socketpairs.

     return -1;
   }
 
-  if (AF_INET != domain && AF_INET6 != domain) {
-    errno = EAFNOSUPPORT;
+  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
+
+  UnixSocketNode* socket = new UnixSocketNode(stream_fs_.get());
+  Error rtn = socket->Init(O_RDWR);
+  if (rtn != 0) {
+    errno = rtn;
+    return -1;
+  }
+  ScopedNode node0(socket);
+  socket = new UnixSocketNode(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;
   }
 
-  // We cannot reach this point.
-  errno = ENOSYS;
-  return -1;
+  sv[0] = AllocateFD(handle0);
+  sv[1] = AllocateFD(handle1);
+
+  return 0;
 }
 
 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