Breakpad Linux: Prevent some memory leaks. (Try 2)

components/breakpad/app/breakpad_linux.cc

 // Copyright 2013 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.
 
 #include "components/breakpad/app/breakpad_linux.h"
 
 #include <fcntl.h>
@@ skipping 185 matching lines @@
 }
 #endif
 
 size_t LengthWithoutTrailingSpaces(const char* str, size_t len) {
   while (len > 0 && str[len - 1] == ' ') {
     len--;
   }
   return len;
 }
 
-// Populates the passed in allocated string and its size with the distro of
-// the crashing process.
-// The passed string is expected to be at least kDistroSize bytes long.
-void PopulateDistro(char* distro, size_t* distro_len_param) {
-  size_t distro_len = std::min(my_strlen(base::g_linux_distro), kDistroSize);
-  memcpy(distro, base::g_linux_distro, distro_len);
-  if (distro_len_param)
-    *distro_len_param = distro_len;
-}
-
 void SetClientIdFromCommandLine(const CommandLine& command_line) {
   // Get the guid and linux distro from the command line switch.
   std::string switch_value =
       command_line.GetSwitchValueASCII(switches::kEnableCrashReporter);
   size_t separator = switch_value.find(",");
   if (separator != std::string::npos) {
     GetBreakpadClient()->SetClientID(switch_value.substr(0, separator));
     base::SetLinuxDistro(switch_value.substr(separator + 1));
   } else {
     GetBreakpadClient()->SetClientID(switch_value);
@@ skipping 465 matching lines @@
     const bool succeeded) {
   // WARNING: this code runs in a compromised context. It may not call into
   // libc nor allocate memory normally.
   if (!succeeded) {
     static const char msg[] = "Crash dump generation failed.\n";
     WriteLog(msg, sizeof(msg) - 1);
     return false;
   }
 
   // Start constructing the message to send to the browser.
-  char distro[kDistroSize + 1] = {0};
-  size_t distro_length = 0;
-  PopulateDistro(distro, &distro_length);
   BreakpadInfo info = {0};
   info.filename = NULL;
   info.fd = descriptor.fd();
   info.process_type = g_process_type;
   info.process_type_length = my_strlen(g_process_type);
-  info.distro = distro;
-  info.distro_length = distro_length;
+  info.distro = NULL;
+  info.distro_length = 0;
   info.upload = false;
   info.process_start_time = g_process_start_time;
   info.pid = g_pid;
   info.crash_keys = g_crash_keys;
   HandleCrashDump(info);
   bool finalize_result = FinalizeCrashDoneAndroid();
   base::android::BuildInfo* android_build_info =
       base::android::BuildInfo::GetInstance();
   if (android_build_info->sdk_int() >= 18 &&
       my_strcmp(android_build_info->build_type(), "eng") != 0 &&
@@ skipping 60 matching lines @@
   virtual bool RequestDump(const void* crash_context,
                            size_t crash_context_size) OVERRIDE {
     int fds[2] = { -1, -1 };
     if (sys_socketpair(AF_UNIX, SOCK_STREAM, 0, fds) < 0) {
       static const char msg[] = "Failed to create socket for crash dumping.\n";
       WriteLog(msg, sizeof(msg) - 1);
       return false;
     }
 
     // Start constructing the message to send to the browser.
-    char distro[kDistroSize + 1] = {0};
-    PopulateDistro(distro, NULL);
-
     char b;  // Dummy variable for sys_read below.
     const char* b_addr = &b;  // Get the address of |b| so we can create the
                               // expected /proc/[pid]/syscall content in the
                               // browser to convert namespace tids.
 
     // The length of the control message:
     static const unsigned kControlMsgSize = sizeof(int);
     static const unsigned kControlMsgSpaceSize = CMSG_SPACE(kControlMsgSize);
     static const unsigned kControlMsgLenSize = CMSG_LEN(kControlMsgSize);
 
     struct kernel_msghdr msg;
     my_memset(&msg, 0, sizeof(struct kernel_msghdr));
     struct kernel_iovec iov[kCrashIovSize];
     iov[0].iov_base = const_cast<void*>(crash_context);
     iov[0].iov_len = crash_context_size;
-    iov[1].iov_base = distro;
-    iov[1].iov_len = kDistroSize + 1;
-    iov[2].iov_base = &b_addr;
-    iov[2].iov_len = sizeof(b_addr);
-    iov[3].iov_base = &fds[0];
-    iov[3].iov_len = sizeof(fds[0]);
-    iov[4].iov_base = &g_process_start_time;
-    iov[4].iov_len = sizeof(g_process_start_time);
-    iov[5].iov_base = &base::g_oom_size;
-    iov[5].iov_len = sizeof(base::g_oom_size);
+    iov[1].iov_base = &b_addr;
+    iov[1].iov_len = sizeof(b_addr);
+    iov[2].iov_base = &fds[0];
+    iov[2].iov_len = sizeof(fds[0]);
+    iov[3].iov_base = &g_process_start_time;
+    iov[3].iov_len = sizeof(g_process_start_time);
+    iov[4].iov_base = &base::g_oom_size;
+    iov[4].iov_len = sizeof(base::g_oom_size);
     google_breakpad::SerializedNonAllocatingMap* serialized_map;
-    iov[6].iov_len = g_crash_keys->Serialize(
+    iov[5].iov_len = g_crash_keys->Serialize(
         const_cast<const google_breakpad::SerializedNonAllocatingMap**>(
             &serialized_map));
-    iov[6].iov_base = serialized_map;
-#if defined(ADDRESS_SANITIZER)
-    iov[7].iov_base = const_cast<char*>(g_asan_report_str);
-    iov[7].iov_len = kMaxAsanReportSize + 1;
+    iov[5].iov_base = serialized_map;
+#if !defined(ADDRESS_SANITIZER)
+    COMPILE_ASSERT(5 == kCrashIovSize - 1, Incorrect_Number_Of_Iovec_Members);
+#else
+    iov[6].iov_base = const_cast<char*>(g_asan_report_str);
+    iov[6].iov_len = kMaxAsanReportSize + 1;
+    COMPILE_ASSERT(6 == kCrashIovSize - 1, Incorrect_Number_Of_Iovec_Members);
 #endif
 
     msg.msg_iov = iov;
     msg.msg_iovlen = kCrashIovSize;
     char cmsg[kControlMsgSpaceSize];
     my_memset(cmsg, 0, kControlMsgSpaceSize);
     msg.msg_control = cmsg;
     msg.msg_controllen = sizeof(cmsg);
 
     struct cmsghdr *hdr = CMSG_FIRSTHDR(&msg);
@@ skipping 791 matching lines @@
     }
   }
 }
 #endif  // OS_ANDROID
 
 bool IsCrashReporterEnabled() {
   return g_is_crash_reporter_enabled;
 }
 
 }  // namespace breakpad