Include output of "lsb_release -d" in crash reports....

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 <fcntl.h>
 #include <sys/socket.h>
 #include <sys/uio.h>
 #include <unistd.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/eintr_wrapper.h"
 #include "base/file_version_info_linux.h"
 #include "base/global_descriptors_posix.h"
+#include "base/linux_util.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/string_util.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_switches.h"
 #include "chrome/common/chrome_descriptors.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 UploadCrashDump(const char* filename,
-                      const char* process_type,
-                      unsigned process_type_length,
-                      const char* crash_url,
-                      unsigned crash_url_length,
-                      const char* guid,
-                      unsigned guid_length) {
+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(filename, O_RDONLY, 0);
+  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;
   if (sys_fstat(dumpfd, &st) != 0) {
     static const char msg[] = "Cannot upload crash dump: stat failed\n";
     sys_write(2, msg, sizeof(msg));
     sys_close(dumpfd);
@@ skipping 71 matching lines @@
   //   Chrome_Linux \r\n (7, 8)
   //   BOUNDARY \r\n (9, 10)
   //   Content-Disposition: form-data; name="ver" \r\n \r\n (11..15)
   //   1.2.3.4 \r\n (16, 17)
   //   BOUNDARY \r\n (18, 19)
   //   Content-Disposition: form-data; name="guid" \r\n \r\n (20..24)
   //   1.2.3.4 \r\n (25, 26)
   //   BOUNDARY \r\n (27, 28)
   //
   //   zero or more:
+  //   Content-Disposition: form-data; name="ptype" \r\n \r\n (0..4)
+  //   abcdef \r\n (5, 6)
+  //   BOUNDARY \r\n (7, 8)
+  //
+  //   zero or more:
+  //   Content-Disposition: form-data; name="lsb-release" \r\n \r\n (0..4)
+  //   abcdef \r\n (5, 6)
+  //   BOUNDARY \r\n (7, 8)
+  //
+  //   zero or more:
   //   Content-Disposition: form-data; name="url-chunk-1" \r\n \r\n (0..5)
   //   abcdef \r\n (6, 7)
   //   BOUNDARY \r\n (8, 9)
   //
   //   Content-Disposition: form-data; name="dump"; filename="dump" \r\n (0,1,2)
   //   Content-Type: application/octet-stream \r\n \r\n (3,4,5)
   //   <dump contents> (6)
   //   \r\n BOUNDARY -- \r\n (7,8,9,10)
 
   static const char rn[] = {'\r', '\n'};
   static const char form_data_msg[] = "Content-Disposition: form-data; name=\"";
   static const char prod_msg[] = "prod";
   static const char quote_msg[] = {'"'};
   static const char chrome_linux_msg[] = "Chrome_Linux";
   static const char ver_msg[] = "ver";
   static const char guid_msg[] = "guid";
   static const char dashdash_msg[] = {'-', '-'};
   static const char dump_msg[] = "upload_file_minidump\"; filename=\"dump\"";
   static const char content_type_msg[] =
       "Content-Type: application/octet-stream";
   static const char url_chunk_msg[] = "url-chunk-";
   static const char process_type_msg[] = "ptype";
+  static const char distro_msg[] = "lsb-release";
 
   struct kernel_iovec iov[29];
   iov[0].iov_base = mime_boundary;
   iov[0].iov_len = sizeof(mime_boundary) - 1;
   iov[1].iov_base = const_cast<char*>(rn);
   iov[1].iov_len = sizeof(rn);
 
   iov[2].iov_base = const_cast<char*>(form_data_msg);
   iov[2].iov_len = sizeof(form_data_msg) - 1;
   iov[3].iov_base = const_cast<char*>(prod_msg);
@@ skipping 40 matching lines @@
   iov[20].iov_len = sizeof(form_data_msg) - 1;
   iov[21].iov_base = const_cast<char*>(guid_msg);
   iov[21].iov_len = sizeof(guid_msg) - 1;
   iov[22].iov_base = const_cast<char*>(quote_msg);
   iov[22].iov_len = sizeof(quote_msg);
   iov[23].iov_base = const_cast<char*>(rn);
   iov[23].iov_len = sizeof(rn);
   iov[24].iov_base = const_cast<char*>(rn);
   iov[24].iov_len = sizeof(rn);
 
-  iov[25].iov_base = const_cast<char*>(guid);
-  iov[25].iov_len = guid_length;
+  iov[25].iov_base = const_cast<char*>(info.guid);
+  iov[25].iov_len = info.guid_length;
   iov[26].iov_base = const_cast<char*>(rn);
   iov[26].iov_len = sizeof(rn);
 
   iov[27].iov_base = mime_boundary;
   iov[27].iov_len = sizeof(mime_boundary) - 1;
   iov[28].iov_base = const_cast<char*>(rn);
   iov[28].iov_len = sizeof(rn);
 
   sys_writev(fd, iov, 29);
 
-  if (process_type_length) {
+  if (info.process_type_length) {
     iov[0].iov_base = const_cast<char*>(form_data_msg);
     iov[0].iov_len = sizeof(form_data_msg) - 1;
     iov[1].iov_base = const_cast<char*>(process_type_msg);
     iov[1].iov_len = sizeof(process_type_msg) - 1;
     iov[2].iov_base = const_cast<char*>(quote_msg);
     iov[2].iov_len = sizeof(quote_msg);
     iov[3].iov_base = const_cast<char*>(rn);
     iov[3].iov_len = sizeof(rn);
     iov[4].iov_base = const_cast<char*>(rn);
     iov[4].iov_len = sizeof(rn);
 
-    iov[5].iov_base = const_cast<char*>(process_type);
-    iov[5].iov_len = process_type_length;
+    iov[5].iov_base = const_cast<char*>(info.process_type);
+    iov[5].iov_len = info.process_type_length;
     iov[6].iov_base = const_cast<char*>(rn);
     iov[6].iov_len = sizeof(rn);
     iov[7].iov_base = mime_boundary;
     iov[7].iov_len = sizeof(mime_boundary) - 1;
     iov[8].iov_base = const_cast<char*>(rn);
     iov[8].iov_len = sizeof(rn);
 
     sys_writev(fd, iov, 9);
   }
 
-  if (crash_url_length) {
-    unsigned i = 0, done = 0;
+  if (info.distro_length) {
+    iov[0].iov_base = const_cast<char*>(form_data_msg);
+    iov[0].iov_len = sizeof(form_data_msg) - 1;
+    iov[1].iov_base = const_cast<char*>(distro_msg);
+    iov[1].iov_len = sizeof(distro_msg) - 1;
+    iov[2].iov_base = const_cast<char*>(quote_msg);
+    iov[2].iov_len = sizeof(quote_msg);
+    iov[3].iov_base = const_cast<char*>(rn);
+    iov[3].iov_len = sizeof(rn);
+    iov[4].iov_base = const_cast<char*>(rn);
+    iov[4].iov_len = sizeof(rn);
+
+    iov[5].iov_base = const_cast<char*>(info.distro);
+    iov[5].iov_len = info.distro_length;
+    iov[6].iov_base = const_cast<char*>(rn);
+    iov[6].iov_len = sizeof(rn);
+    iov[7].iov_base = mime_boundary;
+    iov[7].iov_len = sizeof(mime_boundary) - 1;
+    iov[8].iov_base = const_cast<char*>(rn);
+    iov[8].iov_len = sizeof(rn);
+
+    sys_writev(fd, iov, 9);
+  }
+
+  if (info.crash_url_length) {
+    unsigned i = 0, done = 0, crash_url_length = info.crash_url_length;
     static const unsigned kMaxCrashChunkSize = 64;
     static const unsigned kMaxUrlLength = 8 * kMaxCrashChunkSize;
     if (crash_url_length > kMaxUrlLength)
       crash_url_length = kMaxUrlLength;
 
     while (crash_url_length) {
       char num[16];
       const unsigned num_len = my_int_len(++i);
       my_itos(num, i, num_len);
 
       iov[0].iov_base = const_cast<char*>(form_data_msg);
       iov[0].iov_len = sizeof(form_data_msg) - 1;
       iov[1].iov_base = const_cast<char*>(url_chunk_msg);
       iov[1].iov_len = sizeof(url_chunk_msg) - 1;
       iov[2].iov_base = num;
       iov[2].iov_len = num_len;
       iov[3].iov_base = const_cast<char*>(quote_msg);
       iov[3].iov_len = sizeof(quote_msg);
       iov[4].iov_base = const_cast<char*>(rn);
       iov[4].iov_len = sizeof(rn);
       iov[5].iov_base = const_cast<char*>(rn);
       iov[5].iov_len = sizeof(rn);
 
       const unsigned len = crash_url_length > kMaxCrashChunkSize ?
                            kMaxCrashChunkSize : crash_url_length;
-      iov[6].iov_base = const_cast<char*>(crash_url + done);
+      iov[6].iov_base = const_cast<char*>(info.crash_url + done);
       iov[6].iov_len = len;
       iov[7].iov_base = const_cast<char*>(rn);
       iov[7].iov_len = sizeof(rn);
       iov[8].iov_base = mime_boundary;
       iov[8].iov_len = sizeof(mime_boundary) - 1;
       iov[9].iov_base = const_cast<char*>(rn);
       iov[9].iov_len = sizeof(rn);
 
       sys_writev(fd, iov, 10);
 
@@ skipping 92 matching lines @@
       sys_close(fds[1]);
       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(filename);
+      sys_unlink(info.filename);
       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,
@@ skipping 14 matching lines @@
   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,
                       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;
 
-  UploadCrashDump(path, "browser", 7, NULL, 0, google_update::linux_guid.data(),
-                  google_update::linux_guid.length());
+  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();
+  UploadCrashDump(info);
 
   return true;
 }
 
 void EnableCrashDumping() {
   // We leak this object.
 
   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
 RendererCrashHandler(const void* crash_context, size_t crash_context_size,
              void* context) {
-  const int fd = (int) context;
+  const int fd = reinterpret_cast<int>(context);
   int fds[2];
   socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
   char guid[kGuidSize] = {0};
   char crash_url[kMaxActiveURLSize + 1] = {0};
+  char distro[kDistroSize + 1] = {0};
   const unsigned guid_len = std::min(google_update::linux_guid.size(),
                                      kGuidSize);
   const unsigned crash_url_len =
       std::min(child_process_logging::active_url.size(), kMaxActiveURLSize);
+  const unsigned distro_len =
+      std::min(base::linux_distro.size(), kDistroSize);
   memcpy(guid, google_update::linux_guid.data(), guid_len);
   memcpy(crash_url, child_process_logging::active_url.data(), crash_url_len);
+  memcpy(distro, base::linux_distro.data(), distro_len);
 
   // The length of the control message:
   static const unsigned kControlMsgSize = CMSG_SPACE(sizeof(int));
 
   struct kernel_msghdr msg;
   my_memset(&msg, 0, sizeof(struct kernel_msghdr));
-  struct kernel_iovec iov[3];
+  struct kernel_iovec iov[4];
   iov[0].iov_base = const_cast<void*>(crash_context);
   iov[0].iov_len = crash_context_size;
   iov[1].iov_base = guid;
   iov[1].iov_len = kGuidSize + 1;
   iov[2].iov_base = crash_url;
   iov[2].iov_len = kMaxActiveURLSize + 1;
+  iov[3].iov_base = distro;
+  iov[3].iov_len = kDistroSize + 1;
 
   msg.msg_iov = iov;
-  msg.msg_iovlen = 3;
+  msg.msg_iovlen = 4;
   char cmsg[kControlMsgSize];
   memset(cmsg, 0, kControlMsgSize);
   msg.msg_control = cmsg;
   msg.msg_controllen = sizeof(cmsg);
 
   struct cmsghdr *hdr = CMSG_FIRSTHDR(&msg);
   hdr->cmsg_level = SOL_SOCKET;
   hdr->cmsg_type = SCM_RIGHTS;
   hdr->cmsg_len = CMSG_LEN(sizeof(int));
   *((int*) CMSG_DATA(hdr)) = fds[1];
@@ skipping 17 matching lines @@
 }
 
 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);
   if (process_type.empty()) {
     if (!GoogleUpdateSettings::GetCollectStatsConsent())
       return;
+    base::GetLinuxDistro();  // Initialize base::linux_distro if needed.
     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::kRendererCrashDump))
       return;
-    google_update::linux_guid = WideToASCII(
+    // Get the guid and linux distro from the command line switch.
+    std::string switch_value = WideToASCII(
         parsed_command_line.GetSwitchValue(switches::kRendererCrashDump));
+    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();
   }
 }