Add an optional root prefix to Linux dumpers

src/client/linux/minidump_writer/linux_dumper.cc

 // Copyright (c) 2010, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 70 matching lines @@
   return my_strncmp(mapping.name,
                     kMappedFileUnsafePrefix,
                     sizeof(kMappedFileUnsafePrefix) - 1) == 0;
 }
 
 namespace google_breakpad {
 
 // All interesting auvx entry types are below AT_SYSINFO_EHDR
 #define AT_MAX AT_SYSINFO_EHDR
 
-LinuxDumper::LinuxDumper(pid_t pid)
+LinuxDumper::LinuxDumper(pid_t pid, const char* root_prefix)
     : pid_(pid),
+      root_prefix_(root_prefix),
       crash_address_(0),
       crash_signal_(0),
       crash_thread_(pid),
       threads_(&allocator_, 8),
       mappings_(&allocator_),
       auxv_(&allocator_, AT_MAX + 1) {
+  assert(root_prefix_ && my_strlen(root_prefix_) < PATH_MAX);
   // The passed-in size to the constructor (above) is only a hint.
   // Must call .resize() to do actual initialization of the elements.
   auxv_.resize(AT_MAX + 1);
 }
 
 LinuxDumper::~LinuxDumper() {
 }
 
 bool LinuxDumper::Init() {
   return ReadAuxv() && EnumerateThreads() && EnumerateMappings();
@@ skipping 23 matching lines @@
       linux_gate = reinterpret_cast<void*>(mapping.start_addr);
     } else {
       linux_gate = allocator_.Alloc(mapping.size);
       CopyFromProcess(linux_gate, pid_,
                       reinterpret_cast<const void*>(mapping.start_addr),
                       mapping.size);
     }
     return FileID::ElfFileIdentifierFromMappedFile(linux_gate, identifier);
   }
 
-  char filename[NAME_MAX];
-  size_t filename_len = my_strlen(mapping.name);
-  if (filename_len >= NAME_MAX) {
-    assert(false);
+  char filename[PATH_MAX];
+  if (!GetMappingAbsolutePath(mapping, filename))
     return false;
-  }
-  my_memcpy(filename, mapping.name, filename_len);
-  filename[filename_len] = '\0';
   bool filename_modified = HandleDeletedFileInMapping(filename);
 
   MemoryMappedFile mapped_file(filename, mapping.offset);
   if (!mapped_file.data() || mapped_file.size() < SELFMAG)
     return false;
 
   bool success =
       FileID::ElfFileIdentifierFromMappedFile(mapped_file.data(), identifier);
   if (success && member && filename_modified) {
-    mappings_[mapping_id]->name[filename_len -
+    mappings_[mapping_id]->name[my_strlen(mapping.name) -
                                 sizeof(kDeletedSuffix) + 1] = '\0';
   }
 
   return success;
 }
 
+bool LinuxDumper::GetMappingAbsolutePath(const MappingInfo& mapping,
+                                         char path[PATH_MAX]) const {
+  return my_strlcpy(path, root_prefix_, PATH_MAX) < PATH_MAX &&
+         my_strlcat(path, mapping.name, PATH_MAX) < PATH_MAX;
+}
+
 namespace {
 bool ElfFileSoNameFromMappedFile(
     const void* elf_base, char* soname, size_t soname_size) {
   if (!IsValidElf(elf_base)) {
     // Not ELF
     return false;
   }
 
   const void* segment_start;
   size_t segment_size;
@@ skipping 29 matching lines @@
   }
 
   // Did not find SONAME
   return false;
 }
 
 // Find the shared object name (SONAME) by examining the ELF information
 // for |mapping|. If the SONAME is found copy it into the passed buffer
 // |soname| and return true. The size of the buffer is |soname_size|.
 // The SONAME will be truncated if it is too long to fit in the buffer.
