Beispiel #1
0
 def readBytes(self, address, size):
     buffer = create_string_buffer(size)
     io_desc = ptrace_io_desc(
         piod_op=PIOD_READ_D,
         piod_offs=address,
         piod_addr=addressof(buffer),
         piod_len=size)
     ptrace_io(self.pid, io_desc)
     return buffer.raw
Beispiel #2
0
 def readBytes(self, address, size):
     debug("Read %s bytes at %s" % (size, formatAddress(address)))
     buffer = create_string_buffer(size)
     io_desc = ptrace_io_desc(
         piod_op=PIOD_READ_D,
         piod_offs=address,
         piod_addr=addressof(buffer),
         piod_len=size)
     ptrace_io(self.pid, io_desc)
     return buffer.raw
Beispiel #3
0
 def writeBytes(self, address, bytes):
     size = len(bytes)
     debug("Write %s bytes at %s" % (
         size, formatAddress(address)))
     bytes = create_string_buffer(bytes)
     io_desc = ptrace_io_desc(
         piod_op=PIOD_WRITE_D,
         piod_offs=address,
         piod_addr=addressof(bytes),
         piod_len=size)
     ptrace_io(self.pid, io_desc)
Beispiel #4
0
    def writeBytes(self, address, bytes):
        if HAS_PTRACE_IO:
            size = len(bytes)
            bytes = create_string_buffer(bytes)
            io_desc = ptrace_io_desc(
                piod_op=PIOD_WRITE_D,
                piod_offs=address,
                piod_addr=addressof(bytes),
                piod_len=size)
            ptrace_io(self.pid, io_desc)
        else:
            offset = address % CPU_WORD_SIZE
            if offset:
                # Write partial word (end)
                address -= offset
                size = CPU_WORD_SIZE - offset
                word = self.readBytes(address, CPU_WORD_SIZE)
                if len(bytes) < size:
                    size = len(bytes)
                    word = word[:offset] + bytes[:size] + \
                        word[offset + size:]  # <-- FIXME: Big endian!
                else:
                    # <-- FIXME: Big endian!
                    word = word[:offset] + bytes[:size]
                self.writeWord(address, bytes2word(word))
                bytes = bytes[size:]
                address += CPU_WORD_SIZE

            # Write full words
            while CPU_WORD_SIZE <= len(bytes):
                # Read one word
                word = bytes[:CPU_WORD_SIZE]
                word = bytes2word(word)
                self.writeWord(address, word)

                # Move to next word
                bytes = bytes[CPU_WORD_SIZE:]
                address += CPU_WORD_SIZE
            if not bytes:
                return

            # Write partial word (begin)
            size = len(bytes)
            word = self.readBytes(address, CPU_WORD_SIZE)
            # FIXME: Write big endian version of the next line
            word = bytes + word[size:]
            self.writeWord(address, bytes2word(word))