Breakpad Linux: Log crashes.

chrome/app/breakpad_linux.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // For linux_syscall_support.h. This makes it safe to call embedded system
 // calls when in seccomp mode.
 #define SYS_SYSCALL_ENTRYPOINT "playground$syscallEntryPoint"
 
 #include "chrome/app/breakpad_linux.h"
 
 #include <fcntl.h>
@@ skipping 31 matching lines @@
 // where we either a) know the call cannot fail, or b) there is nothing we
 // can do when a call fails, we mark the return code as ignored. This avoids
 // spurious compiler warnings.
 #define IGNORE_RET(x) do { if (x); } while (0)
 
 static const char kUploadURL[] =
     "https://clients2.google.com/cr/report";
 
 static bool is_crash_reporter_enabled = false;
 static uint64_t process_start_time = 0;
+static char* crash_log_path = NULL;
 
 // Writes the value |v| as 16 hex characters to the memory pointed at by
 // |output|.
 static void write_uint64_hex(char* output, uint64_t v) {
   static const char hextable[] = "0123456789abcdef";
 
   for (int i = 15; i >= 0; --i) {
     output[i] = hextable[v & 15];
     v >>= 4;
   }
@@ skipping 471 matching lines @@
     int fds[2];
     IGNORE_RET(sys_pipe(fds));
 
     const pid_t child = sys_fork();
     if (child) {
       IGNORE_RET(sys_close(fds[1]));
       char id_buf[17];
       const int len = HANDLE_EINTR(sys_read(fds[0], id_buf,
                                    sizeof(id_buf) - 1));
       if (len > 0) {
+        // Write crash dump id to stderr.
         id_buf[len] = 0;
         static const char msg[] = "\nCrash dump id: ";
         sys_write(2, msg, sizeof(msg) - 1);
         sys_write(2, id_buf, my_strlen(id_buf));
         sys_write(2, "\n", 1);
+
+        // Write crash dump id to crash log as: seconds_since_epoch,crash_id
+        struct kernel_timeval tv;
+        if (!sys_gettimeofday(&tv, NULL)) {
+          uint64_t time = kernel_timeval_to_ms(&tv);
+          char time_str[21];
+          const unsigned time_len = my_uint64_len(time);
+          my_uint64tos(time_str, time, time_len);
+
+          int log_fd = sys_open(crash_log_path, O_CREAT | O_WRONLY | O_APPEND,
+                                0600);
+          if (log_fd > 0) {
+            sys_write(log_fd, time_str, time_len);
+            sys_write(log_fd, ",", 1);
+            sys_write(log_fd, id_buf, my_strlen(id_buf));
+            sys_write(log_fd, "\n", 1);
+            IGNORE_RET(sys_close(log_fd));
+          }
+        }
       }
       IGNORE_RET(sys_unlink(info.filename));
       IGNORE_RET(sys_unlink(temp_file));
       sys__exit(0);
     }
 
     IGNORE_RET(sys_close(fds[0]));
     IGNORE_RET(sys_dup2(fds[1], 3));
     static const char* const kWgetBinary = "/usr/bin/wget";
     const char* args[] = {
@@ skipping 68 matching lines @@
 // Wrapper script, do not add more code here.
 static bool CrashDoneUpload(const char* dump_path,
                       const char* minidump_id,
                       void* context,
                       bool succeeded) {
   return CrashDone(dump_path, minidump_id, true, succeeded);
 }
 
 void EnableCrashDumping(const bool unattended) {
   is_crash_reporter_enabled = true;
+
+  FilePath tmp_path("/tmp");

[agl, 2011/02/15 14:33:52]

We certainly can't write files like this into /tmp. How about the user data dir?

[Lei Zhang, 2011/02/15 20:29:48]

DIR_CRASH_DUMPS is relative to DIR_USER_DATA. If a user cannot get
DIR_CRASH_DUMPS, then they probably also cannot get DIR_USER_DATA. In which
case, Chrome will refuse to start.

[agl, 2011/02/15 20:34:14]

In the case that we can't get DIR_CRASH_DUMPS, I think that we should log and
return. Writing into /tmp is open to a symlink attack and the current code could
become a security issue in the event of a distant change.

+  PathService::Get(base::DIR_TEMP, &tmp_path);
+
+  FilePath dumps_path(tmp_path);
+  PathService::Get(chrome::DIR_CRASH_DUMPS, &dumps_path);
+
+  FilePath logfile = dumps_path.AppendASCII("uploads.log");
+  std::string logfile_str = logfile.value();
+  const size_t crash_log_path_len = logfile_str.size() + 1;
+  crash_log_path = new char[crash_log_path_len];
+  strncpy(crash_log_path, logfile_str.c_str(), crash_log_path_len);
+
   if (unattended) {
-    FilePath dumps_path("/tmp");
-    PathService::Get(chrome::DIR_CRASH_DUMPS, &dumps_path);
     new google_breakpad::ExceptionHandler(dumps_path.value().c_str(), NULL,
                                           CrashDoneNoUpload, NULL,
                                           true /* install handlers */);
   } else {
-    new google_breakpad::ExceptionHandler("/tmp", NULL, CrashDoneUpload, NULL,
+    new google_breakpad::ExceptionHandler(tmp_path.value().c_str(), NULL,
+                                          CrashDoneUpload, NULL,
                                           true /* install handlers */);
   }
 }
 
 // Currently Non-Browser = Renderer, Plugins, Native Client and Gpu
 static bool
 NonBrowserCrashHandler(const void* crash_context, size_t crash_context_size,
                        void* context) {
   const int fd = reinterpret_cast<intptr_t>(context);
   int fds[2] = { -1, -1 };
@@ skipping 119 matching lines @@
   struct timeval tv;
   if (!gettimeofday(&tv, NULL))
     process_start_time = timeval_to_ms(&tv);
   else
     process_start_time = 0;
 }
 
 bool IsCrashReporterEnabled() {
   return is_crash_reporter_enabled;
 }