-bool ElfFileSoName(
+bool ElfFileSoName(const LinuxDumper& dumper,
     const MappingInfo& mapping, char* soname, size_t soname_size) {
   if (IsMappedFileOpenUnsafe(mapping)) {
     // Not safe
     return false;
   }
 
-  char filename[NAME_MAX];
-  size_t filename_len = my_strlen(mapping.name);
-  if (filename_len >= NAME_MAX) {
-    assert(false);
-    // name too long
+  char filename[PATH_MAX];
+  if (!dumper.GetMappingAbsolutePath(mapping, filename))
     return false;
-  }
-
-  my_memcpy(filename, mapping.name, filename_len);
-  filename[filename_len] = '\0';
 
   MemoryMappedFile mapped_file(filename, mapping.offset);
   if (!mapped_file.data() || mapped_file.size() < SELFMAG) {
     // mmap failed
     return false;
   }
 
   return ElfFileSoNameFromMappedFile(mapped_file.data(), soname, soname_size);
 }
 
 }  // namespace
 
 
-// static
 void LinuxDumper::GetMappingEffectiveNameAndPath(const MappingInfo& mapping,
                                                  char* file_path,
                                                  size_t file_path_size,
                                                  char* file_name,
                                                  size_t file_name_size) {
   my_strlcpy(file_path, mapping.name, file_path_size);
 
   // If an executable is mapped from a non-zero offset, this is likely because
   // the executable was loaded directly from inside an archive file (e.g., an
   // apk on Android). We try to find the name of the shared object (SONAME) by
   // looking in the file for ELF sections.
   bool mapped_from_archive = false;
-  if (mapping.exec && mapping.offset != 0)
-    mapped_from_archive = ElfFileSoName(mapping, file_name, file_name_size);
+  if (mapping.exec && mapping.offset != 0) {
+    mapped_from_archive =
+        ElfFileSoName(*this, mapping, file_name, file_name_size);
+  }
 
   if (mapped_from_archive) {
     // Some tools (e.g., stackwalk) extract the basename from the pathname. In
     // this case, we append the file_name to the mapped archive path as follows:
     //   file_name := libname.so
     //   file_path := /path/to/ARCHIVE.APK/libname.so
     if (my_strlen(file_path) + 1 + my_strlen(file_name) < file_path_size) {
       my_strlcat(file_path, "/", file_path_size);
       my_strlcat(file_path, file_name, file_path_size);
     }
@@ skipping 303 matching lines @@
   const size_t path_len = my_strlen(path);
   if (path_len < kDeletedSuffixLen + 2)
     return false;
   if (my_strncmp(path + path_len - kDeletedSuffixLen, kDeletedSuffix,
                  kDeletedSuffixLen) != 0) {
     return false;
   }
 
   // Check |path| against the /proc/pid/exe 'symlink'.
   char exe_link[NAME_MAX];
-  char new_path[NAME_MAX];
   if (!BuildProcPath(exe_link, pid_, "exe"))
     return false;
-  if (!SafeReadLink(exe_link, new_path))
+  MappingInfo new_mapping = {0};
+  if (!SafeReadLink(exe_link, new_mapping.name))
+    return false;
+  char new_path[PATH_MAX];
+  if (!GetMappingAbsolutePath(new_mapping, new_path))
     return false;
   if (my_strcmp(path, new_path) != 0)
     return false;
 
   // Check to see if someone actually named their executable 'foo (deleted)'.
   struct kernel_stat exe_stat;
   struct kernel_stat new_path_stat;
   if (sys_stat(exe_link, &exe_stat) == 0 &&
       sys_stat(new_path, &new_path_stat) == 0 &&
       exe_stat.st_dev == new_path_stat.st_dev &&
       exe_stat.st_ino == new_path_stat.st_ino) {
     return false;
   }
 
   my_memcpy(path, exe_link, NAME_MAX);
   return true;
 }
 
 }  // namespace google_breakpad