Extend UnixDomainSocket::RecvMsg to return sender's PID

base/posix/unix_domain_socket_linux_unittest.cc

 // Copyright (c) 2013 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 <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 59 matching lines @@
   // message is sent with MSG_NOSIGNAL, this shall result in SIGPIPE.
   Pickle request;
   ASSERT_EQ(-1,
       UnixDomainSocket::SendRecvMsg(fds[1], static_cast<uint8_t*>(NULL),
                                     0U, static_cast<int*>(NULL), request));
   ASSERT_EQ(EPIPE, errno);
   // Restore the SIGPIPE handler.
   ASSERT_EQ(0, sigaction(SIGPIPE, &oldact, NULL));
 }
 
+// Simple sanity check within a single process that receiving PIDs works.
+TEST(UnixDomainSocketTest, RecvPid) {
+  int fds[2];
+  ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_SEQPACKET, 0, fds));
+  base::ScopedFD recv_sock(fds[0]);
+  base::ScopedFD send_sock(fds[1]);
+
+  ASSERT_TRUE(UnixDomainSocket::EnableReceiveProcessId(recv_sock.get()));
+
+  static const char kHello[] = "hello";
+  ASSERT_TRUE(UnixDomainSocket::SendMsg(
+      send_sock.get(), kHello, sizeof(kHello), std::vector<int>()));

[willchan no longer on Chromium, 2014/04/24 20:44:04]

Generally we prefer arraysize to sizeof for arrays.

[mdempsky, 2014/04/24 20:59:14]

Noted, but the APIs used here take the number of bytes, not the number of array
elements.  In this case, they're the same because kHello is an array of chars
(and sizeof(char) == 1 by definition), but if we changed it to an array of
wchar_t, using arraysize() would be incorrect.

Do you still prefer that I change it to use arraysize() instead of sizeof()?

[willchan no longer on Chromium, 2014/04/24 21:09:56]

Oops, I missed that. Fine as is.

+
+  // Extra receiving buffer space to make sure we really received only
+  // sizeof(kHello) bytes and it wasn't just truncated to fit the buffer.
+  char buf[sizeof(kHello) + 1];
+  base::ProcessId sender_pid;
+  std::vector<int> fd_vec;
+  const ssize_t nread = UnixDomainSocket::RecvMsgWithPid(
+      recv_sock.get(), buf, sizeof(buf), &fd_vec, &sender_pid);
+  ASSERT_EQ(sizeof(kHello), static_cast<size_t>(nread));
+  ASSERT_EQ(0, memcmp(buf, kHello, sizeof(kHello)));
+  ASSERT_EQ(0U, fd_vec.size());
+
+  ASSERT_EQ(getpid(), sender_pid);
+}
+
+// Same as above, but send the max number of file descriptors too.
+TEST(UnixDomainSocketTest, RecvPidWithMaxDescriptors) {
+  int fds[2];
+  ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_SEQPACKET, 0, fds));
+  base::ScopedFD recv_sock(fds[0]);
+  base::ScopedFD send_sock(fds[1]);
+
+  ASSERT_TRUE(UnixDomainSocket::EnableReceiveProcessId(recv_sock.get()));
+
+  static const char kHello[] = "hello";
+  std::vector<int> fd_vec(UnixDomainSocket::kMaxFileDescriptors,
+                          send_sock.get());
+  ASSERT_TRUE(UnixDomainSocket::SendMsg(
+      send_sock.get(), kHello, sizeof(kHello), fd_vec));
+
+  // Extra receiving buffer space to make sure we really received only
+  // sizeof(kHello) bytes and it wasn't just truncated to fit the buffer.
+  char buf[sizeof(kHello) + 1];
+  base::ProcessId sender_pid;
+  const ssize_t nread = UnixDomainSocket::RecvMsgWithPid(
+      recv_sock.get(), buf, sizeof(buf), &fd_vec, &sender_pid);
+  ASSERT_EQ(sizeof(kHello), static_cast<size_t>(nread));
+  ASSERT_EQ(0, memcmp(buf, kHello, sizeof(kHello)));
+  ASSERT_EQ(UnixDomainSocket::kMaxFileDescriptors, fd_vec.size());
+  for (size_t i = 0; i < UnixDomainSocket::kMaxFileDescriptors; i++) {
+    ASSERT_EQ(0, IGNORE_EINTR(close(fd_vec[i])));
+  }
+
+  ASSERT_EQ(getpid(), sender_pid);
+}
+
 }  // namespace
 
 }  // namespace base