Reverting 24220.

chrome/app/breakpad_linux.cc

 // Copyright (c) 2009 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.
 
 #include "chrome/app/breakpad_linux.h"
 
 #include <arpa/inet.h>
 #include <fcntl.h>
 #include <netinet/in.h>
-#include <stdlib.h>
 #include <sys/sendfile.h>
 #include <sys/socket.h>
 #include <sys/uio.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/eintr_wrapper.h"
-#include "base/file_path.h"
 #include "base/file_version_info_linux.h"
 #include "base/format_macros.h"
 #include "base/global_descriptors_posix.h"
 #include "base/json_writer.h"
 #include "base/linux_util.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/scoped_fd.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "breakpad/linux/directory_reader.h"
 #include "breakpad/linux/exception_handler.h"
 #include "breakpad/linux/linux_libc_support.h"
 #include "breakpad/linux/linux_syscall_support.h"
 #include "breakpad/linux/memory.h"
 #include "chrome/common/chrome_descriptors.h"
-#include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/installer/util/google_update_settings.h"
 
 static const char kUploadURL[] =
     "https://clients2.google.com/cr/report";
 
 // 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;
   }
 }
 
-pid_t HandleCrashDump(const BreakpadInfo& info) {
+pid_t UploadCrashDump(const BreakpadInfo& info) {
   // WARNING: this code runs in a compromised context. It may not call into
   // libc nor allocate memory normally.
 
   const int dumpfd = sys_open(info.filename, O_RDONLY, 0);
   if (dumpfd < 0) {
     static const char msg[] = "Cannot upload crash dump: failed to open\n";
     sys_write(2, msg, sizeof(msg));
     return -1;
   }
   struct kernel_stat st;
@@ skipping 23 matching lines @@
   const int ufd = sys_open("/dev/urandom", O_RDONLY, 0);
   if (ufd < 0) {
     static const char msg[] = "Cannot upload crash dump because /dev/urandom"
                               " is missing\n";
     sys_write(2, msg, sizeof(msg) - 1);
     return -1;
   }
 
   static const char temp_file_template[] =
       "/tmp/chromium-upload-XXXXXXXXXXXXXXXX";
-  char temp_file[sizeof(temp_file_template)];
+  char buf[sizeof(temp_file_template)];
+  memcpy(buf, temp_file_template, sizeof(temp_file_template));
+
   int fd = -1;
-  if (info.upload) {
-    memcpy(temp_file, temp_file_template, sizeof(temp_file_template));
+  for (unsigned i = 0; i < 10; ++i) {
+    uint64_t t;
+    read(ufd, &t, sizeof(t));
+    write_uint64_hex(buf + sizeof(buf) - (16 + 1), t);
 
-    for (unsigned i = 0; i < 10; ++i) {
-      uint64_t t;
-      read(ufd, &t, sizeof(t));
-      write_uint64_hex(temp_file + sizeof(temp_file) - (16 + 1), t);
-
-      fd = sys_open(temp_file, O_WRONLY | O_CREAT | O_EXCL, 0600);
-      if (fd >= 0)
-        break;
-    }
-
-    if (fd < 0) {
-      static const char msg[] = "Failed to create temporary file in /tmp: "
-          "cannot upload crash dump\n";
-      sys_write(2, msg, sizeof(msg) - 1);
-      sys_close(ufd);
-      return -1;
-    }
-  } else {
-    fd = sys_open(info.filename, O_WRONLY, 0600);
-    if (fd < 0) {
-      static const char msg[] = "Failed to save crash dump: failed to open\n";
-      sys_write(2, msg, sizeof(msg) - 1);
-      sys_close(ufd);
-      return -1;
-    }
+    fd = sys_open(buf, O_WRONLY | O_CREAT | O_EXCL, 0600);
+    if (fd >= 0)
+      break;
   }
 
-  // The MIME boundary is 28 hyphens, followed by a 64-bit nonce and a NUL.
+  if (fd == -1) {
+    static const char msg[] = "Failed to create temporary file in /tmp: cannot "
+                              "upload crash dump\n";
+    sys_write(2, msg, sizeof(msg) - 1);
+    sys_close(ufd);
+    return -1;
+  }
+
+  // The MIME boundary is 28 hypens, followed by a 64-bit nonce and a NUL.
   char mime_boundary[28 + 16 + 1];
   my_memset(mime_boundary, '-', 28);
   uint64_t boundary_rand;
   sys_read(ufd, &boundary_rand, sizeof(boundary_rand));
   write_uint64_hex(mime_boundary + 28, boundary_rand);
   mime_boundary[28 + 16] = 0;
   sys_close(ufd);
 
   // The define for the product version is a wide string, so we need to
   // downconvert it.
@@ skipping 235 matching lines @@
   iov[8].iov_len = sizeof(mime_boundary) - 1;
   iov[9].iov_base = const_cast<char*>(dashdash_msg);
   iov[9].iov_len = sizeof(dashdash_msg);
   iov[10].iov_base = const_cast<char*>(rn);
   iov[10].iov_len = sizeof(rn);
 
   sys_writev(fd, iov, 11);
 
   sys_close(fd);
 
-  if (!info.upload)
-    return 0;
-
   // The --header argument to wget looks like:
   //   --header=Content-Type: multipart/form-data; boundary=XYZ
   // where the boundary has two fewer leading '-' chars
   static const char header_msg[] =
       "--header=Content-Type: multipart/form-data; boundary=";
   char* const header = reinterpret_cast<char*>(allocator.Alloc(
       sizeof(header_msg) - 1 + sizeof(mime_boundary) - 2));
   memcpy(header, header_msg, sizeof(header_msg) - 1);
   memcpy(header + sizeof(header_msg) - 1, mime_boundary + 2,
          sizeof(mime_boundary) - 2);
   // We grab the NUL byte from the end of |mime_boundary|.
 
   // The --post-file argument to wget looks like:
   //   --post-file=/tmp/...
   static const char post_file_msg[] = "--post-file=";
   char* const post_file = reinterpret_cast<char*>(allocator.Alloc(
-       sizeof(post_file_msg) - 1 + sizeof(temp_file)));
+       sizeof(post_file_msg) - 1 + sizeof(buf)));
   memcpy(post_file, post_file_msg, sizeof(post_file_msg) - 1);
-  memcpy(post_file + sizeof(post_file_msg) - 1, temp_file, sizeof(temp_file));
+  memcpy(post_file + sizeof(post_file_msg) - 1, buf, sizeof(buf));
 
   const pid_t child = sys_fork();
   if (!child) {
     // This code is called both when a browser is crashing (in which case,
     // nothing really matters any more) and when a renderer crashes, in which
     // case we need to continue.
     //
     // Since we are a multithreaded app, if we were just to fork(), we might
     // grab file descriptors which have just been created in another thread and
     // hold them open for too long.
@@ skipping 29 matching lines @@
       char id_buf[17];
       const int len = HANDLE_EINTR(read(fds[0], id_buf, sizeof(id_buf) - 1));
       if (len > 0) {
         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);
       }
       sys_unlink(info.filename);
-      sys_unlink(temp_file);
+      sys_unlink(buf);
       sys__exit(0);
     }
 
     sys_close(fds[0]);
     sys_dup2(fds[1], 3);
     static const char* const kWgetBinary = "/usr/bin/wget";
     const char* args[] = {
       kWgetBinary,
       header,
       post_file,
       kUploadURL,
       "-O",  // output reply to fd 3
       "/dev/fd/3",
       NULL,
     };
 
