hunktool

#!/usr/bin/env python2.7
#
# hunktool
#
# the swiss-army knife for Amiga Hunk executable file format
#
# written by Christian Vogelgsang (chris@vogelgsang.org)

import sys
import argparse
import pprint
import time

from amitools.FileScanner import FileScanner
from amitools.hunk import Hunk
from amitools.hunk import HunkReader
from amitools.hunk import HunkShow
from amitools.hunk import HunkRelocate
from amitools.elf import ELFReader
from amitools.util.HexDump import *

def print_pretty(data):
  pp = pprint.PrettyPrinter(indent=2)
  pp.pprint(data)

# ----- commands -------------------------------------------------------------

class HunkCommand:
  def __init__(self, args):
    self.counts = {}
    self.args = args
    self.failed_files = []

  def handle_file(self, path, hunk_file, error_code, delta):
    if not self.counts.has_key(error_code):
      self.counts[error_code] = 0
    self.counts[error_code] += 1

    print "%s (%.4fs)" % (path, delta),

    # abort if hunk parser failed!
    if error_code != Hunk.RESULT_OK:
      print Hunk.result_names[error_code], hunk_file.error_string
      if args.dump:
        print_pretty(hunk_file.hunks)
      self.failed_files.append( (path, "READ: " + hunk_file.error_string) )        
      return not self.args.stop

    # if verbose then print block structure
    if args.verbose:
      print
      print "  hunks:    ",hunk_file.get_hunk_summary()
      if args.dump:
        print_pretty(hunk_file.hunks)        
      print "  type:     ",
    
    # build segments from hunks
    ok = hunk_file.build_segments()
    if not ok:
      print "BUILD SEGMENTS FAILED: %s" % (hunk_file.error_string)
      self.failed_files.append( (path, "BUILD: " + hunk_file.error_string) )
      return not self.args.stop
    
    # print recognized file type name
    print Hunk.type_names[hunk_file.type],
    
    # if verbose then print hunk structure
    if args.verbose:
      print 
      print "  segments: ",hunk_file.get_segment_summary()
      print "  overlays: ",hunk_file.get_overlay_segment_summary()
      print "  libs:     ",hunk_file.get_libs_summary()
      print "  units:    ",hunk_file.get_units_summary()
      if args.dump:
        print_pretty(hunk_file.hunks)
    else:
      print

    # do special processing on hunk file for command
    ok = self.handle_hunk_file(path, hunk_file)
    return ok
  
  def result(self):
    for code in self.counts.keys():
      print Hunk.result_names[code],":",self.counts[code]
    for failed in self.failed_files:
      print failed[0],failed[1]
    return 0
      
  def process_file(self, path, fobj, cmd):
    hunk_file = HunkReader.HunkReader()
    start = time.clock()
    result = hunk_file.read_file_obj(path,fobj,None)
    end = time.clock()
    delta = end - start
    # ignore non hunk files
    if result == Hunk.RESULT_NO_HUNK_FILE:
      return True
    return self.handle_file(path, hunk_file, result, delta)
  
  def run(self):
    scanner = FileScanner(lambda path, fobj: self.process_file(path, fobj, cmd), use_adf=args.adf, use_lha=args.lha, stop_on_error=args.stop)
    for path in args.files:
      ok = scanner.handle_path(path)
      if not ok:
        print "ABORTED"
    return cmd.result()

# ----- Validator -----

class Validator(HunkCommand):
  
  def handle_hunk_file(self, path, hunk_file):
    # do nothing extra
    return True

# ----- Info -----

class Info(HunkCommand):

  def handle_hunk_file(self, path, hunk_file):
    # verbose all hunk
    hs = HunkShow.HunkShow(hunk_file, \
      show_relocs=args.show_relocs, show_debug=args.show_debug, \
      disassemble=args.disassemble, disassemble_start=args.disassemble_start, \
      use_objdump=args.use_objdump, cpu=args.cpu, \
      hexdump=args.hexdump, \
      brief=args.brief)
    hs.show_segments()
    return True

