Revisit the decision to try out super, and decide to stick with specific inheritance to avoid **kwargs everywhere.

volatility/framework/__init__.py

@@ -34,7 +34,7 @@ class Context(interfaces.context.ContextInterface):
     """Maintains the context within which to construct objects"""
 
     def __init__(self, natives):
-        super(Context, self).__init__()
+        interfaces.context.ContextInterface.__init__(self)
         self._symbol_space = symbols.SymbolSpace(natives)
         self._memory = layers.Memory()
 

volatility/framework/interfaces/layers.py

@@ -4,7 +4,7 @@ Created on 4 May 2013
 @author: mike
 '''
 
-from volatility.framework import validity
+from volatility.framework import validity, exceptions
 # We can't just import interfaces because we'd have a cycle going
 from volatility.framework.interfaces import context as context_module
 
@@ -32,7 +32,7 @@ class DataLayerInterface(validity.ValidityRoutines):
         """Returns a boolean based on whether the offset is valid or not"""
 
     def read(self, offset, length, pad = False):
-        """Read takes an offset and a size and returns 'bytes' (not 'str') of length size
+        """Reads an offset for length bytes and returns 'bytes' (not 'str') of length size
         
            If there is a fault of any kind (such as a pagefault), an exception will be thrown
            unless pad is set, in which case the read errors will be replaced by null characters.
@@ -51,7 +51,42 @@ class TranslationLayerInterface(DataLayerInterface):
         """Returns a tuple of (offset, layer) indicating the translation of input domain to the output range"""
 
     def mapping(self, offset, length):
-        """Returns a list of (offset, length, layer) mappings"""
+        """Returns a sorted list of (offset, mapped_offset, length, layer) mappings
+        
+           This allows translation layers to provide maps of contiguous regions in one layer
+        """
 
     def dependencies(self):
         """Returns a list of layer names that this layer translates onto"""
+
+    ### Read/Write functions for mapped pages
+
+    def read(self, offset, length, pad = False):
+        """Reads an offset for length bytes and returns 'bytes' (not 'str') of length size"""
+        current_offset = offset
+        output = b""
+        for (offset, mapped_offset, length, layer) in self.mapping(offset, length):
+            if not pad and offset > current_offset:
+                raise exceptions.InvalidAddressException("Layer " + self.name + " cannot map offset " + current_offset)
+            elif offset > current_offset:
+                output += b"\x00" * (current_offset - offset)
+                current_offset = offset
+            elif offset < current_offset:
+                raise exceptions.LayerException("Mapping returned an overlapping element")
+            output += self._context.memory.read(mapped_offset, length, layer, pad)
+            current_offset += length
+        return output
+
+    def write(self, offset, value):
+        """Writes a value at offset, distributing the writing across any underlying mapping"""
+        current_offset = offset
+        length = len(value)
+        for (offset, mapped_offset, length, layer) in self.mapping(offset, length):
+            if offset > current_offset:
+                raise exceptions.InvalidAddressException("Layer " + self.name + " cannot map offset " + current_offset)
+            elif offset < current_offset:
+                raise exceptions.LayerException("Mapping returned an overlapping element")
+            self._context.memory.write(mapped_offset, length, layer)
+            current_offset += length
+
+

volatility/framework/layers/physical.py

@@ -11,7 +11,7 @@ class BufferDataLayer(interfaces.layers.DataLayerInterface):
     """A DataLayer class backed by a buffer in memory, designed for testing and swift data access"""
 
     def __init__(self, context, name, buffer):
-        super(BufferDataLayer, self).__init__(context, name)
+        interfaces.layers.DataLayerInterface.__init__(self, context, name)
         self._buffer = self.type_check(buffer, bytes)
 
     @property
@@ -41,7 +41,7 @@ class FileLayer(interfaces.layers.DataLayerInterface):
     """a DataLayer backed by a file on the filesystem"""
 
     def __init__(self, context, name, filename):
-        super(FileLayer, self).__init__(context, name)
+        interfaces.layers.DataLayerInterface.__init__(self, context, name)
 
         self._file = open(filename, "r+b")
         self._size = os.path.getsize(filename)
@@ -79,7 +79,10 @@ class FileLayer(interfaces.layers.DataLayerInterface):
         return data
 
     def write(self, offset, data):
-        """Writes to the file"""
+        """Writes to the file
+        
+           This will tehcnically allow writes beyond the extent of the file
+        """
         if not self.is_valid(offset):
             raise exceptions.InvalidAddressException("Offset outside of the " + self.name + " file boundaries")
         self._file.seek(offset)

volatility/framework/objects/__init__.py

@@ -29,12 +29,13 @@ class PrimitiveObject(interfaces.objects.ObjectInterface):
     """PrimitiveObject is an interface for any objects that should simulate a Python primitive"""
 
     def __init__(self, context, layer_name, offset, symbol_name, size = None, parent = None, struct_format = '<I'):
-        super(PrimitiveObject, self).__init__(context = context,
-                                              layer_name = layer_name,
-                                              offset = offset,
-                                              symbol_name = symbol_name,
-                                              size = size,
-                                              parent = parent)
+        interfaces.objects.ObjectInterface.__init__(self,
+                                                    context = context,
+                                                    layer_name = layer_name,
+                                                    offset = offset,
+                                                    symbol_name = symbol_name,
+                                                    size = size,
+                                                    parent = parent)
         self._struct_format = struct_format
 
     @classmethod
@@ -90,13 +91,14 @@ class Pointer(Integer):
     def __init__(self, context, layer_name, offset, symbol_name, size = None, parent = None, struct_format = None, target = None):
         if not isinstance(target, templates.ObjectTemplate):
             raise TypeError("Pointer targets must be an ObjectTemplate")
-        super(Pointer, self).__init__(context,
-                                      layer_name = layer_name,
-                                      offset = offset,
-                                      symbol_name = symbol_name,
-                                      size = size,
-                                      parent = parent,
-                                      struct_format = struct_format)
+        Integer.__init__(self,
+                         context,
+                         layer_name = layer_name,
+                         offset = offset,
+                         symbol_name = symbol_name,
+                         size = size,
+                         parent = parent,
+                         struct_format = struct_format)
         self._target = target
 
     def dereference(self):
@@ -157,12 +159,13 @@ class Array(interfaces.objects.ObjectInterface, collections.Sequence):
     def __init__(self, context, layer_name, offset, symbol_name, size = None, parent = None, count = 0, target = None):
         if not isinstance(target, templates.ObjectTemplate):
             raise TypeError("Array target must be an ObjectTemplate")
-        super(Array, self).__init__(context = context,
-                                    layer_name = layer_name,
-                                    offset = offset,
-                                    symbol_name = symbol_name,
-                                    size = size,
-                                    parent = parent)
+        interfaces.objects.ObjectInterface.__init__(self,
+                                                    context = context,
+                                                    layer_name = layer_name,
+                                                    offset = offset,
+                                                    symbol_name = symbol_name,
+                                                    size = size,
+                                                    parent = parent)
         self._count = count
         self._target = target
 
@@ -199,12 +202,13 @@ class Struct(interfaces.objects.ObjectInterface):
     """Object which can contain members that are other objects"""
 
     def __init__(self, context, layer_name, offset, symbol_name, size = None, members = None, parent = None):
-        super(Struct, self).__init__(context = context,
-                                     layer_name = layer_name,
-                                     offset = offset,
-                                     symbol_name = symbol_name,
-                                     size = size,
-                                     parent = parent)
+        interfaces.objects.ObjectInterface.__init__(self,
+                                                    context = context,
+                                                    layer_name = layer_name,
+                                                    offset = offset,
+                                                    symbol_name = symbol_name,
+                                                    size = size,
+                                                    parent = parent)
         self.check_members(members)
         self._members = members
         self._concrete_members = {}

volatility/framework/objects/templates.py

@@ -16,7 +16,7 @@ class ObjectTemplate(interfaces.objects.Template, validity.ValidityRoutines):
        etc.
     """
     def __init__(self, object_class = None, symbol_name = None, **kwargs):
-        super(ObjectTemplate, self).__init__(symbol_name = symbol_name, **kwargs)
+        interfaces.objects.Template.__init__(self, symbol_name = symbol_name, **kwargs)
         self.object_class = self.class_check(object_class, interfaces.objects.ObjectInterface)
 
     @property

volatility/framework/symbols/native.py

@@ -10,7 +10,7 @@ class NativeTable(interfaces.symbols.NativeTableInterface):
     """Symbol List that handles Native types"""
 
     def __init__(self, name, native_dictionary):
-        super(NativeTable, self).__init__(name, self)
+        interfaces.symbols.NativeTableInterface.__init__(self, name, self)
         self._native_dictionary = copy.deepcopy(native_dictionary)
         self._overrides = {}
         for native_type in self._native_dictionary.keys():

volatility/framework/symbols/vtypes.py

@@ -37,7 +37,7 @@ class VTypeSymbolTable(interfaces.symbols.SymbolTableInterface):
     """Symbol Table that handles vtype datastructures"""
 
     def __init__(self, name, vtype_dictionary, native_symbols = None):
-        super(VTypeSymbolTable, self).__init__(name, native_symbols)
+        interfaces.symbols.SymbolTableInterface.__init__(self, name, native_symbols)
         self._vtypedict = vtype_dictionary
         self._overrides = {}