-    execv(kWgetBinary, const_cast<char**>(args));
+    execv("/usr/bin/wget", const_cast<char**>(args));
     static const char msg[] = "Cannot upload crash dump: cannot exec "
                               "/usr/bin/wget\n";
     sys_write(2, msg, sizeof(msg) - 1);
     sys__exit(1);
   }
 
   return child;
 }
 
 // This is defined in chrome/browser/google_update_settings_linux.cc, it's the
 // static string containing the user's unique GUID. We send this in the crash
 // report.
 namespace google_update {
 extern std::string linux_guid;
 }
 
 // This is defined in base/linux_util.cc, it's the static string containing the
 // user's distro info. We send this in the crash report.
 namespace base {
 extern std::string linux_distro;
 }
 
 static bool CrashDone(const char* dump_path,
                       const char* minidump_id,
-                      const bool upload,
-                      const bool succeeded) {
+                      void* context,
+                      bool succeeded) {
   // WARNING: this code runs in a compromised context. It may not call into
   // libc nor allocate memory normally.
   if (!succeeded)
     return false;
 
   google_breakpad::PageAllocator allocator;
   const unsigned dump_path_len = my_strlen(dump_path);
   const unsigned minidump_id_len = my_strlen(minidump_id);
   char *const path = reinterpret_cast<char*>(allocator.Alloc(
       dump_path_len + 1 /* '/' */ + minidump_id_len +
       4 /* ".dmp" */ + 1 /* NUL */));
   memcpy(path, dump_path, dump_path_len);
   path[dump_path_len] = '/';
   memcpy(path + dump_path_len + 1, minidump_id, minidump_id_len);
   memcpy(path + dump_path_len + 1 + minidump_id_len, ".dmp", 4);
   path[dump_path_len + 1 + minidump_id_len + 4] = 0;
 
   BreakpadInfo info;
   info.filename = path;
   info.process_type = "browser";
   info.process_type_length = 7;
   info.crash_url = NULL;
   info.crash_url_length = 0;
   info.guid = google_update::linux_guid.data();
   info.guid_length = google_update::linux_guid.length();
   info.distro = base::linux_distro.data();
   info.distro_length = base::linux_distro.length();
-  info.upload = upload;
-  HandleCrashDump(info);
+  UploadCrashDump(info);
 
   return true;
 }
 