# ----- Relocate -----

class Relocate(HunkCommand):
  
  def handle_hunk_file(self, path, hunk_file):
    if hunk_file.type != Hunk.TYPE_LOADSEG:
      print "ERROR: can only relocate LoadSeg()able files:",path;
      return False
    
    rel = HunkRelocate.HunkRelocate(hunk_file,verbose=self.args.verbose)
    # get sizes of all segments
    sizes = rel.get_sizes()
    # calc begin addrs for all segments
    base_addr = self.args.base_address
    addrs = rel.get_seq_addrs(base_addr)
    # relocate and return data of segments
    datas = rel.relocate(addrs)
    if datas == None:
      print "ERROR: relocation failed:",path
      return False
    else:    
      print "Relocate to base address",base_addr
      print "Bases: "," ".join(map(lambda x:"%06x"%(x),addrs))
      print "Sizes: "," ".join(map(lambda x:"%06x"%(x),sizes))
      print "Data:  "," ".join(map(lambda x:"%06x"%(len(x)),datas))
      print "Total: ","%06x"%(rel.get_total_size())
      if args.hexdump:
        for d in datas:
          print_hex(d)
      return True

# ----- Elf2Hunk -----

class ElfInfo:
  def __init__(self,args):
    self.args = args
  
  def run(self):
    for f in args.files:
      elf = ELFReader.ELFReader()
      if not elf.load(f):
        print "ERROR loading ELF:",elf.error_string
        return 1
      elf.dump_elf_segment_headers()
      elf.dump_elf_symbols()
      elf.dump_elf_relas()
      elf.dump_elf_segments(show_relocs=args.show_relocs, show_debug=args.show_debug)
    return 0
  
# ----- main -----
# call scanner and process all files with selected command
cmd_map = {
"validate" : Validator,
"info" : Info,
"elfinfo" : ElfInfo,
"relocate" : Relocate
}

parser = argparse.ArgumentParser()
parser.add_argument('command', help="command: "+",".join(cmd_map.keys()))
parser.add_argument('files', nargs='+')
parser.add_argument('-d', '--dump', action='store_true', default=False, help="dump the hunk structure")
parser.add_argument('-v', '--verbose', action='store_true', default=False, help="be more verbos")
parser.add_argument('-a', '--adf', nargs='?', default='unadf', help="enable adf scanner (requires unadf tool)")
parser.add_argument('-l', '--lha', nargs='?', default='lha', help="enable lha scanner (with given lha executable)")
parser.add_argument('-s', '--stop', action='store_true', default=False, help="stop on error")
parser.add_argument('-R', '--show-relocs', action='store_true', default=False, help="show relocation entries")
parser.add_argument('-D', '--show-debug', action='store_true', default=False, help="show debug info entries")
parser.add_argument('-A', '--disassemble', action='store_true', default=False, help="disassemble code segments")
parser.add_argument('-S', '--disassemble-start', action='store', type=int, default=0, help="start address for dissassembly")
parser.add_argument('-x', '--hexdump', action='store_true', default=False, help="dump segments in hex")
parser.add_argument('-b', '--brief', action='store_true', default=False, help="show only brief information")
parser.add_argument('-B', '--base-address', action='store', type=int, default=0, help="base address for relocation")
parser.add_argument('-o', '--use-objdump', action='store_true', default=False, help="disassemble with m68k-elf-objdump instead of vda68k")
parser.add_argument('-c', '--cpu', action='store', default='68000', help="disassemble for given cpu (objdump only)")
args = parser.parse_args()

cmd = args.command
if not cmd_map.has_key(cmd):
  print "INVALID COMMAND:",cmd
  print "valid commands are:"
  for a in cmd_map:
    print "  ",a
  sys.exit(1)
cmd_cls = cmd_map[cmd]

# execute command
cmd = cmd_cls(args)
res = cmd.run()
sys.exit(res)