ChildPortHandshake: allow receive rights to be received

client/crashpad_client_mac.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 79 matching lines @@
     const base::FilePath& handler,
     const base::FilePath& database,
     const std::string& url,
     const std::map<std::string, std::string>& annotations,
     const std::vector<std::string>& arguments) {
   DCHECK(!exception_port_.is_valid());
 
   // Set up the arguments for execve() first. These aren’t needed until execve()
   // is called, but it’s dangerous to do this in a child process after fork().
   ChildPortHandshake child_port_handshake;
-  int handshake_fd = child_port_handshake.ReadPipeFD();
+  base::ScopedFD client_read_fd = child_port_handshake.ClientReadFD();
 
   // Use handler as argv[0], followed by arguments directed by this method’s
   // parameters and a --handshake-fd argument. |arguments| are added first so
   // that if it erroneously contains an argument such as --url, the actual |url|
   // argument passed to this method will supersede it. In normal command-line
   // processing, the last parameter wins in the case of a conflict.
   std::vector<std::string> argv(1, handler.value());
   argv.reserve(1 + arguments.size() + 2 + annotations.size() + 1);
   for (const std::string& argument : arguments) {
     argv.push_back(argument);
   }
   if (!database.value().empty()) {
     argv.push_back(FormatArgumentString("database", database.value()));
   }
   if (!url.empty()) {
     argv.push_back(FormatArgumentString("url", url));
   }
   for (const auto& kv : annotations) {
     argv.push_back(
         FormatArgumentString("annotation", kv.first + '=' + kv.second));
   }
-  argv.push_back(FormatArgumentInt("handshake-fd", handshake_fd));
+  argv.push_back(FormatArgumentInt("handshake-fd", client_read_fd.get()));
 
   // argv_c contains const char* pointers and is terminated by nullptr. argv
   // is required because the pointers in argv_c need to point somewhere, and
   // they can’t point to temporaries such as those returned by
   // FormatArgumentString().
   std::vector<const char*> argv_c;
   argv_c.reserve(argv.size() + 1);
   for (const std::string& argument : argv) {
     argv_c.push_back(argument.c_str());
   }
@@ skipping 41 matching lines @@
 
     if (pid > 0) {
       // Child process.
 
       // _exit() instead of exit(), because fork() was called.
       _exit(EXIT_SUCCESS);
     }
 
     // Grandchild process.
 
-    CloseMultipleNowOrOnExec(STDERR_FILENO + 1, handshake_fd);
+    CloseMultipleNowOrOnExec(STDERR_FILENO + 1, client_read_fd.get());
 
     // &argv_c[0] is a pointer to a pointer to const char data, but because of
     // how C (not C++) works, execvp() wants a pointer to a const pointer to
     // char data. It modifies neither the data nor the pointers, so the
     // const_cast is safe.
     execvp(handler.value().c_str(), const_cast<char* const*>(&argv_c[0]));
     PLOG(FATAL) << "execvp " << handler.value();
   }
 
   // Parent process.
 
+  client_read_fd.reset();
+
   // waitpid() for the child, so that it does not become a zombie process. The
   // child normally exits quickly.
   int status;
   pid_t wait_pid = HANDLE_EINTR(waitpid(pid, &status, 0));
   PCHECK(wait_pid != -1) << "waitpid";
   DCHECK_EQ(wait_pid, pid);
 
   if (WIFSIGNALED(status)) {
     LOG(WARNING) << "intermediate process: signal " << WTERMSIG(status);
   } else if (!WIFEXITED(status)) {
     DLOG(WARNING) << "intermediate process: unknown termination " << status;
   } else if (WEXITSTATUS(status) != EXIT_SUCCESS) {
     LOG(WARNING) << "intermediate process: exit status " << WEXITSTATUS(status);
   }
 
   // Rendezvous with the handler running in the grandchild process.
-  exception_port_.reset(child_port_handshake.RunServer());
+  exception_port_.reset(child_port_handshake.RunServer(
+      ChildPortHandshake::PortRightType::kSendRight));
 
   return exception_port_.is_valid();
 }
 
 bool CrashpadClient::UseHandler() {
   DCHECK(exception_port_.is_valid());
 
   return SetCrashExceptionPorts(exception_port_.get());
 }
 
 // static
 void CrashpadClient::UseSystemDefaultHandler() {
   base::mac::ScopedMachSendRight
       system_crash_reporter_handler(SystemCrashReporterHandler());
 
   // Proceed even if SystemCrashReporterHandler() failed, setting MACH_PORT_NULL
   // to clear the current exception ports.
   if (!SetCrashExceptionPorts(system_crash_reporter_handler.get())) {
     SetCrashExceptionPorts(MACH_PORT_NULL);
   }
 }
 
 }  // namespace crashpad