win: get tools/crashpad_database_util mostly working

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,
 // 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 <errno.h>
 #include <getopt.h>
-#include <libgen.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 #include <time.h>
 
 #include <string>
 #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 "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
+#include "build/build_config.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"
 
+#if defined(OS_MACOSX)
+#include <libgen.h>
+#endif  // OS_MACOSX
+
 namespace crashpad {
 namespace {
 
+#if defined(OS_POSIX)
+time_t TimeGM(struct tm* tm) {
+  return timegm(tm);
+}
+
+std::string Basename(const std::string& path) {
+  std::string copy(path);
+  return std::string(basename(&copy[0]));
+}
+
+const char* Strptime(const char* buf, const char* format, struct tm* tm) {
+  return strptime(buf, format, tm);
+}
+#elif defined(OS_WIN)
+time_t TimeGM(struct tm* tm) {
+  return _mkgmtime(tm);

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

Write a timegm wrapper in compat/win/time.{cc,h} instead? And do a compat
wrapper for basename and strptime too?

[scottmg, 2015/05/04 23:26:36]

I did timegm and strptime, but basename seems icky, so I pulled that out of the
next CL where it's in util/ with a std::string in/out.

+}
+
+std::string Basename(const std::string& path) {
+  char fname[_MAX_FNAME];
+  char ext[_MAX_EXT];
+  _splitpath(path.c_str(), nullptr, nullptr, fname, ext);
+  return std::string(fname) + std::string(ext);
+}
+
+const char* Strptime(const char* buf, const char* format, struct tm* tm) {
+  // TODO(scottmg): strptime implementation.
+  NOTREACHED();
+  return nullptr;
+}
+#endif  // OS_POSIX
+
 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"
@@ skipping 45 matching lines @@
   const char* const kTrueWords[] = {
       "1",
       "true",
       "yes",
       "on",
       "enabled",
       "set",
   };
 
   for (size_t index = 0; index < arraysize(kFalseWords); ++index) {
-    if (strcasecmp(string, kFalseWords[index]) == 0) {
+    if (base::strcasecmp(string, kFalseWords[index]) == 0) {
       *boolean = false;
       return true;
     }
   }
 
   for (size_t index = 0; index < arraysize(kTrueWords); ++index) {
-    if (strcasecmp(string, kTrueWords[index]) == 0) {
+    if (base::strcasecmp(string, kTrueWords[index]) == 0) {
       *boolean = true;
       return true;
     }
   }
 
   return false;
 }
 
 // Converts |boolean| to a string, either "true" or "false".
 std::string BoolToString(bool boolean) {
   return std::string(boolean ? "true" : "false");
 }
 
 // Converts |string| to |time|, returning true if a conversion could be
 // performed, and false without setting |boolean| if no conversion could be
 // performed. Various time formats are recognized, including several string
 // representations and a numeric time_t representation. The special string
 // "never" is recognized as |string| and converts to a |time| value of 0. |utc|,
 // when true, causes |string| to be interpreted as a UTC time rather than a
 // local time when the time zone is ambiguous.
 bool StringToTime(const char* string, time_t* time, bool utc) {
-  if (strcasecmp(string, "never") == 0) {
+  if (base::strcasecmp(string, "never") == 0) {
     *time = 0;
     return true;
   }
 
   const char* end = string + strlen(string);
 
   const char* const kFormats[] = {
       "%Y-%m-%d %H:%M:%S %Z",
       "%Y-%m-%d %H:%M:%S",
       "%+",
   };
 
   for (size_t index = 0; index < arraysize(kFormats); ++index) {
     tm time_tm;
-    const char* strptime_result = strptime(string, kFormats[index], &time_tm);
+    const char* strptime_result = Strptime(string, kFormats[index], &time_tm);
     if (strptime_result == end) {
       if (utc) {
-        *time = timegm(&time_tm);
+        *time = TimeGM(&time_tm);
       } else {
-        *time = timelocal(&time_tm);
+        *time = mktime(&time_tm);
       }
 
       return true;
     }
   }
 
   char* end_result;
   errno = 0;
   long long strtoll_result = strtoll(string, &end_result, 0);
   if (end_result == end && errno == 0 &&
       base::IsValueInRangeForNumericType<time_t>(strtoll_result)) {
     *time = strtoll_result;
     return true;
   }
 
   return false;
 }
 
-// Converst |time_tt| to a string, and returns it. |utc| determines whether the
+// Converts |time_tt| to a string, and returns it. |utc| determines whether the
 // converted time will reference local time or UTC. If |time_tt| is 0, the
 // string "never" will be returned as a special case.
 std::string TimeToString(time_t time_tt, bool utc) {
   if (time_tt == 0) {
     return std::string("never");
   }
 
   tm time_tm;
   if (utc) {
+#if defined(OS_POSIX)
     gmtime_r(&time_tt, &time_tm);
+#elif defined(OS_WIN)
+    gmtime_s(&time_tm, &time_tt);
+#endif  // OS_POSIX
   } else {
+#if defined(OS_POSIX)
     localtime_r(&time_tt, &time_tm);
+#elif defined(OS_WIN)
+    localtime_s(&time_tm, &time_tt);
+#endif  // OS_POSIX
   }
 
   char string[64];
   CHECK_NE(
       strftime(string, arraysize(string), "%Y-%m-%d %H:%M:%S %Z", &time_tm),
       0u);
 
   return std::string(string);
 }
 
 // Shows information about a single |report|. |space_count| is the number of
 // spaces to print before each line that is printed. |utc| determines whether
 // times should be shown in UTC or the local time zone.
 void ShowReport(const CrashReportDatabase::Report& report,
                 size_t space_count,
                 bool utc) {
   std::string spaces(space_count, ' ');
 
-  printf("%sPath: %s\n", spaces.c_str(), report.file_path.value().c_str());
+  printf("%sPath: %s\n",

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

Does it work to use PRFilePath here so that the argument can be
report.file_path.value().c_str() regardless of OS? Or is it desirable to convert
to UTF-8 ourselves? I suspect that neither may be 100% correct on Windows,
because console output is probably expecting narrow strings to be in the
configured codepage, not UTF-8.

[scottmg, 2015/05/04 23:26:36]

Done.

+         spaces.c_str(),
+#if defined(OS_POSIX)
+         report.file_path.value().c_str()
+#elif defined(OS_WIN)
+         base::UTF16ToUTF8(report.file_path.value()).c_str()
+#endif
+             );
   if (!report.id.empty()) {
     printf("%sRemote ID: %s\n", spaces.c_str(), report.id.c_str());
   }
   printf("%sCreation time: %s\n",
          spaces.c_str(),
          TimeToString(report.creation_time, utc).c_str());
   printf("%sUploaded: %s\n",
          spaces.c_str(),
          BoolToString(report.uploaded).c_str());
   printf("%sLast upload attempt time: %s\n",
@@ skipping 15 matching lines @@
 
   for (const CrashReportDatabase::Report& report : reports) {
     printf("%s%s%s\n", spaces.c_str(), report.uuid.ToString().c_str(), colon);
     if (options.show_all_report_info) {
       ShowReport(report, space_count + 2, options.utc);
     }
   }
 }
 
 int DatabaseUtilMain(int argc, char* argv[]) {
-  const std::string me(basename(argv[0]));
+  const std::string me(Basename(argv[0]));
 
   enum OptionFlags {
     // “Short” (single-character) options.
     kOptionDatabase = 'd',
 
     // Long options without short equivalents.
     kOptionLastChar = 255,
     kOptionShowClientID,
     kOptionShowUploadsEnabled,
     kOptionShowLastUploadAttemptTime,
@@ skipping 89 matching lines @@
           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));
+#if defined(OS_POSIX)
+        base::FilePath new_report_path(optarg);
+#elif defined(OS_WIN)
+        base::FilePath new_report_path(base::UTF8ToUTF16(optarg));

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

Similarly, when the entry point is main() and not wmain(), argv is in the
configured code page and not UTF-8, right?

[scottmg, 2015/05/04 23:26:36]

Yes, that's right. I looked at switching to wmain, and then at other option
parsers like e.g. http://optionparser.sourceforge.net/ which support wide chars
but it didn't really seem worth the effort for things in tools/.

So, made this ASCIIToUTF16 to at least be somewhat more accurate (DCHECKs on
>127). This required: https://codereview.chromium.org/1125773004/

+#endif  // OS_POSIX
+        options.new_report_paths.push_back(new_report_path);
         break;
       }
       case kOptionUTC: {
         options.utc = true;
         break;
       }
       case kOptionHelp: {
         Usage(me);
         return EXIT_SUCCESS;
       }
@@ skipping 38 matching lines @@
                                  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;
   }
 
+#if defined(OS_POSIX)
+  base::FilePath database_path(options.database);
+#elif defined(OS_WIN)
+  base::FilePath database_path(base::UTF8ToUTF16(options.database));
+#endif  // OS_POSIX
   scoped_ptr<CrashReportDatabase> database(
-      CrashReportDatabase::Initialize(base::FilePath(options.database)));
+      CrashReportDatabase::Initialize(database_path));
   if (!database) {
     return EXIT_FAILURE;
   }
 
   Settings* settings = database->GetSettings();
 
   // Handle the “show” options before the “set” options so that when they’re
   // specified together, the “show” option reflects the initial state.
 
   if (options.show_client_id) {
@@ skipping 23 matching lines @@
     if (!settings->GetLastUploadAttemptTime(&last_upload_attempt_time)) {
       return EXIT_FAILURE;
     }
 
     const char* prefix =
         (show_operations > 1) ? "Last upload attempt time: " : "";
 
     printf("%s%s (%ld)\n",
            prefix,
            TimeToString(last_upload_attempt_time, options.utc).c_str(),
-           implicit_cast<long>(last_upload_attempt_time));
+           static_cast<long>(last_upload_attempt_time));
   }
 
   if (options.show_pending_reports) {
     std::vector<CrashReportDatabase::Report> pending_reports;
     if (database->GetPendingReports(&pending_reports) !=
         CrashReportDatabase::kNoError) {
       return EXIT_FAILURE;
     }
 
     if (show_operations > 1) {
@@ skipping 91 matching lines @@
 
   return EXIT_SUCCESS;
 }
 
 }  // namespace
 }  // namespace crashpad
 
 int main(int argc, char* argv[]) {
   return crashpad::DatabaseUtilMain(argc, argv);
 }