Stop using chrome-sandbox to determine real pids

content/browser/renderer_host/sandbox_ipc_linux.cc

 // Copyright 2014 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 "content/browser/renderer_host/sandbox_ipc_linux.h"
 
 #include <fcntl.h>
 #include <fontconfig/fontconfig.h>
 #include <sys/poll.h>
 #include <sys/socket.h>
@@ skipping 140 matching lines @@
   SetProcessTitleFromCommandLine(NULL);
 }
 
 void SandboxIPCProcess::Run() {
   struct pollfd pfds[2];
   pfds[0].fd = lifeline_fd_;
   pfds[0].events = POLLIN;
   pfds[1].fd = browser_socket_;
   pfds[1].events = POLLIN;
 
+  if (!UnixDomainSocket::EnableReceiveProcessId(browser_socket_))
+    LOG(FATAL) << "failed to enable receiving PIDs";
+
   int failed_polls = 0;
   for (;;) {
     const int r = HANDLE_EINTR(poll(pfds, 2, -1 /* no timeout */));
     // '0' is not a possible return value with no timeout.
     DCHECK_NE(0, r);
     if (r < 0) {
       PLOG(WARNING) << "poll";
       if (failed_polls++ == 3) {
         LOG(FATAL) << "poll(2) failing. RenderSandboxHostLinux aborting.";
         return;
       }
       continue;
     }
 
     failed_polls = 0;
 
     if (pfds[0].revents) {
       // our parent died so we should too.
       _exit(0);
     }
 
     if (pfds[1].revents) {
       HandleRequestFromRenderer(browser_socket_);
     }
   }
 }
 
 void SandboxIPCProcess::HandleRequestFromRenderer(int fd) {
   std::vector<int> fds;
+  base::ProcessId sender_pid;
 
   // A FontConfigIPC::METHOD_MATCH message could be kMaxFontFamilyLength
   // bytes long (this is the largest message type).
   // 128 bytes padding are necessary so recvmsg() does not return MSG_TRUNC
   // error for a maximum length message.
   char buf[FontConfigIPC::kMaxFontFamilyLength + 128];
 
-  const ssize_t len = UnixDomainSocket::RecvMsg(fd, buf, sizeof(buf), &fds);
+  const ssize_t len =
+      UnixDomainSocket::RecvMsgWithPid(fd, buf, sizeof(buf), &fds, &sender_pid);
   if (len == -1) {
     // TODO: should send an error reply, or the sender might block forever.
     NOTREACHED() << "Sandbox host message is larger than kMaxFontFamilyLength";
     return;
   }
   if (fds.empty())
     return;
 
   Pickle pickle(buf, len);
   PickleIterator iter(pickle);
@@ skipping 11 matching lines @@
   } else if (kind == LinuxSandbox::METHOD_LOCALTIME) {
     HandleLocaltime(fd, pickle, iter, fds);
   } else if (kind == LinuxSandbox::METHOD_GET_CHILD_WITH_INODE) {
     HandleGetChildWithInode(fd, pickle, iter, fds);
   } else if (kind == LinuxSandbox::METHOD_GET_STYLE_FOR_STRIKE) {
     HandleGetStyleForStrike(fd, pickle, iter, fds);
   } else if (kind == LinuxSandbox::METHOD_MAKE_SHARED_MEMORY_SEGMENT) {
     HandleMakeSharedMemorySegment(fd, pickle, iter, fds);
   } else if (kind == LinuxSandbox::METHOD_MATCH_WITH_FALLBACK) {
     HandleMatchWithFallback(fd, pickle, iter, fds);
+  } else if (kind == LinuxSandbox::METHOD_GET_REAL_PID) {
+    HandleGetRealPid(fd, pickle, iter, fds, sender_pid);
   }
 
 error:
   for (std::vector<int>::const_iterator i = fds.begin(); i != fds.end(); ++i) {
     close(*i);
   }
 }
 
 int SandboxIPCProcess::FindOrAddPath(const SkString& path) {
   int count = paths_.count();
@@ skipping 367 matching lines @@
 
   Pickle reply;
   SendRendererReply(fds, reply, font_fd);
 
   if (font_fd >= 0) {
     if (IGNORE_EINTR(close(font_fd)) < 0)
       PLOG(ERROR) << "close";
   }
 }
 
+void SandboxIPCProcess::HandleGetRealPid(int fd,
+                                         const Pickle& pickle,
+                                         PickleIterator iter,
+                                         std::vector<int>& fds,
+                                         base::ProcessId sender_pid) {
+  if (fds.size() != 2)
+    return;
+
+  bool return_pid;
+  if (!iter.ReadBool(&return_pid))
+    return;
+
+  // Write it to the zygote process.
+  const ssize_t written =
+      HANDLE_EINTR(write(fds[1], &sender_pid, sizeof(sender_pid)));
+  if (written != sizeof(sender_pid))
+    LOG(ERROR) << "Failed to write real pid to zygote";
+
+  Pickle reply;
+  reply.WriteInt(return_pid ? sender_pid : 0);
+  SendRendererReply(fds, reply, -1);
+}
+
 void SandboxIPCProcess::SendRendererReply(const std::vector<int>& fds,
                                           const Pickle& reply,
                                           int reply_fd) {
   struct msghdr msg;
   memset(&msg, 0, sizeof(msg));
   struct iovec iov = {const_cast<void*>(reply.data()), reply.size()};
   msg.msg_iov = &iov;
   msg.msg_iovlen = 1;
 
   char control_buffer[CMSG_SPACE(sizeof(int))];
@@ skipping 29 matching lines @@
 }
 
 void SandboxIPCProcess::EnsureWebKitInitialized() {
   if (webkit_platform_support_)
     return;
   webkit_platform_support_.reset(new BlinkPlatformImpl);
   blink::initializeWithoutV8(webkit_platform_support_.get());
 }
 
 }  // namespace content