| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 The Crashpad Authors. All rights reserved. | |
| 2 // | |
| 3 // Licensed under the Apache License, Version 2.0 (the "License"); | |
| 4 // you may not use this file except in compliance with the License. | |
| 5 // You may obtain a copy of the License at | |
| 6 // | |
| 7 // http://www.apache.org/licenses/LICENSE-2.0 | |
| 8 // | |
| 9 // Unless required by applicable law or agreed to in writing, software | |
| 10 // distributed under the License is distributed on an "AS IS" BASIS, | |
| 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| 12 // See the License for the specific language governing permissions and | |
| 13 // limitations under the License. | |
| 14 | |
| 15 #include <errno.h> | |
| 16 #include <getopt.h> | |
| 17 #include <libgen.h> | |
| 18 #include <mach/mach.h> | |
| 19 #include <servers/bootstrap.h> | |
| 20 #include <stdio.h> | |
| 21 #include <stdlib.h> | |
| 22 #include <string.h> | |
| 23 #include <unistd.h> | |
| 24 | |
| 25 #include <string> | |
| 26 #include <vector> | |
| 27 | |
| 28 #include "base/basictypes.h" | |
| 29 #include "base/mac/mach_logging.h" | |
| 30 #include "base/mac/scoped_mach_port.h" | |
| 31 #include "base/strings/stringprintf.h" | |
| 32 #include "tools/tool_support.h" | |
| 33 #include "util/mach/exception_ports.h" | |
| 34 #include "util/mach/mach_extensions.h" | |
| 35 #include "util/mach/symbolic_constants_mach.h" | |
| 36 #include "util/mach/task_for_pid.h" | |
| 37 #include "util/posix/drop_privileges.h" | |
| 38 #include "util/stdlib/string_number_conversion.h" | |
| 39 | |
| 40 namespace crashpad { | |
| 41 namespace { | |
| 42 | |
| 43 //! \brief Manages a pool of Mach send rights, deallocating all send rights upon | |
| 44 //! destruction. | |
| 45 //! | |
| 46 //! This class effectively implements what a vector of | |
| 47 //! base::mac::ScopedMachSendRight objects would be. | |
| 48 //! | |
| 49 //! The various “show” operations performed by this program display Mach ports | |
| 50 //! by their names as they are known in this task. For this to be useful, rights | |
| 51 //! to the same ports must have consistent names across successive calls. This | |
| 52 //! cannot be guaranteed if the rights are deallocated as soon as they are used, | |
| 53 //! because if that deallocation causes the task to lose its last right to a | |
| 54 //! port, subsequently regaining a right to the same port would cause it to be | |
| 55 //! known by a new name in this task. | |
| 56 //! | |
| 57 //! Instead of immediately deallocating send rights that are used for display, | |
| 58 //! they can be added to this pool. The pool collects send rights, ensuring that | |
| 59 //! they remain alive in this task, and that subsequent calls that obtain the | |
| 60 //! same rights cause them to be known by the same name. All rights are | |
| 61 //! deallocated upon destruction. | |
| 62 class MachSendRightPool { | |
| 63 public: | |
| 64 MachSendRightPool() | |
| 65 : send_rights_() { | |
| 66 } | |
| 67 | |
| 68 ~MachSendRightPool() { | |
| 69 for (mach_port_t send_right : send_rights_) { | |
| 70 kern_return_t kr = mach_port_deallocate(mach_task_self(), send_right); | |
| 71 MACH_LOG_IF(ERROR, kr != KERN_SUCCESS, kr) << "mach_port_deallocate"; | |
| 72 } | |
| 73 } | |
| 74 | |
| 75 //! \brief Adds a send right to the pool. | |
| 76 //! | |
| 77 //! \param[in] send_right The send right to be added. The pool object takes | |
| 78 //! ownership of the send right, which remains valid until the pool object | |
| 79 //! is destroyed. | |
| 80 //! | |
| 81 //! It is possible and in fact likely that one pool will wind up owning the | |
| 82 //! same send right multiple times. This is acceptable, because send rights | |
| 83 //! are reference-counted. | |
| 84 void AddSendRight(mach_port_t send_right) { | |
| 85 send_rights_.push_back(send_right); | |
| 86 } | |
| 87 | |
| 88 private: | |
| 89 std::vector<mach_port_t> send_rights_; | |
| 90 | |
| 91 DISALLOW_COPY_AND_ASSIGN(MachSendRightPool); | |
| 92 }; | |
| 93 | |
| 94 struct ExceptionHandlerDescription { | |
| 95 ExceptionPorts::TargetType target_type; | |
| 96 exception_mask_t mask; | |
| 97 exception_behavior_t behavior; | |
| 98 thread_state_flavor_t flavor; | |
| 99 std::string handler; | |
| 100 }; | |
| 101 | |
| 102 const char kHandlerNull[] = "NULL"; | |
| 103 const char kHandlerBootstrapColon[] = "bootstrap:"; | |
| 104 | |
| 105 // Populates |description| based on a textual representation in | |
| 106 // |handler_string_ro|, returning true on success and false on failure (parse | |
| 107 // error). The --help string describes the format of |handler_string_ro|. | |
| 108 // Briefly, it is a comma-separated string that allows the members of | |
| 109 // |description| to be specified as "field=value". Values for "target" can be | |
| 110 // "host", "task", or "thread"; values for "handler" are of the form | |
| 111 // "bootstrap:service_name" where service_name will be looked up with the | |
| 112 // bootstrap server; and values for the other fields are interpreted by | |
| 113 // SymbolicConstantsMach. | |
| 114 bool ParseHandlerString(const char* handler_string_ro, | |
| 115 ExceptionHandlerDescription* description) { | |
| 116 const char kTargetEquals[] = "target="; | |
| 117 const char kMaskEquals[] = "mask="; | |
| 118 const char kBehaviorEquals[] = "behavior="; | |
| 119 const char kFlavorEquals[] = "flavor="; | |
| 120 const char kHandlerEquals[] = "handler="; | |
| 121 | |
| 122 std::string handler_string(handler_string_ro); | |
| 123 char* handler_string_c = &handler_string[0]; | |
| 124 | |
| 125 char* token; | |
| 126 while ((token = strsep(&handler_string_c, ",")) != nullptr) { | |
| 127 if (strncmp(token, kTargetEquals, strlen(kTargetEquals)) == 0) { | |
| 128 const char* value = token + strlen(kTargetEquals); | |
| 129 if (strcmp(value, "host") == 0) { | |
| 130 description->target_type = ExceptionPorts::kTargetTypeHost; | |
| 131 } else if (strcmp(value, "task") == 0) { | |
| 132 description->target_type = ExceptionPorts::kTargetTypeTask; | |
| 133 } else if (strcmp(value, "thread") == 0) { | |
| 134 description->target_type = ExceptionPorts::kTargetTypeThread; | |
| 135 } else { | |
| 136 return false; | |
| 137 } | |
| 138 } else if (strncmp(token, kMaskEquals, strlen(kMaskEquals)) == 0) { | |
| 139 const char* value = token + strlen(kMaskEquals); | |
| 140 if (!StringToExceptionMask( | |
| 141 value, | |
| 142 kAllowFullName | kAllowShortName | kAllowNumber | kAllowOr, | |
| 143 &description->mask)) { | |
| 144 return false; | |
| 145 } | |
| 146 } else if (strncmp(token, kBehaviorEquals, strlen(kBehaviorEquals)) == 0) { | |
| 147 const char* value = token + strlen(kBehaviorEquals); | |
| 148 if (!StringToExceptionBehavior( | |
| 149 value, | |
| 150 kAllowFullName | kAllowShortName | kAllowNumber, | |
| 151 &description->behavior)) { | |
| 152 return false; | |
| 153 } | |
| 154 } else if (strncmp(token, kFlavorEquals, strlen(kFlavorEquals)) == 0) { | |
| 155 const char* value = token + strlen(kFlavorEquals); | |
| 156 if (!StringToThreadStateFlavor( | |
| 157 value, | |
| 158 kAllowFullName | kAllowShortName | kAllowNumber, | |
| 159 &description->flavor)) { | |
| 160 return false; | |
| 161 } | |
| 162 } else if (strncmp(token, kHandlerEquals, strlen(kHandlerEquals)) == 0) { | |
| 163 const char* value = token + strlen(kHandlerEquals); | |
| 164 if (strcmp(value, kHandlerNull) != 0 && | |
| 165 strncmp(value, | |
| 166 kHandlerBootstrapColon, | |
| 167 strlen(kHandlerBootstrapColon)) != 0) { | |
| 168 return false; | |
| 169 } | |
| 170 description->handler = std::string(value); | |
| 171 } else { | |
| 172 return false; | |
| 173 } | |
| 174 } | |
| 175 | |
| 176 return true; | |
| 177 } | |
| 178 | |
| 179 // ShowExceptionPorts() shows handlers as numeric mach_port_t values, which are | |
| 180 // opaque and meaningless on their own. ShowBootstrapService() can be used to | |
| 181 // look up a service with the bootstrap server by name and show its mach_port_t | |
| 182 // value, which can then be associated with handlers shown by | |
| 183 // ShowExceptionPorts(). Any send rights obtained by this function are added to | |
| 184 // |mach_send_right_pool|. | |
| 185 void ShowBootstrapService(const std::string& service_name, | |
| 186 MachSendRightPool* mach_send_right_pool) { | |
| 187 mach_port_t service_port; | |
| 188 kern_return_t kr = bootstrap_look_up( | |
| 189 bootstrap_port, const_cast<char*>(service_name.c_str()), &service_port); | |
| 190 if (kr != BOOTSTRAP_SUCCESS) { | |
| 191 BOOTSTRAP_LOG(ERROR, kr) << "bootstrap_look_up " << service_name; | |
| 192 return; | |
| 193 } | |
| 194 | |
| 195 mach_send_right_pool->AddSendRight(service_port); | |
| 196 | |
| 197 printf("service %s %#x\n", service_name.c_str(), service_port); | |
| 198 } | |
| 199 | |
| 200 // Prints information about all exception ports known for |exception_ports|. If | |
| 201 // |numeric| is true, all information is printed in numeric form, otherwise, it | |
| 202 // will be converted to symbolic constants where possible by | |
| 203 // SymbolicConstantsMach. If |is_new| is true, information will be presented as | |
| 204 // “new exception ports”, indicating that they show the state of the exception | |
| 205 // ports after SetExceptionPort() has been called. Any send rights obtained by | |
| 206 // this function are added to |mach_send_right_pool|. | |
| 207 void ShowExceptionPorts(const ExceptionPorts& exception_ports, | |
| 208 bool numeric, | |
| 209 bool is_new, | |
| 210 MachSendRightPool* mach_send_right_pool) { | |
| 211 const char* target_name = exception_ports.TargetTypeName(); | |
| 212 | |
| 213 std::vector<ExceptionPorts::ExceptionHandler> handlers; | |
| 214 if (!exception_ports.GetExceptionPorts(ExcMaskAll() | EXC_MASK_CRASH, | |
| 215 &handlers)) { | |
| 216 return; | |
| 217 } | |
| 218 | |
| 219 const char* age_name = is_new ? "new " : ""; | |
| 220 | |
| 221 if (handlers.size() == 0) { | |
| 222 printf("no %s%s exception ports\n", age_name, target_name); | |
| 223 } | |
| 224 | |
| 225 for (size_t port_index = 0; port_index < handlers.size(); ++port_index) { | |
| 226 mach_send_right_pool->AddSendRight(handlers[port_index].port); | |
| 227 | |
| 228 if (numeric) { | |
| 229 printf( | |
| 230 "%s%s exception port %zu, mask %#x, port %#x, " | |
| 231 "behavior %#x, flavor %u\n", | |
| 232 age_name, | |
| 233 target_name, | |
| 234 port_index, | |
| 235 handlers[port_index].mask, | |
| 236 handlers[port_index].port, | |
| 237 handlers[port_index].behavior, | |
| 238 handlers[port_index].flavor); | |
| 239 } else { | |
| 240 std::string mask_string = ExceptionMaskToString( | |
| 241 handlers[port_index].mask, kUseShortName | kUnknownIsEmpty | kUseOr); | |
| 242 if (mask_string.empty()) { | |
| 243 mask_string.assign("?"); | |
| 244 } | |
| 245 | |
| 246 std::string behavior_string = ExceptionBehaviorToString( | |
| 247 handlers[port_index].behavior, kUseShortName | kUnknownIsEmpty); | |
| 248 if (behavior_string.empty()) { | |
| 249 behavior_string.assign("?"); | |
| 250 } | |
| 251 | |
| 252 std::string flavor_string = ThreadStateFlavorToString( | |
| 253 handlers[port_index].flavor, kUseShortName | kUnknownIsEmpty); | |
| 254 if (flavor_string.empty()) { | |
| 255 flavor_string.assign("?"); | |
| 256 } | |
| 257 | |
| 258 printf( | |
| 259 "%s%s exception port %zu, mask %#x (%s), port %#x, " | |
| 260 "behavior %#x (%s), flavor %u (%s)\n", | |
| 261 age_name, | |
| 262 target_name, | |
| 263 port_index, | |
| 264 handlers[port_index].mask, | |
| 265 mask_string.c_str(), | |
| 266 handlers[port_index].port, | |
| 267 handlers[port_index].behavior, | |
| 268 behavior_string.c_str(), | |
| 269 handlers[port_index].flavor, | |
| 270 flavor_string.c_str()); | |
| 271 } | |
| 272 } | |
| 273 } | |
| 274 | |
| 275 // Sets the exception port for |target_port|, a send right to a thread, task, or | |
| 276 // host port, to |description|, which identifies what type of port |target_port| | |
| 277 // is and describes an exception port to be set. Returns true on success. | |
| 278 // | |
| 279 // This function may be called more than once if setting different handlers is | |
| 280 // desired. | |
| 281 bool SetExceptionPort(const ExceptionHandlerDescription* description, | |
| 282 mach_port_t target_port) { | |
| 283 base::mac::ScopedMachSendRight service_port_owner; | |
| 284 exception_handler_t service_port = MACH_PORT_NULL; | |
| 285 kern_return_t kr; | |
| 286 if (description->handler.compare( | |
| 287 0, strlen(kHandlerBootstrapColon), kHandlerBootstrapColon) == 0) { | |
| 288 const char* service_name = | |
| 289 description->handler.c_str() + strlen(kHandlerBootstrapColon); | |
| 290 kr = bootstrap_look_up( | |
| 291 bootstrap_port, const_cast<char*>(service_name), &service_port); | |
| 292 if (kr != BOOTSTRAP_SUCCESS) { | |
| 293 BOOTSTRAP_LOG(ERROR, kr) << "bootstrap_look_up " << service_name; | |
| 294 return false; | |
| 295 } | |
| 296 | |
| 297 // The service port doesn’t need to be added to a MachSendRightPool because | |
| 298 // it’s not used for display at all. ScopedMachSendRight is sufficient. | |
| 299 service_port_owner.reset(service_port); | |
| 300 } else if (description->handler != kHandlerNull) { | |
| 301 return false; | |
| 302 } | |
| 303 | |
| 304 ExceptionPorts exception_ports(description->target_type, target_port); | |
| 305 if (!exception_ports.SetExceptionPort(description->mask, | |
| 306 service_port, | |
| 307 description->behavior, | |
| 308 description->flavor)) { | |
| 309 return false; | |
| 310 } | |
| 311 | |
| 312 return true; | |
| 313 } | |
| 314 | |
| 315 void Usage(const std::string& me) { | |
| 316 fprintf(stderr, | |
| 317 "Usage: %s [OPTION]... [COMMAND [ARG]...]\n" | |
| 318 "View and change Mach exception ports, and run COMMAND if supplied.\n" | |
| 319 "\n" | |
| 320 " -s, --set-handler=DESCRIPTION set an exception port to DESCRIPTION, see belo
w\n" | |
| 321 " --show-bootstrap=SERVICE look up and display a service registered with\
n" | |
| 322 " the bootstrap server\n" | |
| 323 " -p, --pid=PID operate on PID instead of the current task\n" | |
| 324 " -h, --show-host display original host exception ports\n" | |
| 325 " -t, --show-task display original task exception ports\n" | |
| 326 " --show-thread display original thread exception ports\n" | |
| 327 " -H, --show-new-host display modified host exception ports\n" | |
| 328 " -T, --show-new-task display modified task exception ports\n" | |
| 329 " --show-new-thread display modified thread exception ports\n" | |
| 330 " -n, --numeric display values numerically, not symbolically\n
" | |
| 331 " --help display this help and exit\n" | |
| 332 " --version output version information and exit\n" | |
| 333 "\n" | |
| 334 "Any operations on host exception ports require superuser permissions.\n" | |
| 335 "\n" | |
| 336 "DESCRIPTION is formatted as a comma-separated sequence of tokens, where each\n" | |
| 337 "token consists of a key and value separated by an equals sign. Available keys:\
n" | |
| 338 " target which target's exception ports to set: host, task, or thread\n" | |
| 339 " mask the mask of exception types to handle: CRASH, ALL, or others\n" | |
| 340 " behavior the specific exception handler routine to call: DEFAULT, STATE,\n" | |
| 341 " or STATE_IDENTITY, possibly with MACH_EXCEPTION_CODES.\n" | |
| 342 " flavor the thread state flavor passed to the handler: architecture-specifi
c\n" | |
| 343 " handler the exception handler: NULL or bootstrap:SERVICE, indicating that\n
" | |
| 344 " the handler should be looked up with the bootstrap server\n" | |
| 345 "The default DESCRIPTION is\n" | |
| 346 " target=task,mask=CRASH,behavior=DEFAULT|MACH,flavor=NONE,handler=NULL\n", | |
| 347 me.c_str()); | |
| 348 ToolSupport::UsageTail(me); | |
| 349 } | |
| 350 | |
| 351 int ExceptionPortToolMain(int argc, char* argv[]) { | |
| 352 const std::string me(basename(argv[0])); | |
| 353 | |
| 354 enum ExitCode { | |
| 355 kExitSuccess = EXIT_SUCCESS, | |
| 356 | |
| 357 // To differentiate this tool’s errors from errors in the programs it execs, | |
| 358 // use a high exit code for ordinary failures instead of EXIT_FAILURE. This | |
| 359 // is the same rationale for using the distinct exit codes for exec | |
| 360 // failures. | |
| 361 kExitFailure = 125, | |
| 362 | |
| 363 // Like env, use exit code 126 if the program was found but could not be | |
| 364 // invoked, and 127 if it could not be found. | |
| 365 // http://pubs.opengroup.org/onlinepubs/9699919799/utilities/env.html | |
| 366 kExitExecFailure = 126, | |
| 367 kExitExecENOENT = 127, | |
| 368 }; | |
| 369 | |
| 370 enum OptionFlags { | |
| 371 // “Short” (single-character) options. | |
| 372 kOptionSetPort = 's', | |
| 373 kOptionPid = 'p', | |
| 374 kOptionShowHost = 'h', | |
| 375 kOptionShowTask = 't', | |
| 376 kOptionShowNewHost = 'H', | |
| 377 kOptionShowNewTask = 'T', | |
| 378 kOptionNumeric = 'n', | |
| 379 | |
| 380 // Long options without short equivalents. | |
| 381 kOptionLastChar = 255, | |
| 382 kOptionShowBootstrap, | |
| 383 kOptionShowThread, | |
| 384 kOptionShowNewThread, | |
| 385 | |
| 386 // Standard options. | |
| 387 kOptionHelp = -2, | |
| 388 kOptionVersion = -3, | |
| 389 }; | |
| 390 | |
| 391 struct { | |
| 392 std::vector<const char*> show_bootstrap; | |
| 393 std::vector<ExceptionHandlerDescription> set_handler; | |
| 394 pid_t pid; | |
| 395 task_t alternate_task; | |
| 396 bool show_host; | |
| 397 bool show_task; | |
| 398 bool show_thread; | |
| 399 bool show_new_host; | |
| 400 bool show_new_task; | |
| 401 bool show_new_thread; | |
| 402 bool numeric; | |
| 403 } options = {}; | |
| 404 | |
| 405 const struct option long_options[] = { | |
| 406 {"set-handler", required_argument, nullptr, kOptionSetPort}, | |
| 407 {"show-bootstrap", required_argument, nullptr, kOptionShowBootstrap}, | |
| 408 {"pid", required_argument, nullptr, kOptionPid}, | |
| 409 {"show-host", no_argument, nullptr, kOptionShowHost}, | |
| 410 {"show-task", no_argument, nullptr, kOptionShowTask}, | |
| 411 {"show-thread", no_argument, nullptr, kOptionShowThread}, | |
| 412 {"show-new-host", no_argument, nullptr, kOptionShowNewHost}, | |
| 413 {"show-new-task", no_argument, nullptr, kOptionShowNewTask}, | |
| 414 {"show-new-thread", no_argument, nullptr, kOptionShowNewThread}, | |
| 415 {"numeric", no_argument, nullptr, kOptionNumeric}, | |
| 416 {"help", no_argument, nullptr, kOptionHelp}, | |
| 417 {"version", no_argument, nullptr, kOptionVersion}, | |
| 418 {nullptr, 0, nullptr, 0}, | |
| 419 }; | |
| 420 | |
| 421 int opt; | |
| 422 while ((opt = getopt_long(argc, argv, "+s:p:htHTn", long_options, nullptr)) != | |
| 423 -1) { | |
| 424 switch (opt) { | |
| 425 case kOptionSetPort: { | |
| 426 options.set_handler.push_back({}); | |
| 427 ExceptionHandlerDescription* description = &options.set_handler.back(); | |
| 428 description->target_type = ExceptionPorts::kTargetTypeTask; | |
| 429 description->mask = EXC_MASK_CRASH; | |
| 430 description->behavior = EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES; | |
| 431 description->flavor = THREAD_STATE_NONE; | |
| 432 description->handler = "NULL"; | |
| 433 if (!ParseHandlerString(optarg, description)) { | |
| 434 fprintf(stderr, | |
| 435 "%s: invalid exception handler: %s\n", | |
| 436 me.c_str(), | |
| 437 optarg); | |
| 438 return kExitFailure; | |
| 439 } | |
| 440 break; | |
| 441 } | |
| 442 case kOptionShowBootstrap: | |
| 443 options.show_bootstrap.push_back(optarg); | |
| 444 break; | |
| 445 case kOptionPid: | |
| 446 if (!StringToNumber(optarg, &options.pid)) { | |
| 447 fprintf(stderr, "%s: invalid pid: %s\n", me.c_str(), optarg); | |
| 448 return kExitFailure; | |
| 449 } | |
| 450 break; | |
| 451 case kOptionShowHost: | |
| 452 options.show_host = true; | |
| 453 break; | |
| 454 case kOptionShowTask: | |
| 455 options.show_task = true; | |
| 456 break; | |
| 457 case kOptionShowThread: | |
| 458 options.show_thread = true; | |
| 459 break; | |
| 460 case kOptionShowNewHost: | |
| 461 options.show_new_host = true; | |
| 462 break; | |
| 463 case kOptionShowNewTask: | |
| 464 options.show_new_task = true; | |
| 465 break; | |
| 466 case kOptionShowNewThread: | |
| 467 options.show_new_thread = true; | |
| 468 break; | |
| 469 case kOptionNumeric: | |
| 470 options.numeric = true; | |
| 471 break; | |
| 472 case kOptionHelp: | |
| 473 Usage(me); | |
| 474 return kExitSuccess; | |
| 475 case kOptionVersion: | |
| 476 ToolSupport::Version(me); | |
| 477 return kExitSuccess; | |
| 478 default: | |
| 479 ToolSupport::UsageHint(me, nullptr); | |
| 480 return kExitFailure; | |
| 481 } | |
| 482 } | |
| 483 argc -= optind; | |
| 484 argv += optind; | |
| 485 | |
| 486 if (options.show_bootstrap.empty() && !options.show_host && | |
| 487 !options.show_task && !options.show_thread && | |
| 488 options.set_handler.empty() && argc == 0) { | |
| 489 ToolSupport::UsageHint(me, "nothing to do"); | |
| 490 return kExitFailure; | |
| 491 } | |
| 492 | |
| 493 base::mac::ScopedMachSendRight alternate_task_owner; | |
| 494 if (options.pid) { | |
| 495 if (argc) { | |
| 496 ToolSupport::UsageHint(me, "cannot combine -p with COMMAND"); | |
| 497 return kExitFailure; | |
| 498 } | |
| 499 | |
| 500 options.alternate_task = TaskForPID(options.pid); | |
| 501 if (options.alternate_task == TASK_NULL) { | |
| 502 return kExitFailure; | |
| 503 } | |
| 504 alternate_task_owner.reset(options.alternate_task); | |
| 505 } | |
| 506 | |
| 507 // This tool may have been installed as a setuid binary so that TaskForPID() | |
| 508 // could succeed. Drop any privileges now that they’re no longer necessary. | |
| 509 DropPrivileges(); | |
| 510 | |
| 511 MachSendRightPool mach_send_right_pool; | |
| 512 | |
| 513 // Show bootstrap services requested. | |
| 514 for (const char* service : options.show_bootstrap) { | |
| 515 ShowBootstrapService(service, &mach_send_right_pool); | |
| 516 } | |
| 517 | |
| 518 // Show the original exception ports. | |
| 519 if (options.show_host) { | |
| 520 ShowExceptionPorts( | |
| 521 ExceptionPorts(ExceptionPorts::kTargetTypeHost, HOST_NULL), | |
| 522 options.numeric, | |
| 523 false, | |
| 524 &mach_send_right_pool); | |
| 525 } | |
| 526 if (options.show_task) { | |
| 527 ShowExceptionPorts( | |
| 528 ExceptionPorts(ExceptionPorts::kTargetTypeTask, options.alternate_task), | |
| 529 options.numeric, | |
| 530 false, | |
| 531 &mach_send_right_pool); | |
| 532 } | |
| 533 if (options.show_thread) { | |
| 534 ShowExceptionPorts( | |
| 535 ExceptionPorts(ExceptionPorts::kTargetTypeThread, THREAD_NULL), | |
| 536 options.numeric, | |
| 537 false, | |
| 538 &mach_send_right_pool); | |
| 539 } | |
| 540 | |
| 541 if (!options.set_handler.empty()) { | |
| 542 // Set new exception handlers. | |
| 543 for (ExceptionHandlerDescription description : options.set_handler) { | |
| 544 if (!SetExceptionPort( | |
| 545 &description, | |
| 546 description.target_type == ExceptionPorts::kTargetTypeTask | |
| 547 ? options.alternate_task | |
| 548 : TASK_NULL)) { | |
| 549 return kExitFailure; | |
| 550 } | |
| 551 } | |
| 552 | |
| 553 // Show changed exception ports. | |
| 554 if (options.show_new_host) { | |
| 555 ShowExceptionPorts( | |
| 556 ExceptionPorts(ExceptionPorts::kTargetTypeHost, HOST_NULL), | |
| 557 options.numeric, | |
| 558 true, | |
| 559 &mach_send_right_pool); | |
| 560 } | |
| 561 if (options.show_new_task) { | |
| 562 ShowExceptionPorts( | |
| 563 ExceptionPorts(ExceptionPorts::kTargetTypeTask, | |
| 564 options.alternate_task), | |
| 565 options.numeric, | |
| 566 true, | |
| 567 &mach_send_right_pool); | |
| 568 } | |
| 569 if (options.show_new_thread) { | |
| 570 ShowExceptionPorts( | |
| 571 ExceptionPorts(ExceptionPorts::kTargetTypeThread, THREAD_NULL), | |
| 572 options.numeric, | |
| 573 true, | |
| 574 &mach_send_right_pool); | |
| 575 } | |
| 576 } | |
| 577 | |
| 578 if (argc) { | |
| 579 // Using the remaining arguments, start a new program with the new set of | |
| 580 // exception ports in effect. | |
| 581 execvp(argv[0], argv); | |
| 582 PLOG(ERROR) << "execvp " << argv[0]; | |
| 583 return errno == ENOENT ? kExitExecENOENT : kExitExecFailure; | |
| 584 } | |
| 585 | |
| 586 return kExitSuccess; | |
| 587 } | |
| 588 | |
| 589 } // namespace | |
| 590 } // namespace crashpad | |
| 591 | |
| 592 int main(int argc, char* argv[]) { | |
| 593 return crashpad::ExceptionPortToolMain(argc, argv); | |
| 594 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 804913003:
tools: Move Mac-specific tools to tools/mac (Closed)
Base URL: https://chromium.googlesource.com/crashpad/crashpad@master