Update Crashpad to b47bf6c250c6b825dee1c5fbad9152c2c962e828

third_party/crashpad/crashpad/handler/handler_main.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 41 matching lines @@
 #include "handler/mac/exception_handler_server.h"
 #include "util/mach/child_port_handshake.h"
 #include "util/mach/mach_extensions.h"
 #include "util/posix/close_stdio.h"
 #elif defined(OS_WIN)
 #include <windows.h>
 
 #include "handler/win/crash_report_exception_handler.h"
 #include "util/win/exception_handler_server.h"
 #include "util/win/handle.h"
+#include "util/win/initial_client_data.h"
 #endif  // OS_MACOSX
 
 namespace crashpad {
 
 namespace {
 
 void Usage(const base::FilePath& me) {
   fprintf(stderr,
 "Usage: %" PRFilePath " [OPTION]...\n"
 "Crashpad's exception handler server.\n"
 "\n"
 "      --annotation=KEY=VALUE  set a process annotation in each crash report\n"
 "      --database=PATH         store the crash report database at PATH\n"
 #if defined(OS_MACOSX)
 "      --handshake-fd=FD       establish communication with the client over FD\n"
 "      --mach-service=SERVICE  register SERVICE with the bootstrap server\n"
 #elif defined(OS_WIN)
-"      --handshake-handle=HANDLE\n"
-"                              create a new pipe and send its name via HANDLE\n"
+"      --initial-client-data=HANDLE_request_crash_dump,\n"
+"                            HANDLE_request_non_crash_dump,\n"
+"                            HANDLE_non_crash_dump_completed,\n"
+"                            HANDLE_pipe,\n"
+"                            HANDLE_client_process,\n"
+"                            Address_crash_exception_information,\n"
+"                            Address_non_crash_exception_information,\n"
+"                            Address_debug_critical_section\n"
+"                              use precreated data to register initial client\n"
 #endif  // OS_MACOSX
 "      --metrics-dir=DIR       store metrics files in DIR (only in Chromium)\n"
 "      --no-rate-limit         don't rate limit crash uploads\n"
 #if defined(OS_MACOSX)
 "      --reset-own-crash-exception-port-to-system-default\n"
 "                              reset the server's exception handler to default\n"
 #elif defined(OS_WIN)
 "      --pipe-name=PIPE        communicate with the client over PIPE\n"
 #endif  // OS_MACOSX
 "      --url=URL               send crash reports to this Breakpad server URL,\n"
@@ skipping 27 matching lines @@
   g_exception_handler_server->Stop();
 }
 
 #endif  // OS_MACOSX
 
 #if defined(OS_WIN)
 LONG WINAPI UnhandledExceptionHandler(EXCEPTION_POINTERS* exception_pointers) {
   Metrics::HandlerCrashed(exception_pointers->ExceptionRecord->ExceptionCode);
   return EXCEPTION_CONTINUE_SEARCH;
 }
-#endif
+#endif  // OS_WIN
 
 }  // namespace
 
 int HandlerMain(int argc, char* argv[]) {
 #if defined(OS_WIN)
   SetUnhandledExceptionFilter(&UnhandledExceptionHandler);
 #endif
 
   const base::FilePath argv0(
       ToolSupport::CommandLineArgumentToFilePathStringType(argv[0]));
   const base::FilePath me(argv0.BaseName());
 
   enum OptionFlags {
     // Long options without short equivalents.
     kOptionLastChar = 255,
     kOptionAnnotation,
     kOptionDatabase,
 #if defined(OS_MACOSX)
     kOptionHandshakeFD,
+#endif  // OS_MACOSX
+#if defined(OS_WIN)
+    kOptionInitialClientData,
+#endif  // OS_WIN
+#if defined(OS_MACOSX)
     kOptionMachService,
-#elif defined(OS_WIN)
-    kOptionHandshakeHandle,
 #endif  // OS_MACOSX
     kOptionMetrics,
     kOptionNoRateLimit,
 #if defined(OS_MACOSX)
     kOptionResetOwnCrashExceptionPortToSystemDefault,
 #elif defined(OS_WIN)
     kOptionPipeName,
 #endif  // OS_MACOSX
     kOptionURL,
 
     // Standard options.
     kOptionHelp = -2,
     kOptionVersion = -3,
   };
 
   struct {
     std::map<std::string, std::string> annotations;
     std::string url;
     const char* database;
     const char* metrics;
 #if defined(OS_MACOSX)
     int handshake_fd;
     std::string mach_service;
     bool reset_own_crash_exception_port_to_system_default;
 #elif defined(OS_WIN)
-    HANDLE handshake_handle;
     std::string pipe_name;
+    InitialClientData initial_client_data;
 #endif  // OS_MACOSX
     bool rate_limit;
   } options = {};
 #if defined(OS_MACOSX)
   options.handshake_fd = -1;
-#elif defined(OS_WIN)
-  options.handshake_handle = INVALID_HANDLE_VALUE;
 #endif
   options.rate_limit = true;
 
   const option long_options[] = {
-      {"annotation", required_argument, nullptr, kOptionAnnotation},
-      {"database", required_argument, nullptr, kOptionDatabase},
+    {"annotation", required_argument, nullptr, kOptionAnnotation},
+    {"database", required_argument, nullptr, kOptionDatabase},
 #if defined(OS_MACOSX)
-      {"handshake-fd", required_argument, nullptr, kOptionHandshakeFD},
-      {"mach-service", required_argument, nullptr, kOptionMachService},
+    {"handshake-fd", required_argument, nullptr, kOptionHandshakeFD},
+#endif  // OS_MACOSX
+#if defined(OS_WIN)
+    {"initial-client-data",
+     required_argument,
+     nullptr,
+     kOptionInitialClientData},
+#endif  // OS_MACOSX
+#if defined(OS_MACOSX)
+    {"mach-service", required_argument, nullptr, kOptionMachService},
+#endif  // OS_MACOSX
+    {"metrics-dir", required_argument, nullptr, kOptionMetrics},
+    {"no-rate-limit", no_argument, nullptr, kOptionNoRateLimit},
+#if defined(OS_MACOSX)
+    {"reset-own-crash-exception-port-to-system-default",
+     no_argument,
+     nullptr,
+     kOptionResetOwnCrashExceptionPortToSystemDefault},
 #elif defined(OS_WIN)
-      {"handshake-handle", required_argument, nullptr, kOptionHandshakeHandle},
+    {"pipe-name", required_argument, nullptr, kOptionPipeName},
 #endif  // OS_MACOSX
-      {"metrics-dir", required_argument, nullptr, kOptionMetrics},
-      {"no-rate-limit", no_argument, nullptr, kOptionNoRateLimit},
-#if defined(OS_MACOSX)
-      {"reset-own-crash-exception-port-to-system-default",
-       no_argument,
-       nullptr,
-       kOptionResetOwnCrashExceptionPortToSystemDefault},
-#elif defined(OS_WIN)
-      {"pipe-name", required_argument, nullptr, kOptionPipeName},
-#endif  // OS_MACOSX
-      {"url", required_argument, nullptr, kOptionURL},
-      {"help", no_argument, nullptr, kOptionHelp},
-      {"version", no_argument, nullptr, kOptionVersion},
-      {nullptr, 0, nullptr, 0},
+    {"url", required_argument, nullptr, kOptionURL},
+    {"help", no_argument, nullptr, kOptionHelp},
+    {"version", no_argument, nullptr, kOptionVersion},
+    {nullptr, 0, nullptr, 0},
   };
 
   int opt;
   while ((opt = getopt_long(argc, argv, "", long_options, nullptr)) != -1) {
     switch (opt) {
       case kOptionAnnotation: {
         std::string key;
         std::string value;
-        if (!SplitString(optarg, '=', &key, &value)) {
+        if (!SplitStringFirst(optarg, '=', &key, &value)) {
           ToolSupport::UsageHint(me, "--annotation requires KEY=VALUE");
           return EXIT_FAILURE;
         }
         std::string old_value;
         if (!MapInsertOrReplace(&options.annotations, key, value, &old_value)) {
           LOG(WARNING) << "duplicate key " << key << ", discarding value "
                        << old_value;
         }
         break;
       }
       case kOptionDatabase: {
         options.database = optarg;
         break;
       }
 #if defined(OS_MACOSX)
       case kOptionHandshakeFD: {
         if (!StringToNumber(optarg, &options.handshake_fd) ||
             options.handshake_fd < 0) {
           ToolSupport::UsageHint(me,
                                  "--handshake-fd requires a file descriptor");
           return EXIT_FAILURE;
         }
         break;
       }
       case kOptionMachService: {
         options.mach_service = optarg;
         break;
       }
 #elif defined(OS_WIN)
-      case kOptionHandshakeHandle: {
-        // Use unsigned int, because the handle was presented by the client in
-        // 0x%x format.
-        unsigned int handle_uint;
-        if (!StringToNumber(optarg, &handle_uint) ||
-            (options.handshake_handle = IntToHandle(handle_uint)) ==
-                INVALID_HANDLE_VALUE) {
-          ToolSupport::UsageHint(me, "--handshake-handle requires a HANDLE");
+      case kOptionInitialClientData: {
+        if (!options.initial_client_data.InitializeFromString(optarg)) {
+          ToolSupport::UsageHint(
+              me, "failed to parse --initial-client-data");
           return EXIT_FAILURE;
         }
         break;
       }
 #endif  // OS_MACOSX
       case kOptionMetrics: {
         options.metrics = optarg;
         break;
       }
       case kOptionNoRateLimit: {
@@ skipping 36 matching lines @@
   if (options.handshake_fd < 0 && options.mach_service.empty()) {
     ToolSupport::UsageHint(me, "--handshake-fd or --mach-service is required");
     return EXIT_FAILURE;
   }
   if (options.handshake_fd >= 0 && !options.mach_service.empty()) {
     ToolSupport::UsageHint(
         me, "--handshake-fd and --mach-service are incompatible");
     return EXIT_FAILURE;
   }
 #elif defined(OS_WIN)
-  if (options.handshake_handle == INVALID_HANDLE_VALUE &&
-      options.pipe_name.empty()) {
-    ToolSupport::UsageHint(me, "--handshake-handle or --pipe-name is required");
+  if (!options.initial_client_data.IsValid() && options.pipe_name.empty()) {
+    ToolSupport::UsageHint(me,
+                           "--initial-client-data or --pipe-name is required");
     return EXIT_FAILURE;
   }
-  if (options.handshake_handle != INVALID_HANDLE_VALUE &&
-      !options.pipe_name.empty()) {
+  if (options.initial_client_data.IsValid() && !options.pipe_name.empty()) {
     ToolSupport::UsageHint(
-        me, "--handshake-handle and --pipe-name are incompatible");
+        me, "--initial-client-data and --pipe-name are incompatible");
     return EXIT_FAILURE;
   }
 #endif  // OS_MACOSX
 
   if (!options.database) {
     ToolSupport::UsageHint(me, "--database is required");
     return EXIT_FAILURE;
   }
 
   if (argc) {
@@ skipping 50 matching lines @@
   }
 #elif defined(OS_WIN)
   // Shut down as late as possible relative to programs we're watching.
   if (!SetProcessShutdownParameters(0x100, SHUTDOWN_NORETRY))
     PLOG(ERROR) << "SetProcessShutdownParameters";
 
   ExceptionHandlerServer exception_handler_server(!options.pipe_name.empty());
 
   if (!options.pipe_name.empty()) {
     exception_handler_server.SetPipeName(base::UTF8ToUTF16(options.pipe_name));
-  } else if (options.handshake_handle != INVALID_HANDLE_VALUE) {
-    std::wstring pipe_name = exception_handler_server.CreatePipe();
-
-    uint32_t pipe_name_length = static_cast<uint32_t>(pipe_name.size());
-    if (!LoggingWriteFile(options.handshake_handle,
-                          &pipe_name_length,
-                          sizeof(pipe_name_length))) {
-      return EXIT_FAILURE;
-    }
-    if (!LoggingWriteFile(options.handshake_handle,
-                          pipe_name.c_str(),
-                          pipe_name.size() * sizeof(pipe_name[0]))) {
-      return EXIT_FAILURE;
-    }
   }
 #endif  // OS_MACOSX
 
   base::GlobalHistogramAllocator* histogram_allocator = nullptr;
   if (options.metrics) {
     const base::FilePath metrics_dir(
         ToolSupport::CommandLineArgumentToFilePathStringType(options.metrics));
     static const char kMetricsName[] = "CrashpadMetrics";
     const size_t kMetricsFileSize = 1 << 20;
     if (base::GlobalHistogramAllocator::CreateWithActiveFileInDir(
@@ skipping 17 matching lines @@
       database.get(), options.url, options.rate_limit);
   upload_thread.Start();
 
   PruneCrashReportThread prune_thread(database.get(),
                                       PruneCondition::GetDefault());
   prune_thread.Start();
 
   CrashReportExceptionHandler exception_handler(
       database.get(), &upload_thread, &options.annotations);
 
+#if defined(OS_WIN)
+  if (options.initial_client_data.IsValid()) {
+    exception_handler_server.InitializeWithInheritedDataForInitialClient(
+        options.initial_client_data, &exception_handler);
+  }
+#endif  // OS_WIN
+
   exception_handler_server.Run(&exception_handler);
 
   upload_thread.Stop();
   prune_thread.Stop();
 
   if (histogram_allocator)
     histogram_allocator->DeletePersistentLocation();
 
   return EXIT_SUCCESS;
 }
 
 }  // namespace crashpad