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

native_client_sdk/src/libraries/nacl_io/socket/unix_socketpair_node.cc

+// Copyright 2015 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/ossocket.h"
+#ifdef PROVIDES_SOCKET_API
+
+#include <assert.h>
+#include <string.h>
+#include <algorithm>
+
+#include "nacl_io/socket/unix_event_emitter.h"
+#include "nacl_io/socket/unix_socketpair_node.h"
+
+namespace nacl_io {
+
+UnixSocketpairNode::UnixSocketpairNode(Filesystem* filesystem)
+    : SocketNode(filesystem),
+      emitter_(UnixEventEmitter::MakeUnixEventEmitter(65536)) {
+  emitter_->AttachStream(this);
+}
+
+UnixSocketpairNode::UnixSocketpairNode(Filesystem* filesystem,
+                                       const UnixSocketpairNode& peer)
+    : SocketNode(filesystem), emitter_(peer.emitter_->GetPeerEmitter()) {
+  emitter_->AttachStream(this);
+}
+
+EventEmitter* UnixSocketpairNode::GetEventEmitter() {
+  return emitter_.get();
+}
+
+Error UnixSocketpairNode::Recv_Locked(void* buffer,
+                                      size_t len,
+                                      PP_Resource* out_addr,
+                                      int* out_len) {
+  assert(emitter_.get());
+  *out_len = emitter_->ReadIn_Locked((char*)buffer, len);
+  *out_addr = 0;
+  return 0;
+}
+
+Error UnixSocketpairNode::Send_Locked(const void* buffer,
+                                      size_t len,
+                                      PP_Resource out_addr,
+                                      int* out_len) {
+  assert(emitter_.get());
+  *out_len = emitter_->WriteOut_Locked((char*)buffer, len);
+  return 0;
+}
+
+Error UnixSocketpairNode::RecvFrom(const HandleAttr& attr,
+                                   void* buf,
+                                   size_t len,
+                                   int flags,
+                                   struct sockaddr* src_addr,
+                                   socklen_t* addrlen,
+                                   int* out_len) {
+  PP_Resource addr = 0;
+  Error err = RecvHelper(attr, buf, len, flags, &addr, out_len);
+  if (0 == err) {
+    if (src_addr) {

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

Can you construct a sockaddr_un here?  Perhaps with sun_path set to '\0'?   Or
perhaps we don't have un.h available on all platforms? 

Perhaps a helper function like ResourceToSockAddr()?

Perhaps RecvHelper should be made to take sockaddr_t rather than a PP_Resource,
although I guess that could be a later change.

[avallee, 2015/09/17 16:18:01]

I can't seem to find sys/un.h on platforms including pnacl (my main use case for
adb).

I've messed around with a small test program on my workstation:
get{sock,peer}name returns addr.sun_family == AF_UNIX and does not modify
addr.sun_path (not even writing sun_path[0] = '\0'). The returned socklen value
is 2, sizeof(sun_family).

+      unsigned short family = AF_UNIX;
+      memcpy(src_addr, &family,
+             std::min(*addrlen, static_cast<socklen_t>(sizeof(family))));
+      *addrlen = sizeof(family);
+    }
+  }
+
+  return err;
+}
+
+Error UnixSocketpairNode::Send(const HandleAttr& attr,
+                               const void* buf,
+                               size_t len,
+                               int flags,
+                               int* out_len) {
+  PP_Resource addr = 0;
+  return SendHelper(attr, buf, len, flags, addr, out_len);
+}
+
+Error UnixSocketpairNode::SendTo(const HandleAttr& attr,
+                                 const void* buf,
+                                 size_t len,
+                                 int flags,
+                                 const struct sockaddr* dest_addr,
+                                 socklen_t addrlen,
+                                 int* out_len) {
+  PP_Resource addr = 0;
+  return SendHelper(attr, buf, len, flags, addr, out_len);
+}
+
+}  // namespace nacl_io
+
+#endif  // PROVIDES_SOCKET_API