| #!/usr/bin/python |
| |
| import optparse |
| import os |
| import shlex |
| import struct |
| import sys |
| |
| ARMAG = "!<arch>\n" |
| SARMAG = 8 |
| ARFMAG = "`\n" |
| AR_EFMT1 = "#1/" |
| |
| |
| def memdump(src, bytes_per_line=16, address=0): |
| FILTER = ''.join([(len(repr(chr(x))) == 3) and chr(x) or '.' |
| for x in range(256)]) |
| for i in range(0, len(src), bytes_per_line): |
| s = src[i:i+bytes_per_line] |
| hex_bytes = ' '.join(["%02x" % (ord(x)) for x in s]) |
| ascii = s.translate(FILTER) |
| print("%#08.8x: %-*s %s" % (address+i, bytes_per_line*3, hex_bytes, |
| ascii)) |
| |
| |
| class Object(object): |
| def __init__(self, file): |
| def read_str(file, str_len): |
| return file.read(str_len).rstrip('\0 ') |
| |
| def read_int(file, str_len, base): |
| return int(read_str(file, str_len), base) |
| |
| self.offset = file.tell() |
| self.file = file |
| self.name = read_str(file, 16) |
| self.date = read_int(file, 12, 10) |
| self.uid = read_int(file, 6, 10) |
| self.gid = read_int(file, 6, 10) |
| self.mode = read_int(file, 8, 8) |
| self.size = read_int(file, 10, 10) |
| if file.read(2) != ARFMAG: |
| raise ValueError('invalid BSD object at offset %#08.8x' % ( |
| self.offset)) |
| # If we have an extended name read it. Extended names start with |
| name_len = 0 |
| if self.name.startswith(AR_EFMT1): |
| name_len = int(self.name[len(AR_EFMT1):], 10) |
| self.name = read_str(file, name_len) |
| self.obj_offset = file.tell() |
| self.obj_size = self.size - name_len |
| file.seek(self.obj_size, 1) |
| |
| def dump(self, f=sys.stdout, flat=True): |
| if flat: |
| f.write('%#08.8x: %#08.8x %5u %5u %6o %#08.8x %s\n' % (self.offset, |
| self.date, self.uid, self.gid, self.mode, self.size, |
| self.name)) |
| else: |
| f.write('%#08.8x: \n' % self.offset) |
| f.write(' name = "%s"\n' % self.name) |
| f.write(' date = %#08.8x\n' % self.date) |
| f.write(' uid = %i\n' % self.uid) |
| f.write(' gid = %i\n' % self.gid) |
| f.write(' mode = %o\n' % self.mode) |
| f.write(' size = %#08.8x\n' % (self.size)) |
| self.file.seek(self.obj_offset, 0) |
| first_bytes = self.file.read(4) |
| f.write('bytes = ') |
| memdump(first_bytes) |
| |
| def get_bytes(self): |
| saved_pos = self.file.tell() |
| self.file.seek(self.obj_offset, 0) |
| bytes = self.file.read(self.obj_size) |
| self.file.seek(saved_pos, 0) |
| return bytes |
| |
| |
| class StringTable(object): |
| def __init__(self, bytes): |
| self.bytes = bytes |
| |
| def get_string(self, offset): |
| length = len(self.bytes) |
| if offset >= length: |
| return None |
| return self.bytes[offset:self.bytes.find('\0', offset)] |
| |
| |
| class Archive(object): |
| def __init__(self, path): |
| self.path = path |
| self.file = open(path, 'r') |
| self.objects = [] |
| self.offset_to_object = {} |
| if self.file.read(SARMAG) != ARMAG: |
| print("error: file isn't a BSD archive") |
| while True: |
| try: |
| self.objects.append(Object(self.file)) |
| except ValueError: |
| break |
| |
| def get_object_at_offset(self, offset): |
| if offset in self.offset_to_object: |
| return self.offset_to_object[offset] |
| for obj in self.objects: |
| if obj.offset == offset: |
| self.offset_to_object[offset] = obj |
| return obj |
| return None |
| |
| def find(self, name, mtime=None, f=sys.stdout): |
| ''' |
| Find an object(s) by name with optional modification time. There |
| can be multple objects with the same name inside and possibly with |
| the same modification time within a BSD archive so clients must be |
| prepared to get multiple results. |
| ''' |
| matches = [] |
| for obj in self.objects: |
| if obj.name == name and (mtime is None or mtime == obj.date): |
| matches.append(obj) |
| return matches |
| |
| @classmethod |
| def dump_header(self, f=sys.stdout): |
| f.write(' DATE UID GID MODE SIZE NAME\n') |
| f.write(' ---------- ----- ----- ------ ---------- ' |
| '--------------\n') |
| |
| def get_symdef(self): |
| def get_uint32(file): |
| '''Extract a uint32_t from the current file position.''' |
| v, = struct.unpack('=I', file.read(4)) |
| return v |
| |
| for obj in self.objects: |
| symdef = [] |
| if obj.name.startswith("__.SYMDEF"): |
| self.file.seek(obj.obj_offset, 0) |
| ranlib_byte_size = get_uint32(self.file) |
| num_ranlib_structs = ranlib_byte_size/8 |
| str_offset_pairs = [] |
| for _ in range(num_ranlib_structs): |
| strx = get_uint32(self.file) |
| offset = get_uint32(self.file) |
| str_offset_pairs.append((strx, offset)) |
| strtab_len = get_uint32(self.file) |
| strtab = StringTable(self.file.read(strtab_len)) |
| for s in str_offset_pairs: |
| symdef.append((strtab.get_string(s[0]), s[1])) |
| return symdef |
| |
| def get_object_dicts(self): |
| ''' |
| Returns an array of object dictionaries that contain they following |
| keys: |
| 'object': the actual bsd.Object instance |
| 'symdefs': an array of symbol names that the object contains |
| as found in the "__.SYMDEF" item in the archive |
| ''' |
| symdefs = self.get_symdef() |
| symdef_dict = {} |
| if symdefs: |
| for (name, offset) in symdefs: |
| if offset in symdef_dict: |
| object_dict = symdef_dict[offset] |
| else: |
| object_dict = { |
| 'object': self.get_object_at_offset(offset), |
| 'symdefs': [] |
| } |
| symdef_dict[offset] = object_dict |
| object_dict['symdefs'].append(name) |
| object_dicts = [] |
| for offset in sorted(symdef_dict): |
| object_dicts.append(symdef_dict[offset]) |
| return object_dicts |
| |
| def dump(self, f=sys.stdout, flat=True): |
| f.write('%s:\n' % self.path) |
| if flat: |
| self.dump_header(f=f) |
| for obj in self.objects: |
| obj.dump(f=f, flat=flat) |
| |
| |
| def main(): |
| parser = optparse.OptionParser( |
| prog='bsd', |
| description='Utility for BSD archives') |
| parser.add_option( |
| '--object', |
| type='string', |
| dest='object_name', |
| default=None, |
| help=('Specify the name of a object within the BSD archive to get ' |
| 'information on')) |
| parser.add_option( |
| '-s', '--symbol', |
| type='string', |
| dest='find_symbol', |
| default=None, |
| help=('Specify the name of a symbol within the BSD archive to get ' |
| 'information on from SYMDEF')) |
| parser.add_option( |
| '--symdef', |
| action='store_true', |
| dest='symdef', |
| default=False, |
| help=('Dump the information in the SYMDEF.')) |
| parser.add_option( |
| '-v', '--verbose', |
| action='store_true', |
| dest='verbose', |
| default=False, |
| help='Enable verbose output') |
| parser.add_option( |
| '-e', '--extract', |
| action='store_true', |
| dest='extract', |
| default=False, |
| help=('Specify this to extract the object specified with the --object ' |
| 'option. There must be only one object with a matching name or ' |
| 'the --mtime option must be specified to uniquely identify a ' |
| 'single object.')) |
| parser.add_option( |
| '-m', '--mtime', |
| type='int', |
| dest='mtime', |
| default=None, |
| help=('Specify the modification time of the object an object. This ' |
| 'option is used with either the --object or --extract options.')) |
| parser.add_option( |
| '-o', '--outfile', |
| type='string', |
| dest='outfile', |
| default=None, |
| help=('Specify a different name or path for the file to extract when ' |
| 'using the --extract option. If this option isn\'t specified, ' |
| 'then the extracted object file will be extracted into the ' |
| 'current working directory if a file doesn\'t already exist ' |
| 'with that name.')) |
| |
| (options, args) = parser.parse_args(sys.argv[1:]) |
| |
| for path in args: |
| archive = Archive(path) |
| if options.object_name: |
| print('%s:\n' % (path)) |
| matches = archive.find(options.object_name, options.mtime) |
| if matches: |
| dump_all = True |
| if options.extract: |
| if len(matches) == 1: |
| dump_all = False |
| if options.outfile is None: |
| outfile_path = matches[0].name |
| else: |
| outfile_path = options.outfile |
| if os.path.exists(outfile_path): |
| print('error: outfile "%s" already exists' % ( |
| outfile_path)) |
| else: |
| print('Saving file to "%s"...' % (outfile_path)) |
| with open(outfile_path, 'w') as outfile: |
| outfile.write(matches[0].get_bytes()) |
| else: |
| print('error: multiple objects match "%s". Specify ' |
| 'the modification time using --mtime.' % ( |
| options.object_name)) |
| if dump_all: |
| for obj in matches: |
| obj.dump(flat=False) |
| else: |
| print('error: object "%s" not found in archive' % ( |
| options.object_name)) |
| elif options.find_symbol: |
| symdefs = archive.get_symdef() |
| if symdefs: |
| success = False |
| for (name, offset) in symdefs: |
| obj = archive.get_object_at_offset(offset) |
| if name == options.find_symbol: |
| print('Found "%s" in:' % (options.find_symbol)) |
| obj.dump(flat=False) |
| success = True |
| if not success: |
| print('Didn\'t find "%s" in any objects' % ( |
| options.find_symbol)) |
| else: |
| print("error: no __.SYMDEF was found") |
| elif options.symdef: |
| object_dicts = archive.get_object_dicts() |
| for object_dict in object_dicts: |
| object_dict['object'].dump(flat=False) |
| print("symbols:") |
| for name in object_dict['symdefs']: |
| print(" %s" % (name)) |
| else: |
| archive.dump(flat=not options.verbose) |
| |
| |
| if __name__ == '__main__': |
| main() |
| |
| |
| def print_mtime_error(result, dmap_mtime, actual_mtime): |
| print >>result, ("error: modification time in debug map (%#08.8x) doesn't " |
| "match the .o file modification time (%#08.8x)" % ( |
| dmap_mtime, actual_mtime)) |
| |
| |
| def print_file_missing_error(result, path): |
| print >>result, "error: file \"%s\" doesn't exist" % (path) |
| |
| |
| def print_multiple_object_matches(result, object_name, mtime, matches): |
| print >>result, ("error: multiple matches for object '%s' with with " |
| "modification time %#08.8x:" % (object_name, mtime)) |
| Archive.dump_header(f=result) |
| for match in matches: |
| match.dump(f=result, flat=True) |
| |
| |
| def print_archive_object_error(result, object_name, mtime, archive): |
| matches = archive.find(object_name, f=result) |
| if len(matches) > 0: |
| print >>result, ("error: no objects have a modification time that " |
| "matches %#08.8x for '%s'. Potential matches:" % ( |
| mtime, object_name)) |
| Archive.dump_header(f=result) |
| for match in matches: |
| match.dump(f=result, flat=True) |
| else: |
| print >>result, "error: no object named \"%s\" found in archive:" % ( |
| object_name) |
| Archive.dump_header(f=result) |
| for match in archive.objects: |
| match.dump(f=result, flat=True) |
| # archive.dump(f=result, flat=True) |
| |
| |
| class VerifyDebugMapCommand: |
| name = "verify-debug-map-objects" |
| |
| def create_options(self): |
| usage = "usage: %prog [options]" |
| description = '''This command reports any .o files that are missing |
| or whose modification times don't match in the debug map of an executable.''' |
| |
| self.parser = optparse.OptionParser( |
| description=description, |
| prog=self.name, |
| usage=usage, |
| add_help_option=False) |
| |
| self.parser.add_option( |
| '-e', '--errors', |
| action='store_true', |
| dest='errors', |
| default=False, |
| help="Only show errors") |
| |
| def get_short_help(self): |
| return "Verify debug map object files." |
| |
| def get_long_help(self): |
| return self.help_string |
| |
| def __init__(self, debugger, unused): |
| self.create_options() |
| self.help_string = self.parser.format_help() |
| |
| def __call__(self, debugger, command, exe_ctx, result): |
| import lldb |
| # Use the Shell Lexer to properly parse up command options just like a |
| # shell would |
| command_args = shlex.split(command) |
| |
| try: |
| (options, args) = self.parser.parse_args(command_args) |
| except: |
| result.SetError("option parsing failed") |
| return |
| |
| # Always get program state from the SBExecutionContext passed in |
| target = exe_ctx.GetTarget() |
| if not target.IsValid(): |
| result.SetError("invalid target") |
| return |
| archives = {} |
| for module_spec in args: |
| module = target.module[module_spec] |
| if not (module and module.IsValid()): |
| result.SetError('error: invalid module specification: "%s". ' |
| 'Specify the full path, basename, or UUID of ' |
| 'a module ' % (module_spec)) |
| return |
| num_symbols = module.GetNumSymbols() |
| num_errors = 0 |
| for i in range(num_symbols): |
| symbol = module.GetSymbolAtIndex(i) |
| if symbol.GetType() != lldb.eSymbolTypeObjectFile: |
| continue |
| path = symbol.GetName() |
| if not path: |
| continue |
| # Extract the value of the symbol by dumping the |
| # symbol. The value is the mod time. |
| dmap_mtime = int(str(symbol).split('value = ') |
| [1].split(',')[0], 16) |
| if not options.errors: |
| print >>result, '%s' % (path) |
| if os.path.exists(path): |
| actual_mtime = int(os.stat(path).st_mtime) |
| if dmap_mtime != actual_mtime: |
| num_errors += 1 |
| if options.errors: |
| print >>result, '%s' % (path), |
| print_mtime_error(result, dmap_mtime, |
| actual_mtime) |
| elif path[-1] == ')': |
| (archive_path, object_name) = path[0:-1].split('(') |
| if not archive_path and not object_name: |
| num_errors += 1 |
| if options.errors: |
| print >>result, '%s' % (path), |
| print_file_missing_error(path) |
| continue |
| if not os.path.exists(archive_path): |
| num_errors += 1 |
| if options.errors: |
| print >>result, '%s' % (path), |
| print_file_missing_error(archive_path) |
| continue |
| if archive_path in archives: |
| archive = archives[archive_path] |
| else: |
| archive = Archive(archive_path) |
| archives[archive_path] = archive |
| matches = archive.find(object_name, dmap_mtime) |
| num_matches = len(matches) |
| if num_matches == 1: |
| print >>result, '1 match' |
| obj = matches[0] |
| if obj.date != dmap_mtime: |
| num_errors += 1 |
| if options.errors: |
| print >>result, '%s' % (path), |
| print_mtime_error(result, dmap_mtime, obj.date) |
| elif num_matches == 0: |
| num_errors += 1 |
| if options.errors: |
| print >>result, '%s' % (path), |
| print_archive_object_error(result, object_name, |
| dmap_mtime, archive) |
| elif num_matches > 1: |
| num_errors += 1 |
| if options.errors: |
| print >>result, '%s' % (path), |
| print_multiple_object_matches(result, |
| object_name, |
| dmap_mtime, matches) |
| if num_errors > 0: |
| print >>result, "%u errors found" % (num_errors) |
| else: |
| print >>result, "No errors detected in debug map" |
| |
| |
| def __lldb_init_module(debugger, dict): |
| # This initializer is being run from LLDB in the embedded command |
| # interpreter. |
| # Add any commands contained in this module to LLDB |
| debugger.HandleCommand( |
| 'command script add -c %s.VerifyDebugMapCommand %s' % ( |
| __name__, VerifyDebugMapCommand.name)) |
| print('The "%s" command has been installed, type "help %s" for detailed ' |
| 'help.' % (VerifyDebugMapCommand.name, VerifyDebugMapCommand.name)) |
