Get generate_dump compiling on Windows

tools/generate_dump.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 <fcntl.h>
 #include <getopt.h>
-#include <libgen.h>
-#include <mach/mach.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <unistd.h>
+#include <sys/types.h>
 
 #include <string>
 
 #include "base/logging.h"
-#include "base/mac/scoped_mach_port.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
+#include "build/build_config.h"
 #include "minidump/minidump_file_writer.h"
+#include "tools/tool_support.h"
+#include "util/file/basename.h"
+#include "util/file/file_writer.h"
+#include "util/posix/drop_privileges.h"
+#include "util/stdlib/string_number_conversion.h"
+
+#if defined(OS_MACOSX)
+#include <libgen.h>
+#include <mach/mach.h>
+#include <unistd.h>
+
+#include "base/mac/scoped_mach_port.h"
 #include "snapshot/mac/process_snapshot_mac.h"
-#include "tools/tool_support.h"
-#include "util/file/file_writer.h"
 #include "util/mach/scoped_task_suspend.h"
 #include "util/mach/task_for_pid.h"
-#include "util/posix/drop_privileges.h"
-#include "util/stdlib/string_number_conversion.h"
+#elif defined(OS_WIN)
+#include "base/strings/utf_string_conversions.h"
+#include "snapshot/win/process_snapshot_win.h"
+#endif  // OS_MACOSX
 
 namespace crashpad {
 namespace {
 
 struct Options {
   std::string dump_path;
   pid_t pid;
   bool suspend;
 };
 
 void Usage(const std::string& me) {
   fprintf(stderr,
 "Usage: %s [OPTION]... PID\n"
 "Generate a minidump file containing a snapshot of a running process.\n"
 "\n"
 "  -r, --no-suspend   don't suspend the target process during dump generation\n"
 "  -o, --output=FILE  write the minidump to FILE instead of minidump.PID\n"
 "      --help         display this help and exit\n"
 "      --version      output version information and exit\n",
           me.c_str());
   ToolSupport::UsageTail(me);
 }
 
 int GenerateDumpMain(int argc, char* argv[]) {
-  const std::string me(basename(argv[0]));
+  const std::string me(Basename(argv[0]));
 
   enum OptionFlags {
     // “Short” (single-character) options.
     kOptionOutput = 'o',
     kOptionNoSuspend = 'r',
 
     // Long options without short equivalents.
     kOptionLastChar = 255,
 
     // Standard options.
@@ skipping 38 matching lines @@
   if (argc != 1) {
     ToolSupport::UsageHint(me, "PID is required");
     return EXIT_FAILURE;
   }
 
   if (!StringToNumber(argv[0], &options.pid) || options.pid <= 0) {
     fprintf(stderr, "%s: invalid PID: %s\n", me.c_str(), argv[0]);
     return EXIT_FAILURE;
   }
 
+#if defined(OS_MACOSX)

[Mark Mentovai, 2015/05/04 21:21:58]

I hope that over time, we can refactor things well enough to the point that the
code doesn’t have to be structured as “if-Mac-elseif-Win, if-Mac-elseif-Win”
over and over.

[scottmg, 2015/05/05 19:26:22]

OK. It seems that having a typedef for task_t/process HANDLE would get us some
of the way. That would allow for a ScopedProcessSuspend (with the same name) and
a factory function to create a snapshot. There's still the process opening that
talks to OS-level things, but that could be moved to a helper function at least.

[Mark Mentovai, 2015/05/05 22:41:35]

scottmg wrote:
Yup, that would be a good future change.

   task_t task = TaskForPID(options.pid);
   if (task == TASK_NULL) {
     return EXIT_FAILURE;
   }
   base::mac::ScopedMachSendRight task_owner(task);
 
   // This tool may have been installed as a setuid binary so that TaskForPID()
   // could succeed. Drop any privileges now that they’re no longer necessary.
   DropPrivileges();
 
   if (options.pid == getpid()) {
     if (options.suspend) {
       LOG(ERROR) << "cannot suspend myself";
       return EXIT_FAILURE;
     }
     LOG(WARNING) << "operating on myself";
   }
+#elif defined(OS_WIN)
+  ScopedKernelHANDLE process(
+      OpenProcess(PROCESS_ALL_ACCESS, false, options.pid));
+  if (!process.is_valid()) {
+    LOG(ERROR) << "could not open process " << options.pid;
+    return EXIT_FAILURE;
+  }
+#endif  // OS_MACOSX
 
   if (options.dump_path.empty()) {
     options.dump_path = base::StringPrintf("minidump.%d", options.pid);
   }
 
   {
+#if defined(OS_MACOSX)
     scoped_ptr<ScopedTaskSuspend> suspend;
     if (options.suspend) {
       suspend.reset(new ScopedTaskSuspend(task));
     }
+#elif defined(OS_WIN)
+    if (options.suspend) {
+      LOG(ERROR) << "TODO(scottmg): --suspend not implemented yet.";
+      return EXIT_FAILURE;
+    }
+#endif  // OS_MACOSX
 
+#if defined(OS_MACOSX)
     ProcessSnapshotMac process_snapshot;
     if (!process_snapshot.Initialize(task)) {
       return EXIT_FAILURE;
     }
+#elif defined(OS_WIN)
+    ProcessSnapshotWin process_snapshot;
+    if (!process_snapshot.Initialize(process.get())) {
+      return EXIT_FAILURE;
+    }
+#endif  // OS_MACOSX
 
     FileWriter file_writer;
-    if (!file_writer.Open(base::FilePath(options.dump_path),
+#if defined(OS_MACOSX)
+    base::FilePath dump_path(options.dump_path);
+#elif defined(OS_WIN)
+    base::FilePath dump_path(base::UTF8ToUTF16(options.dump_path));
+#endif  // OS_MACOSX
+    if (!file_writer.Open(dump_path,
                           FileWriteMode::kTruncateOrCreate,
                           FilePermissions::kWorldReadable)) {
       return EXIT_FAILURE;
     }
 
     MinidumpFileWriter minidump;
     minidump.InitializeFromSnapshot(&process_snapshot);
     if (!minidump.WriteEverything(&file_writer)) {
       if (unlink(options.dump_path.c_str()) != 0) {
         PLOG(ERROR) << "unlink";
       }
       return EXIT_FAILURE;
     }
   }
 
   return EXIT_SUCCESS;
 }
 
 }  // namespace
 }  // namespace crashpad
 
 int main(int argc, char* argv[]) {
   return crashpad::GenerateDumpMain(argc, argv);
 }