kaitai: adjustments and rearrangements for python2/3 compat

1 files changed, 535 insertions, 0 deletions

diff --git a/python/examples/kaitai/iso9660.py b/python/examples/kaitai/iso9660.py
new file mode 100644
index 00000000..dd8071a8
--- /dev/null
+++ b/python/examples/kaitai/iso9660.py
@@ -0,0 +1,535 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+from .kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
+import collections
+
+
+if parse_version(ks_version) < parse_version('0.7'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
+
+class Iso9660(KaitaiStruct):
+    """ISO9660 is standard filesystem used on read-only optical discs
+    (mostly CD-ROM). The standard was based on earlier High Sierra
+    Format (HSF), proposed for CD-ROMs in 1985, and, after several
+    revisions, it was accepted as ISO9960:1998.
+    
+    The format emphasizes portability (thus having pretty minimal
+    features and very conservative file names standards) and sequential
+    access (which favors disc devices with relatively slow rotation
+    speed).
+    """
+    SEQ_FIELDS = []
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        pass
+
+    class VolDescPrimary(KaitaiStruct):
+        """
+        .. seealso::
+           Source - http://wiki.osdev.org/ISO_9660#The_Primary_Volume_Descriptor
+        """
+        SEQ_FIELDS = ["unused1", "system_id", "volume_id", "unused2", "vol_space_size", "unused3", "vol_set_size", "vol_seq_num", "logical_block_size", "path_table_size", "lba_path_table_le", "lba_opt_path_table_le", "lba_path_table_be", "lba_opt_path_table_be", "root_dir", "vol_set_id", "publisher_id", "data_preparer_id", "application_id", "copyright_file_id", "abstract_file_id", "bibliographic_file_id", "vol_create_datetime", "vol_mod_datetime", "vol_expire_datetime", "vol_effective_datetime", "file_structure_version", "unused4", "application_area"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['unused1']['start'] = self._io.pos()
+            self.unused1 = self._io.ensure_fixed_contents(b"\x00")
+            self._debug['unused1']['end'] = self._io.pos()
+            self._debug['system_id']['start'] = self._io.pos()
+            self.system_id = (self._io.read_bytes(32)).decode(u"UTF-8")
+            self._debug['system_id']['end'] = self._io.pos()
+            self._debug['volume_id']['start'] = self._io.pos()
+            self.volume_id = (self._io.read_bytes(32)).decode(u"UTF-8")
+            self._debug['volume_id']['end'] = self._io.pos()
+            self._debug['unused2']['start'] = self._io.pos()
+            self.unused2 = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00\x00\x00\x00\x00")
+            self._debug['unused2']['end'] = self._io.pos()
+            self._debug['vol_space_size']['start'] = self._io.pos()
+            self.vol_space_size = self._root.U4bi(self._io, self, self._root)
+            self.vol_space_size._read()
+            self._debug['vol_space_size']['end'] = self._io.pos()
+            self._debug['unused3']['start'] = self._io.pos()
+            self.unused3 = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
+            self._debug['unused3']['end'] = self._io.pos()
+            self._debug['vol_set_size']['start'] = self._io.pos()
+            self.vol_set_size = self._root.U2bi(self._io, self, self._root)
+            self.vol_set_size._read()
+            self._debug['vol_set_size']['end'] = self._io.pos()
+            self._debug['vol_seq_num']['start'] = self._io.pos()
+            self.vol_seq_num = self._root.U2bi(self._io, self, self._root)
+            self.vol_seq_num._read()
+            self._debug['vol_seq_num']['end'] = self._io.pos()
+            self._debug['logical_block_size']['start'] = self._io.pos()
+            self.logical_block_size = self._root.U2bi(self._io, self, self._root)
+            self.logical_block_size._read()
+            self._debug['logical_block_size']['end'] = self._io.pos()
+            self._debug['path_table_size']['start'] = self._io.pos()
+            self.path_table_size = self._root.U4bi(self._io, self, self._root)
+            self.path_table_size._read()
+            self._debug['path_table_size']['end'] = self._io.pos()
+            self._debug['lba_path_table_le']['start'] = self._io.pos()
+            self.lba_path_table_le = self._io.read_u4le()
+            self._debug['lba_path_table_le']['end'] = self._io.pos()
+            self._debug['lba_opt_path_table_le']['start'] = self._io.pos()
+            self.lba_opt_path_table_le = self._io.read_u4le()
+            self._debug['lba_opt_path_table_le']['end'] = self._io.pos()
+            self._debug['lba_path_table_be']['start'] = self._io.pos()
+            self.lba_path_table_be = self._io.read_u4be()
+            self._debug['lba_path_table_be']['end'] = self._io.pos()
+            self._debug['lba_opt_path_table_be']['start'] = self._io.pos()
+            self.lba_opt_path_table_be = self._io.read_u4be()
+            self._debug['lba_opt_path_table_be']['end'] = self._io.pos()
+            self._debug['root_dir']['start'] = self._io.pos()
+            self._raw_root_dir = self._io.read_bytes(34)
+            io = KaitaiStream(BytesIO(self._raw_root_dir))
+            self.root_dir = self._root.DirEntry(io, self, self._root)
+            self.root_dir._read()
+            self._debug['root_dir']['end'] = self._io.pos()
+            self._debug['vol_set_id']['start'] = self._io.pos()
+            self.vol_set_id = (self._io.read_bytes(128)).decode(u"UTF-8")
+            self._debug['vol_set_id']['end'] = self._io.pos()
+            self._debug['publisher_id']['start'] = self._io.pos()
+            self.publisher_id = (self._io.read_bytes(128)).decode(u"UTF-8")
+            self._debug['publisher_id']['end'] = self._io.pos()
+            self._debug['data_preparer_id']['start'] = self._io.pos()
+            self.data_preparer_id = (self._io.read_bytes(128)).decode(u"UTF-8")
+            self._debug['data_preparer_id']['end'] = self._io.pos()
+            self._debug['application_id']['start'] = self._io.pos()
+            self.application_id = (self._io.read_bytes(128)).decode(u"UTF-8")
+            self._debug['application_id']['end'] = self._io.pos()
+            self._debug['copyright_file_id']['start'] = self._io.pos()
+            self.copyright_file_id = (self._io.read_bytes(38)).decode(u"UTF-8")
+            self._debug['copyright_file_id']['end'] = self._io.pos()
+            self._debug['abstract_file_id']['start'] = self._io.pos()
+            self.abstract_file_id = (self._io.read_bytes(36)).decode(u"UTF-8")
+            self._debug['abstract_file_id']['end'] = self._io.pos()
+            self._debug['bibliographic_file_id']['start'] = self._io.pos()
+            self.bibliographic_file_id = (self._io.read_bytes(37)).decode(u"UTF-8")
+            self._debug['bibliographic_file_id']['end'] = self._io.pos()
+            self._debug['vol_create_datetime']['start'] = self._io.pos()
+            self.vol_create_datetime = self._root.DecDatetime(self._io, self, self._root)
+            self.vol_create_datetime._read()
+            self._debug['vol_create_datetime']['end'] = self._io.pos()
+            self._debug['vol_mod_datetime']['start'] = self._io.pos()
+            self.vol_mod_datetime = self._root.DecDatetime(self._io, self, self._root)
+            self.vol_mod_datetime._read()
+            self._debug['vol_mod_datetime']['end'] = self._io.pos()
+            self._debug['vol_expire_datetime']['start'] = self._io.pos()
+            self.vol_expire_datetime = self._root.DecDatetime(self._io, self, self._root)
+            self.vol_expire_datetime._read()
+            self._debug['vol_expire_datetime']['end'] = self._io.pos()
+            self._debug['vol_effective_datetime']['start'] = self._io.pos()
+            self.vol_effective_datetime = self._root.DecDatetime(self._io, self, self._root)
+            self.vol_effective_datetime._read()
+            self._debug['vol_effective_datetime']['end'] = self._io.pos()
+            self._debug['file_structure_version']['start'] = self._io.pos()
+            self.file_structure_version = self._io.read_u1()
+            self._debug['file_structure_version']['end'] = self._io.pos()
+            self._debug['unused4']['start'] = self._io.pos()
+            self.unused4 = self._io.read_u1()
+            self._debug['unused4']['end'] = self._io.pos()
+            self._debug['application_area']['start'] = self._io.pos()
+            self.application_area = self._io.read_bytes(512)
+            self._debug['application_area']['end'] = self._io.pos()
+
+        @property
+        def path_table(self):
+            if hasattr(self, '_m_path_table'):
+                return self._m_path_table if hasattr(self, '_m_path_table') else None
+
+            _pos = self._io.pos()
+            self._io.seek((self.lba_path_table_le * self._root.sector_size))
+            self._debug['_m_path_table']['start'] = self._io.pos()
+            self._raw__m_path_table = self._io.read_bytes(self.path_table_size.le)
+            io = KaitaiStream(BytesIO(self._raw__m_path_table))
+            self._m_path_table = self._root.PathTableLe(io, self, self._root)
+            self._m_path_table._read()
+            self._debug['_m_path_table']['end'] = self._io.pos()
+            self._io.seek(_pos)
+            return self._m_path_table if hasattr(self, '_m_path_table') else None
+
+
+    class VolDescBootRecord(KaitaiStruct):
+        SEQ_FIELDS = ["boot_system_id", "boot_id"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['boot_system_id']['start'] = self._io.pos()
+            self.boot_system_id = (self._io.read_bytes(32)).decode(u"UTF-8")
+            self._debug['boot_system_id']['end'] = self._io.pos()
+            self._debug['boot_id']['start'] = self._io.pos()
+            self.boot_id = (self._io.read_bytes(32)).decode(u"UTF-8")
+            self._debug['boot_id']['end'] = self._io.pos()
+
+
+    class Datetime(KaitaiStruct):
+        SEQ_FIELDS = ["year", "month", "day", "hour", "minute", "sec", "timezone"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['year']['start'] = self._io.pos()
+            self.year = self._io.read_u1()
+            self._debug['year']['end'] = self._io.pos()
+            self._debug['month']['start'] = self._io.pos()
+            self.month = self._io.read_u1()
+            self._debug['month']['end'] = self._io.pos()
+            self._debug['day']['start'] = self._io.pos()
+            self.day = self._io.read_u1()
+            self._debug['day']['end'] = self._io.pos()
+            self._debug['hour']['start'] = self._io.pos()
+            self.hour = self._io.read_u1()
+            self._debug['hour']['end'] = self._io.pos()
+            self._debug['minute']['start'] = self._io.pos()
+            self.minute = self._io.read_u1()
+            self._debug['minute']['end'] = self._io.pos()
+            self._debug['sec']['start'] = self._io.pos()
+            self.sec = self._io.read_u1()
+            self._debug['sec']['end'] = self._io.pos()
+            self._debug['timezone']['start'] = self._io.pos()
+            self.timezone = self._io.read_u1()
+            self._debug['timezone']['end'] = self._io.pos()
+
+
+    class DirEntry(KaitaiStruct):
+        SEQ_FIELDS = ["len", "body"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['len']['start'] = self._io.pos()
+            self.len = self._io.read_u1()
+            self._debug['len']['end'] = self._io.pos()
+            if self.len > 0:
+                self._debug['body']['start'] = self._io.pos()
+                self._raw_body = self._io.read_bytes((self.len - 1))
+                io = KaitaiStream(BytesIO(self._raw_body))
+                self.body = self._root.DirEntryBody(io, self, self._root)
+                self.body._read()
+                self._debug['body']['end'] = self._io.pos()
+
+
+
+    class VolDesc(KaitaiStruct):
+        SEQ_FIELDS = ["type", "magic", "version", "vol_desc_boot_record", "vol_desc_primary"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['type']['start'] = self._io.pos()
+            self.type = self._io.read_u1()
+            self._debug['type']['end'] = self._io.pos()
+            self._debug['magic']['start'] = self._io.pos()
+            self.magic = self._io.ensure_fixed_contents(b"\x43\x44\x30\x30\x31")
+            self._debug['magic']['end'] = self._io.pos()
+            self._debug['version']['start'] = self._io.pos()
+            self.version = self._io.read_u1()
+            self._debug['version']['end'] = self._io.pos()
+            if self.type == 0:
+                self._debug['vol_desc_boot_record']['start'] = self._io.pos()
+                self.vol_desc_boot_record = self._root.VolDescBootRecord(self._io, self, self._root)
+                self.vol_desc_boot_record._read()
+                self._debug['vol_desc_boot_record']['end'] = self._io.pos()
+
+            if self.type == 1:
+                self._debug['vol_desc_primary']['start'] = self._io.pos()
+                self.vol_desc_primary = self._root.VolDescPrimary(self._io, self, self._root)
+                self.vol_desc_primary._read()
+                self._debug['vol_desc_primary']['end'] = self._io.pos()
+
+
+
+    class PathTableEntryLe(KaitaiStruct):
+        SEQ_FIELDS = ["len_dir_name", "len_ext_attr_rec", "lba_extent", "parent_dir_idx", "dir_name", "padding"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['len_dir_name']['start'] = self._io.pos()
+            self.len_dir_name = self._io.read_u1()
+            self._debug['len_dir_name']['end'] = self._io.pos()
+            self._debug['len_ext_attr_rec']['start'] = self._io.pos()
+            self.len_ext_attr_rec = self._io.read_u1()
+            self._debug['len_ext_attr_rec']['end'] = self._io.pos()
+            self._debug['lba_extent']['start'] = self._io.pos()
+            self.lba_extent = self._io.read_u4le()
+            self._debug['lba_extent']['end'] = self._io.pos()
+            self._debug['parent_dir_idx']['start'] = self._io.pos()
+            self.parent_dir_idx = self._io.read_u2le()
+            self._debug['parent_dir_idx']['end'] = self._io.pos()
+            self._debug['dir_name']['start'] = self._io.pos()
+            self.dir_name = (self._io.read_bytes(self.len_dir_name)).decode(u"UTF-8")
+            self._debug['dir_name']['end'] = self._io.pos()
+            if (self.len_dir_name % 2) == 1:
+                self._debug['padding']['start'] = self._io.pos()
+                self.padding = self._io.read_u1()
+                self._debug['padding']['end'] = self._io.pos()
+
+
+
+    class DirEntries(KaitaiStruct):
+        SEQ_FIELDS = ["entries"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['entries']['start'] = self._io.pos()
+            self.entries = []
+            i = 0
+            while True:
+                if not 'arr' in self._debug['entries']:
+                    self._debug['entries']['arr'] = []
+                self._debug['entries']['arr'].append({'start': self._io.pos()})
+                _t_entries = self._root.DirEntry(self._io, self, self._root)
+                _t_entries._read()
+                _ = _t_entries
+                self.entries.append(_)
+                self._debug['entries']['arr'][len(self.entries) - 1]['end'] = self._io.pos()
+                if _.len == 0:
+                    break
+                i += 1
+            self._debug['entries']['end'] = self._io.pos()
+
+
+    class U4bi(KaitaiStruct):
+        SEQ_FIELDS = ["le", "be"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['le']['start'] = self._io.pos()
+            self.le = self._io.read_u4le()
+            self._debug['le']['end'] = self._io.pos()
+            self._debug['be']['start'] = self._io.pos()
+            self.be = self._io.read_u4be()
+            self._debug['be']['end'] = self._io.pos()
+
+
+    class U2bi(KaitaiStruct):
+        SEQ_FIELDS = ["le", "be"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['le']['start'] = self._io.pos()
+            self.le = self._io.read_u2le()
+            self._debug['le']['end'] = self._io.pos()
+            self._debug['be']['start'] = self._io.pos()
+            self.be = self._io.read_u2be()
+            self._debug['be']['end'] = self._io.pos()
+
+
+    class PathTableLe(KaitaiStruct):
+        """
+        .. seealso::
+           Source - http://wiki.osdev.org/ISO_9660#The_Path_Table
+        """
+        SEQ_FIELDS = ["entries"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['entries']['start'] = self._io.pos()
+            self.entries = []
+            i = 0
+            while not self._io.is_eof():
+                if not 'arr' in self._debug['entries']:
+                    self._debug['entries']['arr'] = []
+                self._debug['entries']['arr'].append({'start': self._io.pos()})
+                _t_entries = self._root.PathTableEntryLe(self._io, self, self._root)
+                _t_entries._read()
+                self.entries.append(_t_entries)
+                self._debug['entries']['arr'][len(self.entries) - 1]['end'] = self._io.pos()
+                i += 1
+
+            self._debug['entries']['end'] = self._io.pos()
+
+
+    class DecDatetime(KaitaiStruct):
+        """
+        .. seealso::
+           Source - http://wiki.osdev.org/ISO_9660#Date.2Ftime_format
+        """
+        SEQ_FIELDS = ["year", "month", "day", "hour", "minute", "sec", "sec_hundreds", "timezone"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['year']['start'] = self._io.pos()
+            self.year = (self._io.read_bytes(4)).decode(u"ASCII")
+            self._debug['year']['end'] = self._io.pos()
+            self._debug['month']['start'] = self._io.pos()
+            self.month = (self._io.read_bytes(2)).decode(u"ASCII")
+            self._debug['month']['end'] = self._io.pos()
+            self._debug['day']['start'] = self._io.pos()
+            self.day = (self._io.read_bytes(2)).decode(u"ASCII")
+            self._debug['day']['end'] = self._io.pos()
+            self._debug['hour']['start'] = self._io.pos()
+            self.hour = (self._io.read_bytes(2)).decode(u"ASCII")
+            self._debug['hour']['end'] = self._io.pos()
+            self._debug['minute']['start'] = self._io.pos()
+            self.minute = (self._io.read_bytes(2)).decode(u"ASCII")
+            self._debug['minute']['end'] = self._io.pos()
+            self._debug['sec']['start'] = self._io.pos()
+            self.sec = (self._io.read_bytes(2)).decode(u"ASCII")
+            self._debug['sec']['end'] = self._io.pos()
+            self._debug['sec_hundreds']['start'] = self._io.pos()
+            self.sec_hundreds = (self._io.read_bytes(2)).decode(u"ASCII")
+            self._debug['sec_hundreds']['end'] = self._io.pos()
+            self._debug['timezone']['start'] = self._io.pos()
+            self.timezone = self._io.read_u1()
+            self._debug['timezone']['end'] = self._io.pos()
+
+
+    class DirEntryBody(KaitaiStruct):
+        SEQ_FIELDS = ["len_ext_attr_rec", "lba_extent", "size_extent", "datetime", "file_flags", "file_unit_size", "interleave_gap_size", "vol_seq_num", "len_file_name", "file_name", "padding", "rest"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['len_ext_attr_rec']['start'] = self._io.pos()
+            self.len_ext_attr_rec = self._io.read_u1()
+            self._debug['len_ext_attr_rec']['end'] = self._io.pos()
+            self._debug['lba_extent']['start'] = self._io.pos()
+            self.lba_extent = self._root.U4bi(self._io, self, self._root)
+            self.lba_extent._read()
+            self._debug['lba_extent']['end'] = self._io.pos()
+            self._debug['size_extent']['start'] = self._io.pos()
+            self.size_extent = self._root.U4bi(self._io, self, self._root)
+            self.size_extent._read()
+            self._debug['size_extent']['end'] = self._io.pos()
+            self._debug['datetime']['start'] = self._io.pos()
+            self.datetime = self._root.Datetime(self._io, self, self._root)
+            self.datetime._read()
+            self._debug['datetime']['end'] = self._io.pos()
+            self._debug['file_flags']['start'] = self._io.pos()
+            self.file_flags = self._io.read_u1()
+            self._debug['file_flags']['end'] = self._io.pos()
+            self._debug['file_unit_size']['start'] = self._io.pos()
+            self.file_unit_size = self._io.read_u1()
+            self._debug['file_unit_size']['end'] = self._io.pos()
+            self._debug['interleave_gap_size']['start'] = self._io.pos()
+            self.interleave_gap_size = self._io.read_u1()
+            self._debug['interleave_gap_size']['end'] = self._io.pos()
+            self._debug['vol_seq_num']['start'] = self._io.pos()
+            self.vol_seq_num = self._root.U2bi(self._io, self, self._root)
+            self.vol_seq_num._read()
+            self._debug['vol_seq_num']['end'] = self._io.pos()
+            self._debug['len_file_name']['start'] = self._io.pos()
+            self.len_file_name = self._io.read_u1()
+            self._debug['len_file_name']['end'] = self._io.pos()
+            self._debug['file_name']['start'] = self._io.pos()
+            self.file_name = (self._io.read_bytes(self.len_file_name)).decode(u"UTF-8")
+            self._debug['file_name']['end'] = self._io.pos()
+            if (self.len_file_name % 2) == 0:
+                self._debug['padding']['start'] = self._io.pos()
+                self.padding = self._io.read_u1()
+                self._debug['padding']['end'] = self._io.pos()
+
+            self._debug['rest']['start'] = self._io.pos()
+            self.rest = self._io.read_bytes_full()
+            self._debug['rest']['end'] = self._io.pos()
+
+        @property
+        def extent_as_dir(self):
+            if hasattr(self, '_m_extent_as_dir'):
+                return self._m_extent_as_dir if hasattr(self, '_m_extent_as_dir') else None
+
+            if (self.file_flags & 2) != 0:
+                io = self._root._io
+                _pos = io.pos()
+                io.seek((self.lba_extent.le * self._root.sector_size))
+                self._debug['_m_extent_as_dir']['start'] = io.pos()
+                self._raw__m_extent_as_dir = io.read_bytes(self.size_extent.le)
+                io = KaitaiStream(BytesIO(self._raw__m_extent_as_dir))
+                self._m_extent_as_dir = self._root.DirEntries(io, self, self._root)
+                self._m_extent_as_dir._read()
+                self._debug['_m_extent_as_dir']['end'] = io.pos()
+                io.seek(_pos)
+
+            return self._m_extent_as_dir if hasattr(self, '_m_extent_as_dir') else None
+
+        @property
+        def extent_as_file(self):
+            if hasattr(self, '_m_extent_as_file'):
+                return self._m_extent_as_file if hasattr(self, '_m_extent_as_file') else None
+
+            if (self.file_flags & 2) == 0:
+                io = self._root._io
+                _pos = io.pos()
+                io.seek((self.lba_extent.le * self._root.sector_size))
+                self._debug['_m_extent_as_file']['start'] = io.pos()
+                self._m_extent_as_file = io.read_bytes(self.size_extent.le)
+                self._debug['_m_extent_as_file']['end'] = io.pos()
+                io.seek(_pos)
+
+            return self._m_extent_as_file if hasattr(self, '_m_extent_as_file') else None
+
+
+    @property
+    def sector_size(self):
+        if hasattr(self, '_m_sector_size'):
+            return self._m_sector_size if hasattr(self, '_m_sector_size') else None
+
+        self._m_sector_size = 2048
+        return self._m_sector_size if hasattr(self, '_m_sector_size') else None
+
+    @property
+    def primary_vol_desc(self):
+        if hasattr(self, '_m_primary_vol_desc'):
+            return self._m_primary_vol_desc if hasattr(self, '_m_primary_vol_desc') else None
+
+        _pos = self._io.pos()
+        self._io.seek((16 * self.sector_size))
+        self._debug['_m_primary_vol_desc']['start'] = self._io.pos()
+        self._m_primary_vol_desc = self._root.VolDesc(self._io, self, self._root)
+        self._m_primary_vol_desc._read()
+        self._debug['_m_primary_vol_desc']['end'] = self._io.pos()
+        self._io.seek(_pos)
+        return self._m_primary_vol_desc if hasattr(self, '_m_primary_vol_desc') else None
+
+