Update Crashpad to 32981a3ee9d7c2769fb27afa038fe2e194cfa329

third_party/crashpad/crashpad/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 20 matching lines @@
 #include "base/macros.h"
 #include "base/numerics/safe_conversions.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"
+#include "util/stdlib/string_number_conversion.h"
 
 namespace crashpad {
 namespace {
 
 void Usage(const base::FilePath& me) {
   fprintf(stderr,
 "Usage: %" PRFilePath " [OPTION]... PID\n"
 "Operate on Crashpad crash report databases.\n"
 "\n"
 "      --create                    allow database at PATH to be created\n"
@@ skipping 72 matching lines @@
   }
 
   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
+// Converts |string| to |out_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) {
+// representations and a numeric time_t representation. The special |string|
+// "never" is recognized as converted to a |out_time| value of 0; "now" is
+// converted to the current time. |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* out_time, bool utc) {
   if (strcasecmp(string, "never") == 0) {
-    *time = 0;
+    *out_time = 0;
     return true;
   }
 
+  if (strcasecmp(string, "now") == 0) {
+    errno = 0;
+    PCHECK(time(out_time) != -1 || errno == 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);
     if (strptime_result == end) {
+      time_t test_out_time;
       if (utc) {
-        *time = timegm(&time_tm);
+        test_out_time = timegm(&time_tm);
       } else {
-        *time = mktime(&time_tm);
+        test_out_time = mktime(&time_tm);
       }
 
-      return true;
+      // mktime() is supposed to set errno in the event of an error, but support
+      // for this is spotty, so there’s no way to distinguish between a true
+      // time_t of -1 (1969-12-31 23:59:59 UTC) and an error. Assume error.
+      //
+      // See 10.11.5 Libc-1082.50.1/stdtime/FreeBSD/localtime.c and
+      // glibc-2.24/time/mktime.c, which don’t set errno or save and restore
+      // errno. Post-Android 7.1.0 Bionic is even more hopeless, setting errno
+      // whenever the time conversion returns -1, even for valid input. See
+      // libc/tzcode/localtime.c mktime(). Windows seems to get it right: see
+      // 10.0.14393 SDK Source/ucrt/time/mktime.cpp.
+      if (test_out_time != -1) {
+        *out_time = test_out_time;
+        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;
+  int64_t int64_result;
+  if (StringToNumber(string, &int64_result) &&
+      base::IsValueInRangeForNumericType<time_t>(int64_result)) {
+    *out_time = int64_result;
     return true;
   }
 
   return false;
 }
 
-// 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
+// Converts |out_time| to a string, and returns it. |utc| determines whether the
+// converted time will reference local time or UTC. If |out_time| 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) {
+std::string TimeToString(time_t out_time, bool utc) {
+  if (out_time == 0) {
     return std::string("never");
   }
 
   tm time_tm;
   if (utc) {
-    gmtime_r(&time_tt, &time_tm);
+    PCHECK(gmtime_r(&out_time, &time_tm));
   } else {
-    localtime_r(&time_tt, &time_tm);
+    PCHECK(localtime_r(&out_time, &time_tm));
   }
 
   char string[64];
   CHECK_NE(
       strftime(string, arraysize(string), "%Y-%m-%d %H:%M:%S %Z", &time_tm),
       0u);
 
   return std::string(string);
 }
 
@@ skipping 403 matching lines @@
 
 #if defined(OS_POSIX)
 int main(int argc, char* argv[]) {
   return crashpad::DatabaseUtilMain(argc, argv);
 }
 #elif defined(OS_WIN)
 int wmain(int argc, wchar_t* argv[]) {
   return crashpad::ToolSupport::Wmain(argc, argv, crashpad::DatabaseUtilMain);
 }
 #endif  // OS_POSIX