common/recipes-core/psu-update/files/hexfile.py

# The MIT License (MIT)
# =====================
#
# Copyright (c) 2014 Ryan Sturmer
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
# License URL: https://github.com/ryansturmer/hexfile/blob/master/LICENSE.md
# Code URL: https://github.com/ryansturmer/hexfile/blob/master/hexfile/core.py

import itertools

def short(msb,lsb):
    return (msb<<8) | lsb

def long(b1, b2, b3, b4):
    return (b1<<24) | (b2<<16) | (b3<<8) | b4

class HexFile(object):
    def __init__(self, segments, eip, cs, ip):
        self.segments = segments
        self.eip = eip
        self.cs = cs
        self.ip = ip

    def __getitem__(self, val):
        if isinstance(val, slice):
            address = val.start
        else:
            address = val

        for segment in self.segments:
            if address in segment:
                return segment[val]

        raise IndexError('No segment contains address 0x%x' % address)

    def __len__(self):
        return sum(map(len, self.segments))

    @property
    def size(self):
        return len(self)

    def __iter__(self):
        return itertools.chain(*self.segments)

    @staticmethod
    def load(filename):
        segments = []
        eip = None
        cs = None
        ip = None

        with open(filename) as fp:
            lines = fp.readlines()

        extended_linear_address = 0
        extended_segment_address = 0
        current_address = 0
        end_of_file = False

        lineno = 0
        for line in lines:
            lineno += 1
            line = line.strip();
            if not line.startswith(':'):
                continue

            if end_of_file:
                raise Exception("Record found after end of file on line %d" % lineno)

            bytes = [int(line[i:i+2], 16) for i in range(1,len(line), 2)]
            byte_count = bytes[0]
            address = short(*bytes[1:3])
            record_type = bytes[3]
            checksum = bytes[-1]
            data = bytes[4:-1]
            computed_checksum = ((1 << 8)-(sum(bytes[:-1]) & 0xff)) & 0xff

            if(computed_checksum != checksum):
                raise Exception("Record checksum doesn't match on line %d" % lineno)

            if record_type == 0:
                if byte_count == len(data):
                    current_address = (address + extended_linear_address + extended_segment_address) & 0xffffffff
                    have_segment = False
                    for segment in segments:
                        if segment.end_address == current_address:
                            segment.data.extend(data)
                            have_segment = True
                            break
                    if not have_segment:
                        segments.append(Segment(current_address, data))
                else:
                    raise Exception("Data record reported size does not match actual size on line %d" % lineno)
            elif record_type == 1:
                end_of_file = True
            elif record_type == 2:
                if byte_count != 2 or len(data) != 2:
                    raise Exception("Byte count misreported in extended segment address record on line %d" % lineno)
                extended_segment_address = short(*data) << 4
            elif record_type == 3:
                if byte_count != 4 or len(data) != 4:
                    raise Exception("Byte count misreported in start segment address record on line %d" % lineno)
                cs = short(*data[0:2])
                ip = short(*data[2:4])
            elif record_type == 4:
                if byte_count != 2 or len(data) != 2:
                    raise Exception("Byte count misreported in extended linear address record on line %d" % lineno)
                extended_linear_address = short(*data) << 16
            elif record_type == 5:
                if byte_count != 4 or len(data) != 4:
                    raise Exception("Byte count misreported in start linear address record on line %d" % lineno)
                eip = long(*data)
            else:
                raise Exception("Unknown record type: %s" % record_type)
        return HexFile(segments, eip, cs, ip)

    def pretty_string(self, stride=16):
        retval = []
        for segment in self.segments:
            retval.append('Segment @ 0x%08x (%d bytes)' % (segment.start_address, segment.size))
            retval.append(segment.pretty_string(stride=stride))
            retval.append('')
        if self.eip is not None:
            retval.append('EIP 0x%x' % self.eip)
        if self.cs is not None:
            retval.append('CS 0x%x' % self.cs)
        if self.ip is not None:
            retval.append('IP 0x%x' % self.ip)
        return '\n'.join(retval)

def load(filename):
    return HexFile.load(filename)

class Segment(object):
    def __init__(self, start_address, data = None):
        self.start_address = start_address
        self.data = data or []

    def pretty_string(self, stride=16):
        retval = []
        addresses = self.addresses
        ranges = [addresses[i:i+stride] for i in range(0, self.size, stride)]
        for r in ranges:
            retval.append('%08x ' % r[0] + ' '.join(['%02x' % self[addr] for addr in r]))
        return '\n'.join(retval)

    def __str__(self):
        return '<%d byte segment @ 0x%08x>' % (self.size, self.start_address)
    def __repr__(self):
        return str(self)

    @property
    def end_address(self):
        return self.start_address + len(self.data)

    @property
    def size(self):
        return len(self.data)

    def __contains__(self, address):
        return address >= self.start_address and address < self.end_address

    def __getitem__(self, address):
        if isinstance(address, slice):
            if address.start not in self or address.stop-1 not in self:
                raise IndexError('Address out of range for this segment')
            else:
                d = self.data[address.start-self.start_address:address.stop-self.start_address:address.step]
                start_address = address.start + self.start_address
                return Segment(start_address, d)
        else:
            if not address in self:
                raise IndexError("Address 0x%x is not in this segment" % address)
            return self.data[address-self.start_address]

    @property
    def addresses(self):
        return range(self.start_address, self.end_address)

    def __len__(self):
        return len(self.data)

    def __iter__(self):
        return iter(zip(self.addresses,self.data))