def _read(self):
self._debug['version']['start'] = self._io.pos()
self.version = self._io.read_u2le()
self._debug['version']['end'] = self._io.pos()
self._debug['flags']['start'] = self._io.pos()
self._raw_flags = self._io.read_bytes(2)
_io__raw_flags = KaitaiStream(BytesIO(self._raw_flags))
self.flags = Zip.LocalFileHeader.GpFlags(_io__raw_flags, self, self._root)
self.flags._read()
self._debug['flags']['end'] = self._io.pos()
self._debug['compression_method']['start'] = self._io.pos()
self.compression_method = KaitaiStream.resolve_enum(Zip.Compression, self._io.read_u2le())
self._debug['compression_method']['end'] = self._io.pos()
self._debug['file_mod_time']['start'] = self._io.pos()
self._raw_file_mod_time = self._io.read_bytes(4)
_io__raw_file_mod_time = KaitaiStream(BytesIO(self._raw_file_mod_time))
self.file_mod_time = dos_datetime.DosDatetime(_io__raw_file_mod_time)
self.file_mod_time._read()
self._debug['file_mod_time']['end'] = self._io.pos()
self._debug['crc32']['start'] = self._io.pos()
self.crc32 = self._io.read_u4le()
self._debug['crc32']['end'] = self._io.pos()
self._debug['len_body_compressed']['start'] = self._io.pos()
self.len_body_compressed = self._io.read_u4le()
self._debug['len_body_compressed']['end'] = self._io.pos()
self._debug['len_body_uncompressed']['start'] = self._io.pos()
self.len_body_uncompressed = self._io.read_u4le()
self._debug['len_body_uncompressed']['end'] = self._io.pos()
self._debug['len_file_name']['start'] = self._io.pos()
self.len_file_name = self._io.read_u2le()
self._debug['len_file_name']['end'] = self._io.pos()
self._debug['len_extra']['start'] = self._io.pos()
self.len_extra = self._io.read_u2le()
self._debug['len_extra']['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()
self._debug['extra']['start'] = self._io.pos()
self._raw_extra = self._io.read_bytes(self.len_extra)
_io__raw_extra = KaitaiStream(BytesIO(self._raw_extra))
self.extra = Zip.Extras(_io__raw_extra, self, self._root)
self.extra._read()
self._debug['extra']['end'] = self._io.pos()
def _read(self):
self._debug['properties']['start'] = self._io.pos()
self.properties = []
i = 0
while True:
if not 'arr' in self._debug['properties']:
self._debug['properties']['arr'] = []
self._debug['properties']['arr'].append({'start': self._io.pos()})
_t_properties = AllegroDat.Property(self._io, self, self._root)
_t_properties._read()
_ = _t_properties
self.properties.append(_)
self._debug['properties']['arr'][len(self.properties) - 1]['end'] = self._io.pos()
if not (_.is_valid):
break
i += 1
self._debug['properties']['end'] = self._io.pos()
self._debug['len_compressed']['start'] = self._io.pos()
self.len_compressed = self._io.read_s4be()
self._debug['len_compressed']['end'] = self._io.pos()
self._debug['len_uncompressed']['start'] = self._io.pos()
self.len_uncompressed = self._io.read_s4be()
self._debug['len_uncompressed']['end'] = self._io.pos()
self._debug['body']['start'] = self._io.pos()
_on = self.type
if _on == u"BMP ":
self._raw_body = self._io.read_bytes(self.len_compressed)
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = AllegroDat.DatBitmap(_io__raw_body, self, self._root)
self.body._read()
elif _on == u"RLE ":
self._raw_body = self._io.read_bytes(self.len_compressed)
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = AllegroDat.DatRleSprite(_io__raw_body, self, self._root)
self.body._read()
elif _on == u"FONT":
self._raw_body = self._io.read_bytes(self.len_compressed)
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = AllegroDat.DatFont(_io__raw_body, self, self._root)
self.body._read()
else:
self.body = self._io.read_bytes(self.len_compressed)
self._debug['body']['end'] = self._io.pos()
def data(self):
if hasattr(self, '_m_data'):
return self._m_data if hasattr(self, '_m_data') else None
_pos = self._io.pos()
self._io.seek(self.ofs_data)
self._debug['_m_data']['start'] = self._io.pos()
_on = self.stream_type
if _on == self._root.StreamTypes.memory_list:
self._raw__m_data = self._io.read_bytes(self.len_data)
_io__raw__m_data = KaitaiStream(BytesIO(self._raw__m_data))
self._m_data = self._root.MemoryList(_io__raw__m_data, self,
self._root)
self._m_data._read()
elif _on == self._root.StreamTypes.misc_info:
self._raw__m_data = self._io.read_bytes(self.len_data)
_io__raw__m_data = KaitaiStream(BytesIO(self._raw__m_data))
self._m_data = self._root.MiscInfo(_io__raw__m_data, self,
self._root)
self._m_data._read()
elif _on == self._root.StreamTypes.thread_list:
self._raw__m_data = self._io.read_bytes(self.len_data)
_io__raw__m_data = KaitaiStream(BytesIO(self._raw__m_data))
self._m_data = self._root.ThreadList(_io__raw__m_data, self,
self._root)
self._m_data._read()
elif _on == self._root.StreamTypes.exception:
self._raw__m_data = self._io.read_bytes(self.len_data)
_io__raw__m_data = KaitaiStream(BytesIO(self._raw__m_data))
self._m_data = self._root.ExceptionStream(
_io__raw__m_data, self, self._root)
self._m_data._read()
elif _on == self._root.StreamTypes.system_info:
self._raw__m_data = self._io.read_bytes(self.len_data)
_io__raw__m_data = KaitaiStream(BytesIO(self._raw__m_data))
self._m_data = self._root.SystemInfo(_io__raw__m_data, self,
self._root)
self._m_data._read()
else:
self._m_data = self._io.read_bytes(self.len_data)
self._debug['_m_data']['end'] = self._io.pos()
self._io.seek(_pos)
return self._m_data if hasattr(self, '_m_data') else None
def _read(self):
self.delim = self._io.read_bytes(1)
if not self.delim == b"\xAA":
raise kaitaistruct.ValidationNotEqualError(b"\xAA", self.delim, self._io, u"/types/entry/seq/0")
self.tag = self._io.read_u1()
self.length = self._io.read_u2be()
self.counter = self._io.read_u2be()
_on = self.tag
if _on == 0:
self._raw_body = self._io.read_bytes((self.length - 6))
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = ModelSxLog.OnChange(_io__raw_body, self, self._root)
elif _on == 1:
self._raw_body = self._io.read_bytes((self.length - 6))
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = ModelSxLog.Periodic(_io__raw_body, self, self._root)
else:
self.body = self._io.read_bytes((self.length - 6))
self.checksum = self._io.read_u1()
def _read(self):
self._debug['len_all']['start'] = self._io.pos()
self.len_all = self._io.read_u4le()
self._debug['len_all']['end'] = self._io.pos()
self._debug['all']['start'] = self._io.pos()
self._raw_all = self._io.read_bytes((self.len_all - 4))
_io__raw_all = KaitaiStream(BytesIO(self._raw_all))
self.all = self._root.LinkInfo.All(_io__raw_all, self, self._root)
self.all._read()
self._debug['all']['end'] = self._io.pos()
def _read(self):
self._debug['b1']['start'] = self._io.pos()
self.b1 = self._io.read_u1()
self._debug['b1']['end'] = self._io.pos()
self._debug['b2']['start'] = self._io.pos()
self.b2 = self._io.read_u1()
self._debug['b2']['end'] = self._io.pos()
self._debug['total_length']['start'] = self._io.pos()
self.total_length = self._io.read_u2be()
self._debug['total_length']['end'] = self._io.pos()
self._debug['identification']['start'] = self._io.pos()
self.identification = self._io.read_u2be()
self._debug['identification']['end'] = self._io.pos()
self._debug['b67']['start'] = self._io.pos()
self.b67 = self._io.read_u2be()
self._debug['b67']['end'] = self._io.pos()
self._debug['ttl']['start'] = self._io.pos()
self.ttl = self._io.read_u1()
self._debug['ttl']['end'] = self._io.pos()
self._debug['protocol']['start'] = self._io.pos()
self.protocol = self._io.read_u1()
self._debug['protocol']['end'] = self._io.pos()
self._debug['header_checksum']['start'] = self._io.pos()
self.header_checksum = self._io.read_u2be()
self._debug['header_checksum']['end'] = self._io.pos()
self._debug['src_ip_addr']['start'] = self._io.pos()
self.src_ip_addr = self._io.read_bytes(4)
self._debug['src_ip_addr']['end'] = self._io.pos()
self._debug['dst_ip_addr']['start'] = self._io.pos()
self.dst_ip_addr = self._io.read_bytes(4)
self._debug['dst_ip_addr']['end'] = self._io.pos()
self._debug['options']['start'] = self._io.pos()
self._raw_options = self._io.read_bytes((self.ihl_bytes - 20))
_io__raw_options = KaitaiStream(BytesIO(self._raw_options))
self.options = self._root.Ipv4Options(_io__raw_options, self, self._root)
self.options._read()
self._debug['options']['end'] = self._io.pos()
self._debug['body']['start'] = self._io.pos()
self._raw_body = self._io.read_bytes((self.total_length - self.ihl_bytes))
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = protocol_body.ProtocolBody(self.protocol, _io__raw_body)
self.body._read()
self._debug['body']['end'] = self._io.pos()
def _read(self):
self._raw_header = self._io.read_bytes(
(self._parent.header_len - 1))
io = KaitaiStream(BytesIO(self._raw_header))
self.header = self._root.Header(io, self, self._root)
if self.header.header1.lha_level == 0:
self.file_uncompr_crc16 = self._io.read_u2le()
self.body = self._io.read_bytes(
self.header.header1.file_size_compr)
def _read(self):
self.magic = self._io.ensure_fixed_contents(b"\x4E\x45\x53\x1A")
self.len_prg_rom = self._io.read_u1()
self.len_chr_rom = self._io.read_u1()
self._raw_f6 = self._io.read_bytes(1)
io = KaitaiStream(BytesIO(self._raw_f6))
self.f6 = self._root.Header.F6(io, self, self._root)
self._raw_f7 = self._io.read_bytes(1)
io = KaitaiStream(BytesIO(self._raw_f7))
self.f7 = self._root.Header.F7(io, self, self._root)
self.len_prg_ram = self._io.read_u1()
self._raw_f9 = self._io.read_bytes(1)
io = KaitaiStream(BytesIO(self._raw_f9))
self.f9 = self._root.Header.F9(io, self, self._root)
self._raw_f10 = self._io.read_bytes(1)
io = KaitaiStream(BytesIO(self._raw_f10))
self.f10 = self._root.Header.F10(io, self, self._root)
self.reserved = self._io.ensure_fixed_contents(
b"\x00\x00\x00\x00\x00")
def _read(self):
self._debug['reserved']['start'] = self._io.pos()
self.reserved = self._io.read_u1()
self._debug['reserved']['end'] = self._io.pos()
self._debug['configurations']['start'] = self._io.pos()
self._raw_configurations = self._io.read_bytes((self._parent.header.length - 1))
_io__raw_configurations = KaitaiStream(BytesIO(self._raw_configurations))
self.configurations = SomeIpSdOptions.SdOption.SdConfigStringsContainer(_io__raw_configurations, self, self._root)
self.configurations._read()
self._debug['configurations']['end'] = self._io.pos()
def _read(self):
self.code = self._io.read_u1()
self.size = self._io.read_u4le()
_on = self.code
if _on == 17:
self._raw_body = self._io.read_bytes(self.size)
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = SwitchManualIntSizeElse.Chunk.ChunkMeta(
_io__raw_body, self, self._root)
elif _on == 34:
self._raw_body = self._io.read_bytes(self.size)
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = SwitchManualIntSizeElse.Chunk.ChunkDir(
_io__raw_body, self, self._root)
else:
self._raw_body = self._io.read_bytes(self.size)
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = SwitchManualIntSizeElse.Chunk.Dummy(
_io__raw_body, self, self._root)
def _read(self):
self.len_block = self._io.read_u4be()
self.block_identifier = KaitaiStream.resolve_enum(MozillaMar.BlockIdentifiers, self._io.read_u4be())
_on = self.block_identifier
if _on == MozillaMar.BlockIdentifiers.product_information:
self._raw_bytes = self._io.read_bytes(((self.len_block - 4) - 4))
_io__raw_bytes = KaitaiStream(BytesIO(self._raw_bytes))
self.bytes = MozillaMar.ProductInformationBlock(_io__raw_bytes, self, self._root)
else:
self.bytes = self._io.read_bytes(((self.len_block - 4) - 4))
def _read(self):
self.b1 = self._io.read_u1()
self.b2 = self._io.read_u1()
self.total_length = self._io.read_u2be()
self.identification = self._io.read_u2be()
self.b67 = self._io.read_u2be()
self.ttl = self._io.read_u1()
self.protocol = self._io.read_u1()
self.header_checksum = self._io.read_u2be()
self.src_ip_addr = self._io.read_bytes(4)
self.dst_ip_addr = self._io.read_bytes(4)
self._raw_options = self._io.read_bytes((self.ihl_bytes - 20))
_io__raw_options = KaitaiStream(BytesIO(self._raw_options))
self.options = Ipv4Packet.Ipv4Options(_io__raw_options, self,
self._root)
self._raw_body = self._io.read_bytes(
(self.total_length - self.ihl_bytes))
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = protocol_body.ProtocolBody(self.protocol, _io__raw_body)
def _read(self):
self.four_cc = KaitaiStream.resolve_enum(Avi.ChunkType,
self._io.read_u4le())
self.block_size = self._io.read_u4le()
_on = self.four_cc
if _on == Avi.ChunkType.list:
self._raw_data = self._io.read_bytes(self.block_size)
_io__raw_data = KaitaiStream(BytesIO(self._raw_data))
self.data = Avi.ListBody(_io__raw_data, self, self._root)
elif _on == Avi.ChunkType.avih:
self._raw_data = self._io.read_bytes(self.block_size)
_io__raw_data = KaitaiStream(BytesIO(self._raw_data))
self.data = Avi.AvihBody(_io__raw_data, self, self._root)
elif _on == Avi.ChunkType.strh:
self._raw_data = self._io.read_bytes(self.block_size)
_io__raw_data = KaitaiStream(BytesIO(self._raw_data))
self.data = Avi.StrhBody(_io__raw_data, self, self._root)
else:
self.data = self._io.read_bytes(self.block_size)
def _read(self):
self.string_magic = self._io.read_bytes(1)
if not self.string_magic == b"\x73":
raise kaitaistruct.ValidationNotEqualError(
b"\x73", self.string_magic, self._io,
u"/types/assembly/seq/0")
self.length = self._io.read_u4le()
self._raw_items = self._io.read_bytes(self.length)
_io__raw_items = KaitaiStream(BytesIO(self._raw_items))
self.items = PythonPyc27.OpArgs(_io__raw_items, self, self._root)
def _read(self):
self.meta_header = AndroidBootldrHuawei.MetaHdr(
self._io, self, self._root)
self.header_ext = self._io.read_bytes(
(self.meta_header.len_meta_header - 76))
self._raw_image_header = self._io.read_bytes(
self.meta_header.len_image_header)
_io__raw_image_header = KaitaiStream(BytesIO(self._raw_image_header))
self.image_header = AndroidBootldrHuawei.ImageHdr(
_io__raw_image_header, self, self._root)
def _read(self):
self.b1 = self._io.read_u1()
self.b2 = self._io.read_u1()
self.total_length = self._io.read_u2be()
self.identification = self._io.read_u2be()
self.b67 = self._io.read_u2be()
self.ttl = self._io.read_u1()
self.protocol = self._io.read_u1()
self.header_checksum = self._io.read_u2be()
self.src_ip_addr = self._io.read_bytes(4)
self.dst_ip_addr = self._io.read_bytes(4)
self._raw_options = self._io.read_bytes((self.ihl_bytes - 20))
io = KaitaiStream(BytesIO(self._raw_options))
self.options = self._root.Ipv4Options(io, self, self._root)
self.read_len = self.total_length if self.total_length > 0 else 64
self._raw_body = self._io.read_bytes(self.read_len - self.ihl_bytes)
# self._raw_body = self._io.read_bytes((self.total_length - self.ihl_bytes))
io = KaitaiStream(BytesIO(self._raw_body))
self.body = ProtocolBody(self.protocol, io)
def _read(self):
self.uuid = self._io.read_bytes(16)
self.image_start_sector = self._io.read_u4be()
self.image_size = self._io.read_u4be()
self.audio_start_sector = self._io.read_u4be()
self.audio_size = self._io.read_u4be()
self._raw_navigation = self._io.read_bytes((512 - 32))
_io__raw_navigation = KaitaiStream(BytesIO(self._raw_navigation))
self.navigation = self._root.NavigationStruct(
_io__raw_navigation, self, self._root)
def _read(self):
self.dst_mac = self._io.read_bytes(6)
self.src_mac = self._io.read_bytes(6)
try:
self.ether_type = self._root.EtherTypeEnum(self._io.read_u2be())
_on = self.ether_type
except:
self.ether_type = self._root.EtherTypeEnum(None)
_on = None
if _on == self._root.EtherTypeEnum.ipv4:
self._raw_body = self._io.read_bytes_full()
io = KaitaiStream(BytesIO(self._raw_body))
self.body = Ipv4Packet(io)
elif _on == self._root.EtherTypeEnum.ipv6:
self._raw_body = self._io.read_bytes_full()
io = KaitaiStream(BytesIO(self._raw_body))
self.body = Ipv6Packet(io)
else:
self.body = self._io.read_bytes_full()
def _read(self):
self.qty_entries = self._io.read_u4le()
self.entries = [None] * (self.qty_entries)
for i in range(self.qty_entries):
self.entries[i] = InstanceIoUser.Entry(self._io, self, self._root)
self._raw_strings = self._io.read_bytes_full()
_io__raw_strings = KaitaiStream(BytesIO(self._raw_strings))
self.strings = InstanceIoUser.StringsObj(_io__raw_strings, self,
self._root)
def _read(self):
self._debug['decompressor_id']['start'] = self._io.pos()
self.decompressor_id = self._io.read_s2be()
self._debug['decompressor_id']['end'] = self._io.pos()
self._debug['decompressor_specific_parameters_with_io']['start'] = self._io.pos()
self._raw_decompressor_specific_parameters_with_io = self._io.read_bytes(4)
_io__raw_decompressor_specific_parameters_with_io = KaitaiStream(BytesIO(self._raw_decompressor_specific_parameters_with_io))
self.decompressor_specific_parameters_with_io = bytes_with_io.BytesWithIo(_io__raw_decompressor_specific_parameters_with_io)
self.decompressor_specific_parameters_with_io._read()
self._debug['decompressor_specific_parameters_with_io']['end'] = self._io.pos()
def _read(self):
self.len = self._io.read_s4le()
self._raw_fields = self._io.read_bytes((self.len - 5))
_io__raw_fields = KaitaiStream(BytesIO(self._raw_fields))
self.fields = Bson.ElementsList(_io__raw_fields, self, self._root)
self.terminator = self._io.read_bytes(1)
if not self.terminator == b"\x00":
raise kaitaistruct.ValidationNotEqualError(b"\x00",
self.terminator,
self._io, u"/seq/2")
def _read(self):
self.header = self._root.ArchiveStorageHeader.Header(
self._io, self, self._root)
self._raw__raw_blocks_info = self._io.read_bytes(
self.header.compressed_size)
_process = Lz4process(self.header.uncompressed_size)
self._raw_blocks_info = _process.decode(self._raw__raw_blocks_info)
io = KaitaiStream(BytesIO(self._raw_blocks_info))
self.blocks_info = self._root.ArchiveStorageHeader.BlocksInfo(
io, self, self._root)
def _read(self):
self.signature = self._io.ensure_fixed_contents(b"\x01\xB0\x93\xFF")
self.size = self._io.read_u4le()
self.reserved0 = self._io.read_bytes(4)
self.last_frame = self._io.read_u2le()
self.reserved1 = self._io.read_bytes(18)
self.wrond_doc = self._io.read_bytes(1)
self._raw_frames = self._io.read_bytes(self.size)
io = KaitaiStream(BytesIO(self._raw_frames))
self.frames = self._root.Framez(io, self, self._root)
def _read(self):
self.tag = self._io.read_u2le()
self.len_body = self._io.read_u2le()
_on = self.tag
if _on == 1:
self._raw_body = self._io.read_bytes(self.len_body)
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = Zip.ExtraField.Ntfs.Attribute1(_io__raw_body, self, self._root)
else:
self.body = self._io.read_bytes(self.len_body)
def _read(self):
self.uid = self._io.read_u4be()
_on = self.uid
if _on == 1380273474:
self._raw_contents = self._io.read_bytes_full()
_io__raw_contents = KaitaiStream(BytesIO(self._raw_contents))
self.contents = RtcpPayload.PsfbAfbRembPacket(
_io__raw_contents, self, self._root)
else:
self.contents = self._io.read_bytes_full()
def _read(self):
self._debug['file_hdr']['start'] = self._io.pos()
self.file_hdr = self._root.FileHeader(self._io, self, self._root)
self.file_hdr._read()
self._debug['file_hdr']['end'] = self._io.pos()
self._debug['dib_info']['start'] = self._io.pos()
self._raw_dib_info = self._io.read_bytes(
(self.file_hdr.ofs_bitmap - 14))
_io__raw_dib_info = KaitaiStream(BytesIO(self._raw_dib_info))
self.dib_info = self._root.BitmapInfo(_io__raw_dib_info, self,
self._root)
self.dib_info._read()
self._debug['dib_info']['end'] = self._io.pos()
self._debug['bitmap']['start'] = self._io.pos()
self._raw_bitmap = self._io.read_bytes_full()
_io__raw_bitmap = KaitaiStream(BytesIO(self._raw_bitmap))
self.bitmap = self._root.Bitmap(_io__raw_bitmap, self, self._root)
self.bitmap._read()
self._debug['bitmap']['end'] = self._io.pos()
def parse_volume_keybag(unwrapped_keybag):
"""
Returns a kaitai struct structure of the unwrapped keybag
param: unwrappped_keybag: The bytes like keybag that will be parsed
return: keybag: The structured keybag
"""
stream = KaitaiStream(BytesIO(unwrapped_keybag))
keybag = media_keybag_t_kek(stream)
return keybag
def _read(self):
self.header = self._root.FileHeader(self._io, self, self._root)
self._raw_hive_bins = []
self.hive_bins = []
i = 0
while not self._io.is_eof():
self._raw_hive_bins.append(self._io.read_bytes(4096))
io = KaitaiStream(BytesIO(self._raw_hive_bins[-1]))
self.hive_bins.append(self._root.HiveBin(io, self, self._root))
i += 1
def _read(self):
self._debug['header_length']['start'] = self._io.pos()
self.header_length = self._io.read_u4le()
self._debug['header_length']['end'] = self._io.pos()
self._debug['main']['start'] = self._io.pos()
self._raw_main = self._io.read_bytes((self.header_length - 4))
_io__raw_main = KaitaiStream(BytesIO(self._raw_main))
self.main = FasttrackerXmModule.Pattern.Header.HeaderMain(_io__raw_main, self, self._root)
self.main._read()
self._debug['main']['end'] = self._io.pos()
def _read(self):
self.ssrc = self._io.read_u4be()
self.ssrc_media_source = self._io.read_u4be()
_on = self.fmt
if _on == self._root.PsfbSubtype.afb:
self._raw_fci_block = self._io.read_bytes_full()
io = KaitaiStream(BytesIO(self._raw_fci_block))
self.fci_block = self._root.PsfbAfbPacket(io, self, self._root)
else:
self.fci_block = self._io.read_bytes_full()