-// Wrapper script, do not add more code here.
-static bool CrashDoneNoUpload(const char* dump_path,
-                      const char* minidump_id,
-                      void* context,
-                      bool succeeded) {
-  return CrashDone(dump_path, minidump_id, false, succeeded);
-}
+void EnableCrashDumping() {
+  // We leak this object.
 
-// 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) {
-  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,
-                                          true /* install handlers */);
-  }
+  new google_breakpad::ExceptionHandler("/tmp", NULL, CrashDone, NULL,
+                                        true /* install handlers */);
 }
 
 // This is defined in chrome/common/child_process_logging_linux.cc, it's the
 // static string containing the current active URL. We send this in the crash
 // report.
 namespace child_process_logging {
 extern std::string active_url;
 }
 
 static bool
@@ skipping 59 matching lines @@
       new google_breakpad::ExceptionHandler("" /* unused */, NULL, NULL,
                                             (void*) fd, true);
   handler->set_crash_handler(RendererCrashHandler);
 }
 
 void InitCrashReporter() {
   // Determine the process type and take appropriate action.
   const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
   const std::wstring process_type =
       parsed_command_line.GetSwitchValue(switches::kProcessType);
-  const bool unattended = (getenv("CHROME_HEADLESS") != NULL);
   if (process_type.empty()) {
-    if (!(unattended || GoogleUpdateSettings::GetCollectStatsConsent()))
+    if (!GoogleUpdateSettings::GetCollectStatsConsent())
       return;
     base::GetLinuxDistro();  // Initialize base::linux_distro if needed.
-    EnableCrashDumping(unattended);
+    EnableCrashDumping();
   } else if (process_type == switches::kRendererProcess ||
              process_type == switches::kZygoteProcess) {
     // We might be chrooted in a zygote or renderer process so we cannot call
     // GetCollectStatsConsent because that needs access the the user's home
     // dir. Instead, we set a command line flag for these processes.
     if (!parsed_command_line.HasSwitch(switches::kEnableCrashReporter))
       return;
     // Get the guid and linux distro from the command line switch.
     std::string switch_value = WideToASCII(
         parsed_command_line.GetSwitchValue(switches::kEnableCrashReporter));
     size_t separator = switch_value.find(",");
     if (separator != std::string::npos) {
       google_update::linux_guid = switch_value.substr(0, separator);
       base::linux_distro = switch_value.substr(separator + 1);
     } else {
       google_update::linux_guid = switch_value;
     }
     EnableRendererCrashDumping();
   }
 }
 
 // -----------------------------------------------------------------------------
 
-#if defined(GOOGLE_CHROME_BUILD)
 bool EnableCoreDumping(std::string* core_dump_directory) {
   // First we check that the core files will get dumped to the
   // current-directory in a file called 'core'. We could try to support other
   // setups by simulating the kernel's code, but it's extra complexity and we
   // only intend for this code to be run internally.
   static const char kCorePatternFd[] = "/proc/sys/kernel/core_pattern";
 
   ScopedFd core_pattern_fd(open(kCorePatternFd, O_RDONLY));
   if (core_pattern_fd.get() < 0) {
     LOG(WARNING) << "Cannot open " << kCorePatternFd << ": " << strerror(errno);
@@ skipping 80 matching lines @@
     return;
   }
 
   const uint64_t binary_size = st.st_size;
 
   DictionaryValue header;
   header.SetString(L"core-size", StringPrintf("%" PRIu32, core_size));
   header.SetString(L"chrome-version", FILE_VERSION);
   header.SetString(L"binary-size", StringPrintf("%" PRIu64, binary_size));
   header.SetString(L"user", getenv("USER"));
+#if defined(GOOGLE_CHROME_BUILD)
   header.SetBoolean(L"offical-build", true);
+#endif
 
   std::string json;
   JSONWriter::Write(&header, true /* pretty print */, &json);
   const uint32_t json_size = json.size();
 
   ScopedFd sock(socket(PF_INET, SOCK_STREAM, 0));
   if (sock.get() < 0) {
     LOG(WARNING) << "Cannot open socket: " << strerror(errno);
     return;
   }
@@ skipping 35 matching lines @@
   }
 
   if (WIFSIGNALED(status) && WCOREDUMP(status)) {
     std::string core_filename;
     UploadCoreFile(child, &core_filename);
     unlink(core_filename.c_str());
   }
 
   rmdir(core_dump_directory.c_str());
 }
-#endif