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.
+// Additional tests are in sandbox/linux/tests/unix_domain_socket_unittest.cc.

[jln (very slow on Chromium), 2014/04/24 18:32:58]

Remove this line, as base/ should not be tested by sandbox/

[mdempsky, 2014/04/24 19:00:34]

Done.

+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>()));
+
+  char buf[sizeof(kHello) + 1];

[jln (very slow on Chromium), 2014/04/24 18:32:58]

Did you add the + 1 to be able to test that you only received sizeof(kHello)
bytes despite reading potentially more?

Maybe add a comment? As-is, one could think that you're adding space for a \0.

[mdempsky, 2014/04/24 19:00:34]

Correct.
Done.

+  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));
+
+  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