The Tor Browser / file revision

 // vim:ts=8:sw=2:et:

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 #include "leaky.h"

 #ifdef USE_BFD

 #include <stdio.h>

 #include <string.h>

 #include <fcntl.h>

 #include <unistd.h>

 #include <libgen.h>

 #include <bfd.h>

 #include <cxxabi.h>

 static bfd *try_debug_file(const char *filename, unsigned long crc32)

 {

   int fd = open(filename, O_RDONLY);

   if (fd < 0)

     return nullptr;

   unsigned char buf[4*1024];

   unsigned long crc = 0;

   while (1) {

     ssize_t count = read(fd, buf, sizeof(buf));

     if (count <= 0)

       break;

     crc = bfd_calc_gnu_debuglink_crc32(crc, buf, count);

   }

   close(fd);

   if (crc != crc32)

     return nullptr;

   bfd *object = bfd_openr(filename, nullptr);

   if (!bfd_check_format(object, bfd_object)) {

     bfd_close(object);

     return nullptr;

   }

   return object;

 }

 static bfd *find_debug_file(bfd *lib, const char *aFileName)

 {

   // check for a separate debug file with symbols

   asection *sect = bfd_get_section_by_name(lib, ".gnu_debuglink");

   if (!sect)

     return nullptr;

   bfd_size_type debuglinkSize = bfd_section_size (objfile->obfd, sect);

   char *debuglink = new char[debuglinkSize];

   bfd_get_section_contents(lib, sect, debuglink, 0, debuglinkSize);

   // crc checksum is aligned to 4 bytes, and after the NUL.

   int crc_offset = (int(strlen(debuglink)) & ~3) + 4;

   unsigned long crc32 = bfd_get_32(lib, debuglink + crc_offset);

   // directory component

   char *dirbuf = strdup(aFileName);

   const char *dir = dirname(dirbuf);

   static const char debug_subdir[] = ".debug";

   // This is gdb's default global debugging info directory, but gdb can

   // be instructed to use a different directory.

   static const char global_debug_dir[] = "/usr/lib/debug";

   char *filename =

     new char[strlen(global_debug_dir) + strlen(dir) + crc_offset + 3];

   // /path/debuglink

   sprintf(filename, "%s/%s", dir, debuglink);

   bfd *debugFile = try_debug_file(filename, crc32);

   if (!debugFile) {

     // /path/.debug/debuglink

     sprintf(filename, "%s/%s/%s", dir, debug_subdir, debuglink);

     debugFile = try_debug_file(filename, crc32);

     if (!debugFile) {

       // /usr/lib/debug/path/debuglink

       sprintf(filename, "%s/%s/%s", global_debug_dir, dir, debuglink);

       debugFile = try_debug_file(filename, crc32);

     }

   }

   delete[] filename;

   free(dirbuf);

   delete[] debuglink;

   return debugFile;

 }

 // Use an indirect array to avoid copying tons of objects

 Symbol ** leaky::ExtendSymbols(int num)

 {

   long n = numExternalSymbols + num;

   externalSymbols = (Symbol**)

                     realloc(externalSymbols,

                             (size_t) (sizeof(externalSymbols[0]) * n));

   Symbol *new_array = new Symbol[n];

   for (int i = 0; i < num; i++) {

     externalSymbols[i + numExternalSymbols] = &new_array[i];

   }

   lastSymbol = externalSymbols + n;

   Symbol **sp = externalSymbols + numExternalSymbols;

   numExternalSymbols = n;

   return sp;

 }

 #define NEXT_SYMBOL do { sp++; \

                          if (sp >= lastSymbol) { \

                            sp = ExtendSymbols(16384); \

                          } \

                        } while (0)

 void leaky::ReadSymbols(const char *aFileName, u_long aBaseAddress)

 {

   int initialSymbols = usefulSymbols;

   if (nullptr == externalSymbols) {

     externalSymbols = (Symbol**) calloc(sizeof(Symbol*),10000);

     Symbol *new_array = new Symbol[10000];

     for (int i = 0; i < 10000; i++) {

       externalSymbols[i] = &new_array[i];

     }

     numExternalSymbols = 10000;

   }

   Symbol** sp = externalSymbols + usefulSymbols;

   lastSymbol = externalSymbols + numExternalSymbols;

   // Create a dummy symbol for the library so, if it doesn't have any

   // symbols, we show it by library.

   (*sp)->Init(aFileName, aBaseAddress);

   NEXT_SYMBOL;

   bfd_boolean kDynamic = (bfd_boolean) false;

   static int firstTime = 1;

   if (firstTime) {

     firstTime = 0;

     bfd_init ();

   }

   bfd* lib = bfd_openr(aFileName, nullptr);

   if (nullptr == lib) {

     return;

   }

   if (!bfd_check_format(lib, bfd_object)) {

     bfd_close(lib);

     return;

   }

   bfd *symbolFile = find_debug_file(lib, aFileName);

   // read mini symbols

   PTR minisyms;

   unsigned int size;

   long symcount = 0;

   if (symbolFile) {

     symcount = bfd_read_minisymbols(symbolFile, kDynamic, &minisyms, &size);

     if (symcount == 0) {

       bfd_close(symbolFile);

     } else {

       bfd_close(lib);

     }

   }

   if (symcount == 0) {

     symcount = bfd_read_minisymbols(lib, kDynamic, &minisyms, &size);

     if (symcount == 0) {

       // symtab is empty; try dynamic symbols

       kDynamic = (bfd_boolean) true;

       symcount = bfd_read_minisymbols(lib, kDynamic, &minisyms, &size);

     }

     symbolFile = lib;

   }

   asymbol* store;

   store = bfd_make_empty_symbol(symbolFile);

   // Scan symbols

   size_t demangle_buffer_size = 128;

   char *demangle_buffer = (char*) malloc(demangle_buffer_size);

   bfd_byte* from = (bfd_byte *) minisyms;

   bfd_byte* fromend = from + symcount * size;

   for (; from < fromend; from += size) {

     asymbol *sym;

     sym = bfd_minisymbol_to_symbol(symbolFile, kDynamic, (const PTR) from, store);

     symbol_info syminfo;

     bfd_get_symbol_info (symbolFile, sym, &syminfo);

 //    if ((syminfo.type == 'T') || (syminfo.type == 't')) {

       const char* nm = bfd_asymbol_name(sym);

       if (nm && nm[0]) {

         char* dnm = nullptr;

         if (strncmp("__thunk", nm, 7)) {

           dnm =

             abi::__cxa_demangle(nm, demangle_buffer, &demangle_buffer_size, 0);

           if (dnm) {

             demangle_buffer = dnm;

           }

         }

         (*sp)->Init(dnm ? dnm : nm, syminfo.value + aBaseAddress);

         NEXT_SYMBOL;

       }

 //    }

   }

   free(demangle_buffer);

   demangle_buffer = nullptr;

   bfd_close(symbolFile);

   int interesting = sp - externalSymbols;

   if (!quiet) {

     printf("%s provided %d symbols\n", aFileName,

            interesting - initialSymbols);

   }

   usefulSymbols = interesting;

 }

 #endif /* USE_BFD */