ChildPortHandshake: 10.6 fix

util/mach/child_port_handshake.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,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "util/mach/child_port_handshake.h"
 
 #include <errno.h>
-#include <fcntl.h>
 #include <pthread.h>
 #include <servers/bootstrap.h>
 #include <sys/event.h>
+#include <sys/socket.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/mac/mach_logging.h"
 #include "base/mac/scoped_mach_port.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
 #include "util/file/fd_io.h"
 #include "util/mach/child_port.h"
 #include "util/mach/mach_extensions.h"
 #include "util/mach/mach_message_server.h"
 
 namespace crashpad {
 
 ChildPortHandshake::ChildPortHandshake()
     : token_(0),
       pipe_read_(),
       pipe_write_(),
       child_port_(MACH_PORT_NULL),
       checked_in_(false) {
+  // Use socketpair() instead of pipe(). There is no way to suppress SIGPIPE on
+  // pipes in Mac OS X 10.6, because the F_SETNOSIGPIPE fcntl() command was not
+  // introduced until 10.7.
   int pipe_fds[2];
-  int rv = pipe(pipe_fds);
-  PCHECK(rv == 0) << "pipe";
+  PCHECK(socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, pipe_fds) == 0)
+      << "socketpair";
 
   pipe_read_.reset(pipe_fds[0]);
   pipe_write_.reset(pipe_fds[1]);
 
+  // Simulate pipe() semantics by shutting down the “wrong” sides of the socket.
+  PCHECK(shutdown(pipe_write_.get(), SHUT_RD) == 0) << "shutdown";
+  PCHECK(shutdown(pipe_read_.get(), SHUT_WR) == 0) << "shutdown";
+
   // SIGPIPE is undesirable when writing to this pipe. Allow broken-pipe writes
   // to fail with EPIPE instead.
-  PCHECK(fcntl(pipe_write_.get(), F_SETNOSIGPIPE, 1) == 0) << "fcntl";
+  const int value = 1;
+  PCHECK(setsockopt(
+      pipe_write_.get(), SOL_SOCKET, SO_NOSIGPIPE, &value, sizeof(value)) == 0)
+      << "setsockopt";
 }
 
 ChildPortHandshake::~ChildPortHandshake() {
 }
 
 int ChildPortHandshake::ReadPipeFD() const {
   DCHECK_NE(pipe_read_.get(), -1);
   return pipe_read_.get();
 }
 
 mach_port_t ChildPortHandshake::RunServer() {
   DCHECK_NE(pipe_read_.get(), -1);
   pipe_read_.reset();
 
   // Transfer ownership of the write pipe into this method’s scope.
   base::ScopedFD pipe_write_owner(pipe_write_.release());
 
   // Initialize the token and share it with the client via the pipe.
   token_ = base::RandUint64();
   int pipe_write = pipe_write_owner.get();
   if (!LoggingWriteFD(pipe_write, &token_, sizeof(token_))) {
+    LOG(WARNING) << "no client check-in";
     return MACH_PORT_NULL;
   }
 
   // Create a unique name for the bootstrap service mapping. Make it unguessable
   // to prevent outsiders from grabbing the name first, which would cause
   // bootstrap_check_in() to fail.
   uint64_t thread_id;
   errno = pthread_threadid_np(pthread_self(), &thread_id);
   PCHECK(errno == 0) << "pthread_threadid_np";
   std::string service_name = base::StringPrintf(
       "com.googlecode.crashpad.child_port_handshake.%d.%llu.%016llx",
       getpid(),
       thread_id,
       base::RandUint64());
   DCHECK_LT(service_name.size(), implicit_cast<size_t>(BOOTSTRAP_MAX_NAME_LEN));
 
   // Check the new service in with the bootstrap server, obtaining a receive
   // right for it.
   mach_port_t server_port;
   kern_return_t kr =
       bootstrap_check_in(bootstrap_port, service_name.c_str(), &server_port);
   BOOTSTRAP_CHECK(kr == BOOTSTRAP_SUCCESS, kr) << "bootstrap_check_in";
   base::mac::ScopedMachReceiveRight server_port_owner(server_port);
 
   // Share the service name with the client via the pipe.
   uint32_t service_name_length = service_name.size();
   if (!LoggingWriteFD(
           pipe_write, &service_name_length, sizeof(service_name_length))) {
+    LOG(WARNING) << "no client check-in";
     return MACH_PORT_NULL;
   }
 
   if (!LoggingWriteFD(pipe_write, service_name.c_str(), service_name_length)) {
+    LOG(WARNING) << "no client check-in";
     return MACH_PORT_NULL;
   }
 
   // A kqueue cannot monitor a raw Mach receive right with EVFILT_MACHPORT. It
   // requires a port set. Create a new port set and add the receive right to it.
   mach_port_t server_port_set;
   kr = mach_port_allocate(
       mach_task_self(), MACH_PORT_RIGHT_PORT_SET, &server_port_set);
   MACH_CHECK(kr == KERN_SUCCESS, kr) << "mach_port_allocate";
   base::mac::ScopedMachPortSet server_port_set_owner(server_port_set);
@@ skipping 207 matching lines @@
       bootstrap_look_up(bootstrap_port, service_name.c_str(), &server_port);
   BOOTSTRAP_CHECK(kr == BOOTSTRAP_SUCCESS, kr) << "bootstrap_look_up";
   base::mac::ScopedMachSendRight server_port_owner(server_port);
 
   // Check in with the server.
   kr = child_port_check_in(server_port, token, port, right_type);
   MACH_CHECK(kr == KERN_SUCCESS, kr) << "child_port_check_in";
 }
 
 }  // namespace crashpad