mac: Don’t leak send rights from ExceptionPorts::GetExceptionPorts()

util/mach/exception_ports_test.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 46 matching lines @@
 // validation.
 void TestGetExceptionPorts(const ExceptionPorts& exception_ports,
                            mach_port_t expect_port,
                            exception_behavior_t expect_behavior) {
   const exception_mask_t kExceptionMask = EXC_MASK_CRASH;
 
   thread_state_flavor_t expect_flavor = (expect_behavior == EXCEPTION_DEFAULT)
                                             ? THREAD_STATE_NONE
                                             : MACHINE_THREAD_STATE;
 
-  std::vector<ExceptionPorts::ExceptionHandler> crash_handler;
+  ExceptionPorts::ExceptionHandlerVector crash_handler;
   ASSERT_TRUE(
       exception_ports.GetExceptionPorts(kExceptionMask, &crash_handler));
 
   if (expect_port != MACH_PORT_NULL) {
     ASSERT_EQ(1u, crash_handler.size());
-    base::mac::ScopedMachSendRight port_owner(crash_handler[0].port);
 
     EXPECT_EQ(kExceptionMask, crash_handler[0].mask);
     EXPECT_EQ(expect_port, crash_handler[0].port);
     EXPECT_EQ(expect_behavior, crash_handler[0].behavior);
     EXPECT_EQ(expect_flavor, crash_handler[0].flavor);
   } else {
     EXPECT_TRUE(crash_handler.empty());
   }
 
-  std::vector<ExceptionPorts::ExceptionHandler> handlers;
+  ExceptionPorts::ExceptionHandlerVector handlers;
   ASSERT_TRUE(exception_ports.GetExceptionPorts(ExcMaskValid(), &handlers));
 
   EXPECT_GE(handlers.size(), crash_handler.size());
   bool found = false;
   for (const ExceptionPorts::ExceptionHandler& handler : handlers) {
     if ((handler.mask & kExceptionMask) != 0) {
-      base::mac::ScopedMachSendRight port_owner(handler.port);
-
       EXPECT_FALSE(found);
       found = true;
       EXPECT_EQ(expect_port, handler.port);
       EXPECT_EQ(expect_behavior, handler.behavior);
       EXPECT_EQ(expect_flavor, handler.flavor);
     }
   }
 
   if (expect_port != MACH_PORT_NULL) {
     EXPECT_TRUE(found);
@@ skipping 477 matching lines @@
 
 TEST(ExceptionPorts, HostExceptionPorts) {
   // ExceptionPorts isn’t expected to work as non-root. Just do a quick test to
   // make sure that TargetTypeName() returns the right string, and that the
   // underlying host_get_exception_ports() function appears to be called by
   // looking for a KERN_INVALID_ARGUMENT return value. Or, on the off chance
   // that the test is being run as root, just look for KERN_SUCCESS.
   // host_set_exception_ports() is not tested, because if the test were running
   // as root and the call succeeded, it would have global effects.
 
+  const bool expect_success = geteuid() == 0;
+
   base::mac::ScopedMachSendRight host(mach_host_self());
   ExceptionPorts explicit_host_ports(ExceptionPorts::kTargetTypeHost, host);
   EXPECT_STREQ("host", explicit_host_ports.TargetTypeName());
 
-  std::vector<ExceptionPorts::ExceptionHandler> handlers;
-  bool rv = explicit_host_ports.GetExceptionPorts(ExcMaskValid(), &handlers);
-  if (geteuid() == 0) {
-    EXPECT_TRUE(rv);
-  } else {
-    EXPECT_FALSE(rv);
-  }
+  ExceptionPorts::ExceptionHandlerVector explicit_handlers;
+  bool rv =
+      explicit_host_ports.GetExceptionPorts(ExcMaskValid(), &explicit_handlers);
+  EXPECT_EQ(expect_success, rv);
 
   ExceptionPorts implicit_host_ports(ExceptionPorts::kTargetTypeHost,
                                      HOST_NULL);
   EXPECT_STREQ("host", implicit_host_ports.TargetTypeName());
 
-  rv = implicit_host_ports.GetExceptionPorts(ExcMaskValid(), &handlers);
-  if (geteuid() == 0) {
-    EXPECT_TRUE(rv);
-  } else {
-    EXPECT_FALSE(rv);
-  }
+  ExceptionPorts::ExceptionHandlerVector implicit_handlers;
+  rv =
+      implicit_host_ports.GetExceptionPorts(ExcMaskValid(), &implicit_handlers);
+  EXPECT_EQ(expect_success, rv);
+
+  EXPECT_EQ(explicit_handlers.size(), implicit_handlers.size());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad