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 "snapshot/mac/process_snapshot_mac.h"
 #include "tools/tool_support.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>

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

This was only present for basename(). You can remove it.

[scottmg, 2015/05/05 23:23:52]

Done.

+#include <mach/mach.h>
+#include <unistd.h>
+
+#include "base/mac/scoped_mach_port.h"
+#include "snapshot/mac/process_snapshot_mac.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) {
+void Usage(const base::FilePath& me) {
   fprintf(stderr,
-"Usage: %s [OPTION]... PID\n"
+"Usage: %" PRFilePath " [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());
+          me.value().c_str());
   ToolSupport::UsageTail(me);
 }
 
 int GenerateDumpMain(int argc, char* argv[]) {
-  const std::string me(basename(argv[0]));
+  const base::FilePath me(base::FilePath(ToolSupport::UTF8ToFilePathStringType(

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

Not loving what clang-format does with this, but I guess it’s OK. These are hard
ones to pick a good format for.

[scottmg, 2015/05/05 23:23:52]

I broke them into two statements, as it got even worse after "UTF8" changed to
"CommandLineArgument".

+                                             argv[0])).BaseName());
 
   enum OptionFlags {
     // “Short” (single-character) options.
     kOptionOutput = 'o',
     kOptionNoSuspend = 'r',
 
     // Long options without short equivalents.
     kOptionLastChar = 255,
 
     // Standard options.
@@ skipping 34 matching lines @@
   }
   argc -= optind;
   argv += optind;
 
   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]);
+    fprintf(stderr,
+            "%" PRFilePath ": invalid PID: %s\n",
+            me.value().c_str(),
+            argv[0]);

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

Where this happens, it’s writing UTF-8 to stdout, and if stdout is the console,
Windows will be expecting a native narrow string. I don’t think that it’s
necessary to worry about that now, but maybe we should have a bug on file to
deal with this in tool output.

[scottmg, 2015/05/05 23:23:52]

Filed: https://code.google.com/p/crashpad/issues/detail?id=36

I think it's writing UTF16 here, or is that what %ls in fprintf does?

But either way, Windows tends to be terrible about anything other than
ASCII/native codepage going to the console, so we should figure out what we want
to do/support.

[Mark Mentovai, 2015/05/06 04:44:15]

%ls is for me.value().c_str(). %ls says UTF-16, so I’m assuming that it does the
right thing for this FilePath. But argv[0] is UTF-8 and formatted with %s.
That’s where we might run into trouble.

[scottmg, 2015/05/06 18:02:18]

Oh, I misunderstood and was looking at `me`, rather than argv[0].

     return EXIT_FAILURE;
   }
 
+#if defined(OS_MACOSX)
   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.";

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

suspend is the default, so technically, it’s “--no-suspend is required for now”.

[scottmg, 2015/05/05 23:23:52]

Done.

+      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
 
+#if defined(OS_POSIX)
 int main(int argc, char* argv[]) {
   return crashpad::GenerateDumpMain(argc, argv);
 }
+#elif defined(OS_WIN)
+int wmain(int argc, wchar_t* argv[]) {
+  return crashpad::ToolSupport::Wmain(argc, argv, &crashpad::GenerateDumpMain);
+}
+#endif  // OS_POSIX