crashpad_database_util: add --new-report

tools/crashpad_database_util.cc

 // Copyright 2015 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 14 matching lines @@
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/numerics/safe_conversions.h"
 #include "client/crash_report_database.h"
 #include "client/settings.h"
 #include "tools/tool_support.h"
+#include "util/file/file_io.h"
+#include "util/file/file_reader.h"
 #include "util/misc/uuid.h"
 
 namespace crashpad {
 namespace {
 
 void Usage(const std::string& me) {
   fprintf(stderr,
 "Usage: %s [OPTION]... PID\n"
 "Operate on Crashpad crash report databases.\n"
 "\n"
 "  -d, --database=PATH             operate on the crash report database at PATH\n"
 "      --show-client-id            show the client ID\n"
 "      --show-uploads-enabled      show whether uploads are enabled\n"
 "      --show-last-upload-attempt-time\n"
 "                                  show the last-upload-attempt time\n"
 "      --show-pending-reports      show reports eligible for upload\n"
 "      --show-completed-reports    show reports not eligible for upload\n"
 "      --show-all-report-info      with --show-*-reports, show more information\n"
 "      --show-report=UUID          show report stored under UUID\n"
 "      --set-uploads-enabled=BOOL  enable or disable uploads\n"
 "      --set-last-upload-attempt-time=TIME\n"
 "                                  set the last-upload-attempt time to TIME\n"
+"      --new-report=PATH           submit a new report at PATH\n"
 "      --utc                       show and set UTC times instead of local\n"
 "      --help                      display this help and exit\n"
 "      --version                   output version information and exit\n",
           me.c_str());
   ToolSupport::UsageTail(me);
 }
 
 struct Options {
   std::vector<UUID> show_reports;
+  std::vector<base::FilePath> new_report_paths;
   const char* database;
   const char* set_last_upload_attempt_time_string;
   time_t set_last_upload_attempt_time;
   bool show_client_id;
   bool show_uploads_enabled;
   bool show_last_upload_attempt_time;
   bool show_pending_reports;
   bool show_completed_reports;
   bool show_all_report_info;
   bool set_uploads_enabled;
@@ skipping 169 matching lines @@
     kOptionLastChar = 255,
     kOptionShowClientID,
     kOptionShowUploadsEnabled,
     kOptionShowLastUploadAttemptTime,
     kOptionShowPendingReports,
     kOptionShowCompletedReports,
     kOptionShowAllReportInfo,
     kOptionShowReport,
     kOptionSetUploadsEnabled,
     kOptionSetLastUploadAttemptTime,
+    kOptionNewReport,
     kOptionUTC,
 
     // Standard options.
     kOptionHelp = -2,
     kOptionVersion = -3,
   };
 
   const option long_options[] = {
       {"database", required_argument, nullptr, kOptionDatabase},
       {"show-client-id", no_argument, nullptr, kOptionShowClientID},
@@ skipping 10 matching lines @@
       {"show-all-report-info", no_argument, nullptr, kOptionShowAllReportInfo},
       {"show-report", required_argument, nullptr, kOptionShowReport},
       {"set-uploads-enabled",
        required_argument,
        nullptr,
        kOptionSetUploadsEnabled},
       {"set-last-upload-attempt-time",
        required_argument,
        nullptr,
        kOptionSetLastUploadAttemptTime},
+      {"new-report", required_argument, nullptr, kOptionNewReport},
       {"utc", no_argument, nullptr, kOptionUTC},
       {"help", no_argument, nullptr, kOptionHelp},
       {"version", no_argument, nullptr, kOptionVersion},
       {nullptr, 0, nullptr, 0},
   };
 
   Options options = {};
 
   int opt;
   while ((opt = getopt_long(argc, argv, "d:", long_options, nullptr)) != -1) {
@@ skipping 40 matching lines @@
           ToolSupport::UsageHint(me, "--set-uploads-enabled requires a BOOL");
           return EXIT_FAILURE;
         }
         options.has_set_uploads_enabled = true;
         break;
       }
       case kOptionSetLastUploadAttemptTime: {
         options.set_last_upload_attempt_time_string = optarg;
         break;
       }
+      case kOptionNewReport: {
+        options.new_report_paths.push_back(base::FilePath(optarg));
+        break;
+      }
       case kOptionUTC: {
         options.utc = true;
         break;
       }
       case kOptionHelp: {
         Usage(me);
         return EXIT_SUCCESS;
       }
       case kOptionVersion: {
         ToolSupport::Version(me);
@@ skipping 19 matching lines @@
   if (options.set_last_upload_attempt_time_string) {
     if (!StringToTime(options.set_last_upload_attempt_time_string,
                       &options.set_last_upload_attempt_time,
                       options.utc)) {
       ToolSupport::UsageHint(me,
                              "--set-last-upload-attempt-time requires a TIME");
       return EXIT_FAILURE;
     }
   }
 
+  // --new-report is treated as a show operation because it produces output.
   const size_t show_operations = options.show_client_id +
                                  options.show_uploads_enabled +
                                  options.show_last_upload_attempt_time +
                                  options.show_pending_reports +
                                  options.show_completed_reports +
-                                 options.show_reports.size();
+                                 options.show_reports.size() +
+                                 options.new_report_paths.size();
   const size_t set_operations =
       options.has_set_uploads_enabled +
       (options.set_last_upload_attempt_time_string != nullptr);
 
   if (show_operations + set_operations == 0) {
     ToolSupport::UsageHint(me, "nothing to do");
     return EXIT_FAILURE;
   }
 
   scoped_ptr<CrashReportDatabase> database(
@@ skipping 98 matching lines @@
       !settings->SetUploadsEnabled(options.set_uploads_enabled)) {
     return EXIT_FAILURE;
   }
 
   if (options.set_last_upload_attempt_time_string &&
       !settings->SetLastUploadAttemptTime(
           options.set_last_upload_attempt_time)) {
     return EXIT_FAILURE;
   }
 
+  for (const base::FilePath new_report_path : options.new_report_paths) {
+    FileReader file_reader;
+    if (!file_reader.Open(new_report_path)) {
+      return EXIT_FAILURE;
+    }
+
+    CrashReportDatabase::NewReport* new_report;
+    CrashReportDatabase::OperationStatus status =
+        database->PrepareNewCrashReport(&new_report);
+    if (status != CrashReportDatabase::kNoError) {
+      return EXIT_FAILURE;
+    }
+
+    CrashReportDatabase::CallErrorWritingCrashReport
+        call_error_writing_crash_report(database.get(), new_report);
+
+    char buf[4096];
+    ssize_t read_result;
+    while ((read_result = file_reader.Read(buf, sizeof(buf))) > 0) {
+      if (!LoggingWriteFile(new_report->handle, buf, read_result)) {
+        return EXIT_FAILURE;
+      }
+    }
+    if (read_result < 0) {
+      return EXIT_FAILURE;
+    }
+
+    call_error_writing_crash_report.Disarm();
+
+    UUID uuid;
+    status = database->FinishedWritingCrashReport(new_report, &uuid);
+    if (status != CrashReportDatabase::kNoError) {
+      return EXIT_FAILURE;
+    }
+
+    const char* prefix = (show_operations > 1) ? "New report ID: " : "";
+    printf("%s%s\n", prefix, uuid.ToString().c_str());
+  }
+
   return EXIT_SUCCESS;
 }
 
 }  // namespace
 }  // namespace crashpad
 
 int main(int argc, char* argv[]) {
   return crashpad::DatabaseUtilMain(argc, argv);
 }