Add and use scoped-right-returning wrappers for Mach bootstrap routines

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 <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"
@@ skipping 65 matching lines @@
   // 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);
+  base::mac::ScopedMachReceiveRight server_port(BootstrapCheckIn(service_name));
+  CHECK_NE(server_port, kMachPortNull);
 
   // Share the service name with the client via the pipe.
   uint32_t service_name_length = service_name.size();
   if (!LoggingWriteFile(
           pipe_write, &service_name_length, sizeof(service_name_length))) {
     LOG(WARNING) << "no client check-in";
     return MACH_PORT_NULL;
   }
 
   if (!LoggingWriteFile(
           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.
   base::mac::ScopedMachPortSet server_port_set(
       NewMachPort(MACH_PORT_RIGHT_PORT_SET));
   CHECK_NE(server_port_set, kMachPortNull);
 
-  kr = mach_port_insert_member(mach_task_self(), server_port, server_port_set);
+  kern_return_t kr =
+      mach_port_insert_member(mach_task_self(), server_port, server_port_set);
   MACH_CHECK(kr == KERN_SUCCESS, kr) << "mach_port_insert_member";
 
   // Set up a kqueue to monitor both the server’s receive right and the write
   // side of the pipe. Messages from the client will be received via the receive
   // right, and the pipe will show EOF if the client closes its read side
   // prematurely.
   base::ScopedFD kq(kqueue());
   PCHECK(kq != -1) << "kqueue";
 
   struct kevent changelist[2];
@@ skipping 164 matching lines @@
 // static
 void ChildPortHandshake::RunClientInternal_ReadPipe(int pipe_read,
                                                     child_port_token_t* token,
                                                     std::string* service_name) {
   // Read the token from the pipe.
   CheckedReadFile(pipe_read, token, sizeof(*token));
 
   // Read the service name from the pipe.
   uint32_t service_name_length;
   CheckedReadFile(pipe_read, &service_name_length, sizeof(service_name_length));
-  DCHECK_LT(service_name_length,
-            implicit_cast<uint32_t>(BOOTSTRAP_MAX_NAME_LEN));
 
   service_name->resize(service_name_length);
   if (!service_name->empty()) {
     CheckedReadFile(pipe_read, &(*service_name)[0], service_name_length);
   }
 }
 
 // static
 void ChildPortHandshake::RunClientInternal_SendCheckIn(
     const std::string& service_name,
     child_port_token_t token,
     mach_port_t port,
     mach_msg_type_name_t right_type) {
   // Get a send right to the server by looking up the service with the bootstrap
   // server by name.
-  mach_port_t server_port;
-  kern_return_t kr =
-      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);
+  base::mac::ScopedMachSendRight server_port(BootstrapLookUp(service_name));
+  CHECK_NE(server_port, kMachPortNull);
 
   // Check in with the server.
-  kr = child_port_check_in(server_port, token, port, right_type);
+  kern_return_t kr = child_port_check_in(server_port, token, port, right_type);
   MACH_CHECK(kr == KERN_SUCCESS, kr) << "child_port_check_in";
 }
 
 }  // namespace crashpad