Generate GUIDs for users who wish to upload crash reports. Include it in cra...

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 <fcntl.h>
 #include <sys/socket.h>
 #include <sys/uio.h>
 #include <unistd.h>
 
 #include <string>
@@ skipping 18 matching lines @@
 // |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* crash_url,
-                      unsigned crash_url_length) {
+pid_t UploadCrashDump(const char* filename,
+                      const char* crash_url,
+                      unsigned crash_url_length,
+                      const char* guid,
+                      unsigned guid_length) {
   // 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);
   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 70 matching lines @@
     version_msg[i] = static_cast<char>(version[i]);
 
   // The MIME block looks like this:
   //   BOUNDARY \r\n (0, 1)
   //   Content-Disposition: form-data; name="prod" \r\n \r\n (2..6)
   //   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="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-";
 
-  struct kernel_iovec iov[20];
+  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);
   iov[3].iov_len = sizeof(prod_msg) - 1;
   iov[4].iov_base = const_cast<char*>(quote_msg);
@@ skipping 27 matching lines @@
   iov[16].iov_base = const_cast<char*>(version_msg);
   iov[16].iov_len = sizeof(version_msg) - 1;
   iov[17].iov_base = const_cast<char*>(rn);
   iov[17].iov_len = sizeof(rn);
 
   iov[18].iov_base = mime_boundary;
   iov[18].iov_len = sizeof(mime_boundary) - 1;
   iov[19].iov_base = const_cast<char*>(rn);
   iov[19].iov_len = sizeof(rn);
 
-  sys_writev(fd, iov, 20);
+  iov[20].iov_base = const_cast<char*>(form_data_msg);
+  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[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 (crash_url_length) {
     unsigned i = 0, done = 0;
     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];
@@ skipping 118 matching lines @@
 
     const pid_t child = sys_fork();
     if (child) {
       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(buf));
+        sys_write(2, id_buf, my_strlen(id_buf));
         sys_write(2, "\n", 1);
       }
       sys_unlink(filename);
       sys_unlink(buf);
       sys__exit(0);
     }
 
     sys_close(fds[0]);
     sys_dup2(fds[1], 3);
     static const char* const kWgetBinary = "/usr/bin/wget";
@@ skipping 10 matching lines @@
     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;
+}
+
 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, NULL, 0);
+  UploadCrashDump(path, NULL, 0, google_update::linux_guid.data(),
+                  google_update::linux_guid.length());
 
   return true;
 }
 
 void EnableCrashDumping() {
   // We leak this object.
 
   new google_breakpad::ExceptionHandler("/tmp", NULL, CrashDone, NULL,
                                         true /* install handlers */);
 }
@@ skipping 14 matching lines @@
 
   // The length of the control message:
   static const unsigned kControlMsgSize =
       CMSG_SPACE(sizeof(int)) + CMSG_SPACE(sizeof(struct ucred));
 
   union {
     struct kernel_msghdr msg;
     struct msghdr sys_msg;
   };
   my_memset(&msg, 0, sizeof(struct kernel_msghdr));
-  struct kernel_iovec iov[2];
+  struct kernel_iovec iov[3];
   iov[0].iov_base = const_cast<void*>(crash_context);
   iov[0].iov_len = crash_context_size;
-  iov[1].iov_base = const_cast<char*>(renderer_logging::active_url.data());
-  iov[1].iov_len = renderer_logging::active_url.size();
+  iov[1].iov_base = const_cast<char*>(google_update::linux_guid.data());
+  iov[1].iov_len = google_update::linux_guid.size();
+  iov[2].iov_base = const_cast<char*>(renderer_logging::active_url.data());
+  iov[2].iov_len = renderer_logging::active_url.size();
 
   msg.msg_iov = iov;
-  msg.msg_iovlen = 2;
+  msg.msg_iovlen = 3;
   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 33 matching lines @@
 
   // 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())
     EnableCrashDumping();
   else if (process_type == switches::kRendererProcess)
     EnableRendererCrashDumping();
 }