The Tor Browser / file revision

 // 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

 // copyright notice, this list of conditions and the following disclaimer

 // in the documentation and/or other materials provided with the

 // distribution.

 //     * Neither the name of Google Inc. nor the names of its

 // contributors may be used to endorse or promote products derived from

 // this software without specific prior written permission.

 //

 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 // Author: Alfred Peng

 #include <demangle.h>

 #include <fcntl.h>

 #include <gelf.h>

 #include <link.h>

 #include <sys/mman.h>

 #include <stab.h>

 #include <sys/stat.h>

 #include <sys/types.h>

 #include <unistd.h>

 #include <functional>

 #include <map>

 #include <vector>

 #include "common/scoped_ptr.h"

 #include "common/solaris/dump_symbols.h"

 #include "common/solaris/file_id.h"

 #include "common/solaris/guid_creator.h"

 // This namespace contains helper functions.

 namespace {

 using std::make_pair;

 #if defined(_LP64)

 typedef Elf64_Sym   Elf_Sym;

 #else

 typedef Elf32_Sym   Elf_Sym;

 #endif

 // Symbol table entry from stabs. Sun CC specific.

 struct slist {

   // String table index.

   unsigned int n_strx;

   // Stab type. 

   unsigned char n_type;

   char n_other;

   short n_desc;

   unsigned long n_value;

 };

 // Symbol table entry

 struct SymbolEntry {

   // Offset from the start of the file.

   GElf_Addr offset;

   // Function size.

   GElf_Word size;

 };

 // Infomation of a line.

 struct LineInfo {

   // Offset from start of the function.

   // Load from stab symbol.

   GElf_Off rva_to_func;

   // Offset from base of the loading binary.

   GElf_Off rva_to_base;

   // Size of the line.

   // The first line: equals to rva_to_func.

   // The other lines: the difference of rva_to_func of the line and

   // rva_to_func of the previous N_SLINE.

   uint32_t size;

   // Line number.

   uint32_t line_num;

 };

 // Information of a function.

 struct FuncInfo {

   // Name of the function.

   const char *name;

   // Offset from the base of the loading address.

   GElf_Off rva_to_base;

   // Virtual address of the function.

   // Load from stab symbol.

   GElf_Addr addr;

   // Size of the function.

   // Equal to rva_to_func of the last function line.

   uint32_t size;

   // Total size of stack parameters.

   uint32_t stack_param_size;

   // Line information array.

   std::vector<struct LineInfo> line_info;

 };

 // Information of a source file.

 struct SourceFileInfo {

   // Name of the source file.

   const char *name;

   // Starting address of the source file.

   GElf_Addr addr;

   // Id of the source file.

   int source_id;

   // Functions information.

   std::vector<struct FuncInfo> func_info;

 };

 struct CompareString {

   bool operator()(const char *s1, const char *s2) const {

     return strcmp(s1, s2) < 0;

   }

 };

 typedef std::map<const char *, struct SymbolEntry *, CompareString> SymbolMap;

 // Information of a symbol table.

 // This is the root of all types of symbol.

 struct SymbolInfo {

   std::vector<struct SourceFileInfo> source_file_info;

   // Symbols information.

   SymbolMap symbol_entries;

 };

 // Stab section name.

 const char *kStabName = ".stab";

 // Stab str section name.

 const char *kStabStrName = ".stabstr";

 // Symtab section name.

 const char *kSymtabName = ".symtab";

 // Strtab section name.

 const char *kStrtabName = ".strtab";

 // Default buffer lenght for demangle.

 const int demangleLen = 20000;

 // Offset to the string table.

 uint64_t stringOffset = 0;

 // Update the offset to the start of the string index of the next

 // object module for every N_ENDM stabs.

 inline void RecalculateOffset(struct slist* cur_list, char *stabstr) {

   while ((--cur_list)->n_strx == 0) ;

   stringOffset += cur_list->n_strx;

   char *temp = stabstr + stringOffset;

   while (*temp != '\0') {

     ++stringOffset;

     ++temp;

   }

   // Skip the extra '\0'

   ++stringOffset;

 }

 // Demangle using demangle library on Solaris.

 std::string Demangle(const char *mangled) {

   int status = 0;

   std::string str(mangled);

   char *demangled = (char *)malloc(demangleLen);

   if (!demangled) {

     fprintf(stderr, "no enough memory.\n");

     goto out;

   }

   if ((status = cplus_demangle(mangled, demangled, demangleLen)) ==

       DEMANGLE_ESPACE) {

     fprintf(stderr, "incorrect demangle.\n");

     goto out;

   }

   str = demangled;

   free(demangled);

 out:

   return str; 

 }

 bool WriteFormat(int fd, const char *fmt, ...) {

   va_list list;

   char buffer[4096];

   ssize_t expected, written;

   va_start(list, fmt);

   vsnprintf(buffer, sizeof(buffer), fmt, list);

   expected = strlen(buffer);

   written = write(fd, buffer, strlen(buffer));

   va_end(list);

   return expected == written;

 }

 bool IsValidElf(const GElf_Ehdr *elf_header) {

   return memcmp(elf_header, ELFMAG, SELFMAG) == 0;

 }

 static bool FindSectionByName(Elf *elf, const char *name,

                               int shstrndx,

                               GElf_Shdr *shdr) {

   assert(name != NULL);

   if (strlen(name) == 0)

     return false;

   Elf_Scn *scn = NULL;

   while ((scn = elf_nextscn(elf, scn)) != NULL) {

     if (gelf_getshdr(scn, shdr) == (GElf_Shdr *)0) {

       fprintf(stderr, "failed to read section header: %s\n", elf_errmsg(0));

       return false;

     }

     const char *section_name = elf_strptr(elf, shstrndx, shdr->sh_name);

     if (!section_name) {

       fprintf(stderr, "Section name error: %s\n", elf_errmsg(-1));

       continue;

     }

     if (strcmp(section_name, name) == 0)

       return true;

   }

   return false;

 }

 // The parameter size is used for FPO-optimized code, and

 // this is all tied up with the debugging data for Windows x86.

 // Set it to 0 on Solaris.

 int LoadStackParamSize(struct slist *list,

                        struct slist *list_end,

                        struct FuncInfo *func_info) {

   struct slist *cur_list = list;

   int step = 1;

   while (cur_list < list_end && cur_list->n_type == N_PSYM) {

     ++cur_list;

     ++step;

   }

   func_info->stack_param_size = 0;

   return step;

 }

 int LoadLineInfo(struct slist *list,

                  struct slist *list_end,

                  struct FuncInfo *func_info) {

   struct slist *cur_list = list;

   do {

     // Skip non line information.

     while (cur_list < list_end && cur_list->n_type != N_SLINE) {

       // Only exit when got another function, or source file, or end stab.

       if (cur_list->n_type == N_FUN || cur_list->n_type == N_SO ||

           cur_list->n_type == N_ENDM) {

         return cur_list - list;

       }

       ++cur_list;

     }

     struct LineInfo line;

     while (cur_list < list_end && cur_list->n_type == N_SLINE) {

       line.rva_to_func = cur_list->n_value;

       // n_desc is a signed short

       line.line_num = (unsigned short)cur_list->n_desc;

       func_info->line_info.push_back(line);

       ++cur_list;

     }

     if (cur_list == list_end && cur_list->n_type == N_ENDM)

       break;

   } while (list < list_end);

   return cur_list - list;

 }

 int LoadFuncSymbols(struct slist *list,

                     struct slist *list_end,

                     char *stabstr,

                     GElf_Word base,

                     struct SourceFileInfo *source_file_info) {

   struct slist *cur_list = list;

   assert(cur_list->n_type == N_SO);

   ++cur_list;

   source_file_info->func_info.clear();

   while (cur_list < list_end) {

     // Go until the function symbol.

     while (cur_list < list_end && cur_list->n_type != N_FUN) {

       if (cur_list->n_type == N_SO) {

         return cur_list - list;

       }

       ++cur_list;

       if (cur_list->n_type == N_ENDM)

         RecalculateOffset(cur_list, stabstr);

       continue;

     }

     while (cur_list->n_type == N_FUN) {

       struct FuncInfo func_info;

       memset(&func_info, 0, sizeof(func_info));

       func_info.name = stabstr + cur_list->n_strx + stringOffset;

       // The n_value field is always 0 from stab generated by Sun CC.

       // TODO(Alfred): Find the correct value.

       func_info.addr = cur_list->n_value;

       ++cur_list;

       if (cur_list->n_type == N_ENDM)

         RecalculateOffset(cur_list, stabstr);

       if (cur_list->n_type != N_ESYM && cur_list->n_type != N_ISYM &&

           cur_list->n_type != N_FUN) {

         // Stack parameter size.

         cur_list += LoadStackParamSize(cur_list, list_end, &func_info);

         // Line info.

         cur_list += LoadLineInfo(cur_list, list_end, &func_info);

       }

       if (cur_list < list_end && cur_list->n_type == N_ENDM)

         RecalculateOffset(cur_list, stabstr);

       // Functions in this module should have address bigger than the module

       // starting address.

       //

       // These two values are always 0 with Sun CC.

       // TODO(Alfred): Get the correct value or remove the condition statement.

       if (func_info.addr >= source_file_info->addr) {

         source_file_info->func_info.push_back(func_info);

       }

     }

   }

   return cur_list - list;

 }

 // Compute size and rva information based on symbols loaded from stab section.

 bool ComputeSizeAndRVA(struct SymbolInfo *symbols) {

   std::vector<struct SourceFileInfo> *sorted_files =

     &(symbols->source_file_info);

   SymbolMap *symbol_entries = &(symbols->symbol_entries);

   for (size_t i = 0; i < sorted_files->size(); ++i) {

     struct SourceFileInfo &source_file = (*sorted_files)[i];

     std::vector<struct FuncInfo> *sorted_functions = &(source_file.func_info);

     int func_size = sorted_functions->size();

     for (size_t j = 0; j < func_size; ++j) {

       struct FuncInfo &func_info = (*sorted_functions)[j];

       int line_count = func_info.line_info.size();

       // Discard the ending part of the name.

       std::string func_name(func_info.name);

       std::string::size_type last_colon = func_name.find_first_of(':');

       if (last_colon != std::string::npos)

         func_name = func_name.substr(0, last_colon);

       // Fine the symbol offset from the loading address and size by name.

       SymbolMap::const_iterator it = symbol_entries->find(func_name.c_str());

       if (it->second) {

         func_info.rva_to_base = it->second->offset;

         func_info.size = (line_count == 0) ? 0 : it->second->size;

       } else {

         func_info.rva_to_base = 0;

         func_info.size = 0;

       }

       // Compute function and line size.

       for (size_t k = 0; k < line_count; ++k) {

         struct LineInfo &line_info = func_info.line_info[k];

         line_info.rva_to_base = line_info.rva_to_func + func_info.rva_to_base;

         if (k == line_count - 1) {

           line_info.size = func_info.size - line_info.rva_to_func;

         } else {

           struct LineInfo &next_line = func_info.line_info[k + 1];

           line_info.size = next_line.rva_to_func - line_info.rva_to_func;

         }

       }  // for each line.

     }  // for each function.

   }  // for each source file.

   for (SymbolMap::iterator it = symbol_entries->begin();

        it != symbol_entries->end(); ++it) {

     free(it->second);

   }

   return true;

 }

 bool LoadAllSymbols(const GElf_Shdr *stab_section,

                     const GElf_Shdr *stabstr_section,

                     GElf_Word base,

                     struct SymbolInfo *symbols) {

   if (stab_section == NULL || stabstr_section == NULL)

     return false;

   char *stabstr = 

     reinterpret_cast<char *>(stabstr_section->sh_offset + base);

   struct slist *lists =

     reinterpret_cast<struct slist *>(stab_section->sh_offset + base);

   int nstab = stab_section->sh_size / sizeof(struct slist);

   int source_id = 0;

   // First pass, load all symbols from the object file.

   for (int i = 0; i < nstab; ) {

     int step = 1;

     struct slist *cur_list = lists + i;

     if (cur_list->n_type == N_SO) {

       // FUNC <address> <size> <param_stack_size> <function>

       struct SourceFileInfo source_file_info;

       source_file_info.name = stabstr + cur_list->n_strx + stringOffset;

       // The n_value field is always 0 from stab generated by Sun CC.

       // TODO(Alfred): Find the correct value.

       source_file_info.addr = cur_list->n_value;

       if (strchr(source_file_info.name, '.'))

         source_file_info.source_id = source_id++;

       else

         source_file_info.source_id = -1;

       step = LoadFuncSymbols(cur_list, lists + nstab - 1, stabstr,

                              base, &source_file_info);

       symbols->source_file_info.push_back(source_file_info);

     }

     i += step;

   }

   // Second pass, compute the size of functions and lines.

   return ComputeSizeAndRVA(symbols);

 }

 bool LoadSymbols(Elf *elf, GElf_Ehdr *elf_header, struct SymbolInfo *symbols,

                  void *obj_base) {

   GElf_Word base = reinterpret_cast<GElf_Word>(obj_base);

   const GElf_Shdr *sections =

     reinterpret_cast<GElf_Shdr *>(elf_header->e_shoff + base);

   GElf_Shdr stab_section;

   if (!FindSectionByName(elf, kStabName, elf_header->e_shstrndx,

                          &stab_section)) {

     fprintf(stderr, "Stab section not found.\n");

     return false;

   }

   GElf_Shdr stabstr_section;

   if (!FindSectionByName(elf, kStabStrName, elf_header->e_shstrndx,

                          &stabstr_section)) {

     fprintf(stderr, "Stabstr section not found.\n");

     return false;

   }

   GElf_Shdr symtab_section;

   if (!FindSectionByName(elf, kSymtabName, elf_header->e_shstrndx,

                          &symtab_section)) {

     fprintf(stderr, "Symtab section not found.\n");

     return false;

   }

   GElf_Shdr strtab_section;

   if (!FindSectionByName(elf, kStrtabName, elf_header->e_shstrndx,

                          &strtab_section)) {

     fprintf(stderr, "Strtab section not found.\n");

     return false;

   }

   Elf_Sym *symbol = (Elf_Sym *)((char *)base + symtab_section.sh_offset);

   for (int i = 0; i < symtab_section.sh_size/symtab_section.sh_entsize; ++i) {

     struct SymbolEntry *symbol_entry =

         (struct SymbolEntry *)malloc(sizeof(struct SymbolEntry));

     const char *name = reinterpret_cast<char *>(

         strtab_section.sh_offset + (GElf_Word)base + symbol->st_name);

     symbol_entry->offset = symbol->st_value;

     symbol_entry->size = symbol->st_size;

     symbols->symbol_entries.insert(make_pair(name, symbol_entry));

     ++symbol;

   }

   // Load symbols.

   return LoadAllSymbols(&stab_section, &stabstr_section, base, symbols);

 }

 bool WriteModuleInfo(int fd, GElf_Half arch, const std::string &obj_file) {

   const char *arch_name = NULL;

   if (arch == EM_386)

     arch_name = "x86";

   else if (arch == EM_X86_64)

     arch_name = "x86_64";

   else if (arch == EM_SPARC32PLUS)

     arch_name = "SPARC_32+";

   else {

     printf("Please add more ARCH support\n");

     return false;

   }

   unsigned char identifier[16];

   google_breakpad::FileID file_id(obj_file.c_str());

   if (file_id.ElfFileIdentifier(identifier)) {

     char identifier_str[40];

     file_id.ConvertIdentifierToString(identifier,

                                       identifier_str, sizeof(identifier_str));

     std::string filename = obj_file;

     size_t slash_pos = obj_file.find_last_of("/");

     if (slash_pos != std::string::npos)

       filename = obj_file.substr(slash_pos + 1);

     return WriteFormat(fd, "MODULE solaris %s %s %s\n", arch_name,

                        identifier_str, filename.c_str());

   }

   return false;

 }

 bool WriteSourceFileInfo(int fd, const struct SymbolInfo &symbols) {

   for (size_t i = 0; i < symbols.source_file_info.size(); ++i) {

     if (symbols.source_file_info[i].source_id != -1) {

       const char *name = symbols.source_file_info[i].name;

       if (!WriteFormat(fd, "FILE %d %s\n",

                        symbols.source_file_info[i].source_id, name))

         return false;

     }

   }

   return true;

 }

 bool WriteOneFunction(int fd, int source_id,

                       const struct FuncInfo &func_info){

   // Discard the ending part of the name.

   std::string func_name(func_info.name);

   std::string::size_type last_colon = func_name.find_last_of(':');

   if (last_colon != std::string::npos)

     func_name = func_name.substr(0, last_colon);

   func_name = Demangle(func_name.c_str());

   if (func_info.size <= 0)

     return true;

   // rva_to_base could be unsigned long(32 bit) or unsigned long long(64 bit).

   if (WriteFormat(fd, "FUNC %llx %x %d %s\n",

                   (long long)func_info.rva_to_base,

                   func_info.size,

                   func_info.stack_param_size,

                   func_name.c_str())) {

     for (size_t i = 0; i < func_info.line_info.size(); ++i) {

       const struct LineInfo &line_info = func_info.line_info[i];

       if (line_info.line_num == 0)

         return true;

       if (!WriteFormat(fd, "%llx %x %d %d\n",

                        (long long)line_info.rva_to_base,

                        line_info.size,

                        line_info.line_num,

                        source_id))

         return false;

     }

     return true;

   }

   return false;

 }

 bool WriteFunctionInfo(int fd, const struct SymbolInfo &symbols) {

   for (size_t i = 0; i < symbols.source_file_info.size(); ++i) {

     const struct SourceFileInfo &file_info = symbols.source_file_info[i];

     for (size_t j = 0; j < file_info.func_info.size(); ++j) {

       const struct FuncInfo &func_info = file_info.func_info[j];

       if (!WriteOneFunction(fd, file_info.source_id, func_info))

         return false;

     }

   }

   return true;

 }

 bool DumpStabSymbols(int fd, const struct SymbolInfo &symbols) {

   return WriteSourceFileInfo(fd, symbols) &&

     WriteFunctionInfo(fd, symbols);

 }

 //

 // FDWrapper

 //

 // Wrapper class to make sure opened file is closed.

 //

 class FDWrapper {

  public:

   explicit FDWrapper(int fd) :

     fd_(fd) {

     }

   ~FDWrapper() {

     if (fd_ != -1)

       close(fd_);

   }

   int get() {

     return fd_;

   }

   int release() {

     int fd = fd_;

     fd_ = -1;

     return fd;

   }

  private:

   int fd_;

 };

 //

 // MmapWrapper

 //

 // Wrapper class to make sure mapped regions are unmapped.

 //

 class MmapWrapper {

  public:

   MmapWrapper(void *mapped_address, size_t mapped_size) :

     base_(mapped_address), size_(mapped_size) {

   }

   ~MmapWrapper() {

     if (base_ != NULL) {

       assert(size_ > 0);

       munmap((char *)base_, size_);

     }

   }

   void release() {

     base_ = NULL;

     size_ = 0;

   }

  private:

   void *base_;

   size_t size_;

 };

 }  // namespace

 namespace google_breakpad {

 class AutoElfEnder {

  public:

   AutoElfEnder(Elf *elf) : elf_(elf) {}

   ~AutoElfEnder() { if (elf_) elf_end(elf_); }

  private:

   Elf *elf_;

 };

 bool DumpSymbols::WriteSymbolFile(const std::string &obj_file, int sym_fd) {

   if (elf_version(EV_CURRENT) == EV_NONE) {

     fprintf(stderr, "elf_version() failed: %s\n", elf_errmsg(0));

     return false;

   }

   int obj_fd = open(obj_file.c_str(), O_RDONLY);

   if (obj_fd < 0)

     return false;

   FDWrapper obj_fd_wrapper(obj_fd);

   struct stat st;

   if (fstat(obj_fd, &st) != 0 && st.st_size <= 0)

     return false;

   void *obj_base = mmap(NULL, st.st_size,

                         PROT_READ, MAP_PRIVATE, obj_fd, 0);

   if (obj_base == MAP_FAILED)

     return false;

   MmapWrapper map_wrapper(obj_base, st.st_size);

   GElf_Ehdr elf_header;

   Elf *elf = elf_begin(obj_fd, ELF_C_READ, NULL);

   AutoElfEnder elfEnder(elf);

   if (gelf_getehdr(elf, &elf_header) == (GElf_Ehdr *)NULL) {

     fprintf(stderr, "failed to read elf header: %s\n", elf_errmsg(-1));

     return false;

   }

   if (!IsValidElf(&elf_header)) {

     fprintf(stderr, "header magic doesn't match\n");

     return false;

   }

   struct SymbolInfo symbols;

   if (!LoadSymbols(elf, &elf_header, &symbols, obj_base))

     return false;

   // Write to symbol file.

   if (WriteModuleInfo(sym_fd, elf_header.e_machine, obj_file) &&

       DumpStabSymbols(sym_fd, symbols))

     return true;

   return false;

 }

 }  // namespace google_breakpad