def root_type(self):
if hasattr(self, '_m_root_type'):
return self._m_root_type
_pos = self._io.pos()
self._io.seek(0)
self._m_root_type = KaitaiStream.resolve_enum(MinecraftNbt.Tag,
self._io.read_u1())
self._io.seek(_pos)
if not self.root_type == MinecraftNbt.Tag.compound:
raise kaitaistruct.ValidationNotEqualError(
MinecraftNbt.Tag.compound, self.root_type, self._io,
u"/instances/root_type")
return getattr(self, '_m_root_type', None)
def _read(self):
self.icmp_type = KaitaiStream.resolve_enum(IcmpPacket.IcmpTypeEnum,
self._io.read_u1())
if self.icmp_type == IcmpPacket.IcmpTypeEnum.destination_unreachable:
self.destination_unreachable = IcmpPacket.DestinationUnreachableMsg(
self._io, self, self._root)
if self.icmp_type == IcmpPacket.IcmpTypeEnum.time_exceeded:
self.time_exceeded = IcmpPacket.TimeExceededMsg(
self._io, self, self._root)
if ((self.icmp_type == IcmpPacket.IcmpTypeEnum.echo)
or (self.icmp_type == IcmpPacket.IcmpTypeEnum.echo_reply)):
self.echo = IcmpPacket.EchoMsg(self._io, self, self._root)
def _read_be(self):
self.timestamp = self._io.read_u4be()
if self.old:
self.ipv4 = self._io.read_bytes(4)
if self.has_ip_proto:
self.ip_proto = KaitaiStream.resolve_enum(
ProtocolBody.ProtocolEnum, self._io.read_u1())
self.port = self._io.read_u2be()
if self.app_proto_present:
self.app_proto = KaitaiStream.resolve_enum(
Masscan.AppProto, self._io.read_u2be())
if self.has_reason:
self.reason = self._io.read_u1()
if self.has_ttl:
self.ttl = self._io.read_u1()
if not (self.old):
self.ip_with_version = Masscan.Record.SwitcheableIpVersion(
self._io, self, self._root)
def _read(self):
self.service_type = KaitaiStream.resolve_enum(
RadioControlProtocol.ServiceTypes, self._io.read_u2le())
self.message_length = self._io.read_u2le()
_on = self.service_type
if _on == RadioControlProtocol.ServiceTypes.call_request:
self.data = RadioControlProtocol.CallRequest(
self._io, self, self._root)
elif _on == RadioControlProtocol.ServiceTypes.call_reply:
self.data = RadioControlProtocol.CallReply(self._io, self,
self._root)
else:
self.data = RadioControlProtocol.GenericData(
self._io, self, self._root)
def _read(self):
self.flags = KaitaiStream.resolve_enum(
Model3Hrl.Record.RecordFlags, self._io.read_bits_int_be(2))
self.counter = self._io.read_bits_int_be(6)
self._io.align_to_byte()
_on = self.flags
if _on == Model3Hrl.Record.RecordFlags.can_frame:
self.payload = Model3Hrl.CanFrame(self._io, self, self._root)
elif _on == Model3Hrl.Record.RecordFlags.timestamp_frame:
self.payload = Model3Hrl.TimestampFrame(
self._io, self, self._root)
elif _on == Model3Hrl.Record.RecordFlags.end_of_block:
self.payload = Model3Hrl.UnknownFrame(self._io, self,
self._root)
def _read(self):
self.len_block = self._io.read_u2le()
self.flag = KaitaiStream.resolve_enum(ZxSpectrumTap.FlagEnum,
self._io.read_u1())
if ((self.len_block == 19)
and (self.flag == ZxSpectrumTap.FlagEnum.header)):
self.header = ZxSpectrumTap.Header(self._io, self, self._root)
if self.len_block == 19:
self.data = self._io.read_bytes((self.header.len_data + 4))
if self.flag == ZxSpectrumTap.FlagEnum.data:
self.headerless_data = self._io.read_bytes(
(self.len_block - 1))
def _read(self):
self._debug['is_data_offset']['start'] = self._io.pos()
self.is_data_offset = self._io.read_bits_int_be(1) != 0
self._debug['is_data_offset']['end'] = self._io.pos()
self._debug['cmd']['start'] = self._io.pos()
self.cmd = KaitaiStream.resolve_enum(MacOsResourceSnd.CmdType, self._io.read_bits_int_be(15))
self._debug['cmd']['end'] = self._io.pos()
self._io.align_to_byte()
self._debug['param1']['start'] = self._io.pos()
self.param1 = self._io.read_u2be()
self._debug['param1']['end'] = self._io.pos()
self._debug['param2']['start'] = self._io.pos()
self.param2 = self._io.read_u4be()
self._debug['param2']['end'] = self._io.pos()
def _read(self):
self._debug['pph_version']['start'] = self._io.pos()
self.pph_version = self._io.read_u1()
self._debug['pph_version']['end'] = self._io.pos()
self._debug['pph_flags']['start'] = self._io.pos()
self.pph_flags = self._io.read_u1()
self._debug['pph_flags']['end'] = self._io.pos()
self._debug['pph_len']['start'] = self._io.pos()
self.pph_len = self._io.read_u2le()
self._debug['pph_len']['end'] = self._io.pos()
self._debug['pph_dlt']['start'] = self._io.pos()
self.pph_dlt = KaitaiStream.resolve_enum(PacketPpi.Linktype,
self._io.read_u4le())
self._debug['pph_dlt']['end'] = self._io.pos()
def _read(self):
self._debug['type']['start'] = self._io.pos()
self.type = KaitaiStream.resolve_enum(self._root.SdesSubtype,
self._io.read_u1())
self._debug['type']['end'] = self._io.pos()
if self.type != self._root.SdesSubtype.pad:
self._debug['length']['start'] = self._io.pos()
self.length = self._io.read_u1()
self._debug['length']['end'] = self._io.pos()
if self.type != self._root.SdesSubtype.pad:
self._debug['value']['start'] = self._io.pos()
self.value = self._io.read_bytes(self.length)
self._debug['value']['end'] = self._io.pos()
def _read(self):
self._debug['type']['start'] = self._io.pos()
self.type = KaitaiStream.resolve_enum(PcfFont.Types, self._io.read_u4le())
self._debug['type']['end'] = self._io.pos()
self._debug['format']['start'] = self._io.pos()
self.format = PcfFont.Format(self._io, self, self._root)
self.format._read()
self._debug['format']['end'] = self._io.pos()
self._debug['len_body']['start'] = self._io.pos()
self.len_body = self._io.read_u4le()
self._debug['len_body']['end'] = self._io.pos()
self._debug['ofs_body']['start'] = self._io.pos()
self.ofs_body = self._io.read_u4le()
self._debug['ofs_body']['end'] = self._io.pos()
def _read(self):
self._debug['intent']['start'] = self._io.pos()
self.intent = KaitaiStream.resolve_enum(self._root.Intent,
self._io.read_u4le())
self._debug['intent']['end'] = self._io.pos()
self._debug['ofs_profile']['start'] = self._io.pos()
self.ofs_profile = self._io.read_u4le()
self._debug['ofs_profile']['end'] = self._io.pos()
self._debug['len_profile']['start'] = self._io.pos()
self.len_profile = self._io.read_u4le()
self._debug['len_profile']['end'] = self._io.pos()
self._debug['reserved']['start'] = self._io.pos()
self.reserved = self._io.read_u4le()
self._debug['reserved']['end'] = self._io.pos()
def _read_be(self):
self.sample_size = self._io.read_u1()
self.header_size = self._io.read_u2be()
self.start_of_data = self._io.read_u2be()
self.dlog_format = KaitaiStream.resolve_enum(
self._root.DlogFormats, self._io.read_u2be())
self.dlog_version = self._io.read_u4be()
self.voltage_scale = self._io.read_u8be()
self.stop_reason = KaitaiStream.resolve_enum(
self._root.StopReasons, self._io.read_u4be())
self.sample_initial_index = self._io.read_u8be()
self.num_samples = self._io.read_u8be()
self.sample_rate_scale = self._io.read_u8be()
self.raw_sample_rate = self._io.read_u8be()
self.delay_scale = self._io.read_u8be()
self.raw_delay = self._io.read_s8be()
if self.dlog_format == self._root.DlogFormats.openlogger:
self.num_openlogger_channels = self._io.read_u4be()
if self.dlog_format == self._root.DlogFormats.openlogger:
self.openlogger_channel_map = [None] * (8)
for i in range(8):
self.openlogger_channel_map[i] = self._io.read_u1()
def _read(self):
self.code = KaitaiStream.resolve_enum(
SwitchManualEnumInvalidElse.Opcode.CodeEnum,
self._io.read_u1())
_on = self.code
if _on == SwitchManualEnumInvalidElse.Opcode.CodeEnum.intval:
self.body = SwitchManualEnumInvalidElse.Opcode.Intval(
self._io, self, self._root)
elif _on == SwitchManualEnumInvalidElse.Opcode.CodeEnum.strval:
self.body = SwitchManualEnumInvalidElse.Opcode.Strval(
self._io, self, self._root)
else:
self.body = SwitchManualEnumInvalidElse.Opcode.Defval(
self._io, self, self._root)
def _read(self):
if not (self.is_prev_two_entries):
self.tag = KaitaiStream.resolve_enum(
JavaClass.ConstantPoolEntry.TagEnum, self._io.read_u1())
if not (self.is_prev_two_entries):
_on = self.tag
if _on == JavaClass.ConstantPoolEntry.TagEnum.interface_method_ref:
self.cp_info = JavaClass.InterfaceMethodRefCpInfo(
self._io, self, self._root)
elif _on == JavaClass.ConstantPoolEntry.TagEnum.class_type:
self.cp_info = JavaClass.ClassCpInfo(
self._io, self, self._root)
elif _on == JavaClass.ConstantPoolEntry.TagEnum.utf8:
self.cp_info = JavaClass.Utf8CpInfo(
self._io, self, self._root)
elif _on == JavaClass.ConstantPoolEntry.TagEnum.method_type:
self.cp_info = JavaClass.MethodTypeCpInfo(
self._io, self, self._root)
elif _on == JavaClass.ConstantPoolEntry.TagEnum.integer:
self.cp_info = JavaClass.IntegerCpInfo(
self._io, self, self._root)
elif _on == JavaClass.ConstantPoolEntry.TagEnum.string:
self.cp_info = JavaClass.StringCpInfo(
self._io, self, self._root)
elif _on == JavaClass.ConstantPoolEntry.TagEnum.float:
self.cp_info = JavaClass.FloatCpInfo(
self._io, self, self._root)
elif _on == JavaClass.ConstantPoolEntry.TagEnum.long:
self.cp_info = JavaClass.LongCpInfo(
self._io, self, self._root)
elif _on == JavaClass.ConstantPoolEntry.TagEnum.method_ref:
self.cp_info = JavaClass.MethodRefCpInfo(
self._io, self, self._root)
elif _on == JavaClass.ConstantPoolEntry.TagEnum.double:
self.cp_info = JavaClass.DoubleCpInfo(
self._io, self, self._root)
elif _on == JavaClass.ConstantPoolEntry.TagEnum.invoke_dynamic:
self.cp_info = JavaClass.InvokeDynamicCpInfo(
self._io, self, self._root)
elif _on == JavaClass.ConstantPoolEntry.TagEnum.field_ref:
self.cp_info = JavaClass.FieldRefCpInfo(
self._io, self, self._root)
elif _on == JavaClass.ConstantPoolEntry.TagEnum.method_handle:
self.cp_info = JavaClass.MethodHandleCpInfo(
self._io, self, self._root)
elif _on == JavaClass.ConstantPoolEntry.TagEnum.name_and_type:
self.cp_info = JavaClass.NameAndTypeCpInfo(
self._io, self, self._root)
def _read(self):
self._debug['magic']['start'] = self._io.pos()
self.magic = self._io.read_bytes(4)
self._debug['magic']['end'] = self._io.pos()
if not self.magic == b"\x4B\x44\x4D\x56":
raise kaitaistruct.ValidationNotEqualError(b"\x4B\x44\x4D\x56",
self.magic, self._io,
u"/seq/0")
self._debug['version']['start'] = self._io.pos()
self.version = self._io.read_s4le()
self._debug['version']['end'] = self._io.pos()
self._debug['flags']['start'] = self._io.pos()
self.flags = VmwareVmdk.HeaderFlags(self._io, self, self._root)
self.flags._read()
self._debug['flags']['end'] = self._io.pos()
self._debug['size_max']['start'] = self._io.pos()
self.size_max = self._io.read_s8le()
self._debug['size_max']['end'] = self._io.pos()
self._debug['size_grain']['start'] = self._io.pos()
self.size_grain = self._io.read_s8le()
self._debug['size_grain']['end'] = self._io.pos()
self._debug['start_descriptor']['start'] = self._io.pos()
self.start_descriptor = self._io.read_s8le()
self._debug['start_descriptor']['end'] = self._io.pos()
self._debug['size_descriptor']['start'] = self._io.pos()
self.size_descriptor = self._io.read_s8le()
self._debug['size_descriptor']['end'] = self._io.pos()
self._debug['num_grain_table_entries']['start'] = self._io.pos()
self.num_grain_table_entries = self._io.read_s4le()
self._debug['num_grain_table_entries']['end'] = self._io.pos()
self._debug['start_secondary_grain']['start'] = self._io.pos()
self.start_secondary_grain = self._io.read_s8le()
self._debug['start_secondary_grain']['end'] = self._io.pos()
self._debug['start_primary_grain']['start'] = self._io.pos()
self.start_primary_grain = self._io.read_s8le()
self._debug['start_primary_grain']['end'] = self._io.pos()
self._debug['size_metadata']['start'] = self._io.pos()
self.size_metadata = self._io.read_s8le()
self._debug['size_metadata']['end'] = self._io.pos()
self._debug['is_dirty']['start'] = self._io.pos()
self.is_dirty = self._io.read_u1()
self._debug['is_dirty']['end'] = self._io.pos()
self._debug['stuff']['start'] = self._io.pos()
self.stuff = self._io.read_bytes(4)
self._debug['stuff']['end'] = self._io.pos()
self._debug['compression_method']['start'] = self._io.pos()
self.compression_method = KaitaiStream.resolve_enum(
VmwareVmdk.CompressionMethods, self._io.read_u2le())
self._debug['compression_method']['end'] = self._io.pos()
def _read(self):
self._debug['tag']['start'] = self._io.pos()
self.tag = KaitaiStream.resolve_enum(self._root.ConstantPoolEntry.TagEnum, self._io.read_u1())
self._debug['tag']['end'] = self._io.pos()
self._debug['cp_info']['start'] = self._io.pos()
_on = self.tag
if _on == self._root.ConstantPoolEntry.TagEnum.interface_method_ref:
self.cp_info = self._root.InterfaceMethodRefCpInfo(self._io, self, self._root)
self.cp_info._read()
elif _on == self._root.ConstantPoolEntry.TagEnum.class_type:
self.cp_info = self._root.ClassCpInfo(self._io, self, self._root)
self.cp_info._read()
elif _on == self._root.ConstantPoolEntry.TagEnum.utf8:
self.cp_info = self._root.Utf8CpInfo(self._io, self, self._root)
self.cp_info._read()
elif _on == self._root.ConstantPoolEntry.TagEnum.method_type:
self.cp_info = self._root.MethodTypeCpInfo(self._io, self, self._root)
self.cp_info._read()
elif _on == self._root.ConstantPoolEntry.TagEnum.integer:
self.cp_info = self._root.IntegerCpInfo(self._io, self, self._root)
self.cp_info._read()
elif _on == self._root.ConstantPoolEntry.TagEnum.string:
self.cp_info = self._root.StringCpInfo(self._io, self, self._root)
self.cp_info._read()
elif _on == self._root.ConstantPoolEntry.TagEnum.float:
self.cp_info = self._root.FloatCpInfo(self._io, self, self._root)
self.cp_info._read()
elif _on == self._root.ConstantPoolEntry.TagEnum.long:
self.cp_info = self._root.LongCpInfo(self._io, self, self._root)
self.cp_info._read()
elif _on == self._root.ConstantPoolEntry.TagEnum.method_ref:
self.cp_info = self._root.MethodRefCpInfo(self._io, self, self._root)
self.cp_info._read()
elif _on == self._root.ConstantPoolEntry.TagEnum.double:
self.cp_info = self._root.DoubleCpInfo(self._io, self, self._root)
self.cp_info._read()
elif _on == self._root.ConstantPoolEntry.TagEnum.invoke_dynamic:
self.cp_info = self._root.InvokeDynamicCpInfo(self._io, self, self._root)
self.cp_info._read()
elif _on == self._root.ConstantPoolEntry.TagEnum.field_ref:
self.cp_info = self._root.FieldRefCpInfo(self._io, self, self._root)
self.cp_info._read()
elif _on == self._root.ConstantPoolEntry.TagEnum.method_handle:
self.cp_info = self._root.MethodHandleCpInfo(self._io, self, self._root)
self.cp_info._read()
elif _on == self._root.ConstantPoolEntry.TagEnum.name_and_type:
self.cp_info = self._root.NameAndTypeCpInfo(self._io, self, self._root)
self.cp_info._read()
self._debug['cp_info']['end'] = self._io.pos()
def _read(self):
self._debug['magic']['start'] = self._io.pos()
self.magic = self._io.read_bytes(2)
self._debug['magic']['end'] = self._io.pos()
if not self.magic == b"\x56\x5A":
raise kaitaistruct.ValidationNotEqualError(
b"\x56\x5A", self.magic, self._io,
u"/types/te_header/seq/0")
self._debug['machine']['start'] = self._io.pos()
self.machine = KaitaiStream.resolve_enum(
self._root.TeHeader.MachineType, self._io.read_u2le())
self._debug['machine']['end'] = self._io.pos()
self._debug['num_sections']['start'] = self._io.pos()
self.num_sections = self._io.read_u1()
self._debug['num_sections']['end'] = self._io.pos()
self._debug['subsystem']['start'] = self._io.pos()
self.subsystem = KaitaiStream.resolve_enum(
self._root.TeHeader.SubsystemEnum, self._io.read_u1())
self._debug['subsystem']['end'] = self._io.pos()
self._debug['stripped_size']['start'] = self._io.pos()
self.stripped_size = self._io.read_u2le()
self._debug['stripped_size']['end'] = self._io.pos()
self._debug['entry_point_addr']['start'] = self._io.pos()
self.entry_point_addr = self._io.read_u4le()
self._debug['entry_point_addr']['end'] = self._io.pos()
self._debug['base_of_code']['start'] = self._io.pos()
self.base_of_code = self._io.read_u4le()
self._debug['base_of_code']['end'] = self._io.pos()
self._debug['image_base']['start'] = self._io.pos()
self.image_base = self._io.read_u8le()
self._debug['image_base']['end'] = self._io.pos()
self._debug['data_dirs']['start'] = self._io.pos()
self.data_dirs = self._root.HeaderDataDirs(self._io, self,
self._root)
self.data_dirs._read()
self._debug['data_dirs']['end'] = self._io.pos()
def _read(self):
self.len_data = self._io.read_u4le()
self.type = KaitaiStream.resolve_enum(GltfBinary.ChunkType,
self._io.read_u4le())
_on = self.type
if _on == GltfBinary.ChunkType.json:
self._raw_data = self._io.read_bytes(self.len_data)
_io__raw_data = KaitaiStream(BytesIO(self._raw_data))
self.data = GltfBinary.Json(_io__raw_data, self, self._root)
elif _on == GltfBinary.ChunkType.bin:
self._raw_data = self._io.read_bytes(self.len_data)
_io__raw_data = KaitaiStream(BytesIO(self._raw_data))
self.data = GltfBinary.Bin(_io__raw_data, self, self._root)
else:
self.data = self._io.read_bytes(self.len_data)
def _read(self):
self._debug['version_magic']['start'] = self._io.pos()
self.version_magic = KaitaiStream.resolve_enum(self._root.Version,
self._io.read_u2le())
self._debug['version_magic']['end'] = self._io.pos()
self._debug['crlf']['start'] = self._io.pos()
self.crlf = self._io.read_u2le()
self._debug['crlf']['end'] = self._io.pos()
self._debug['modification_timestamp']['start'] = self._io.pos()
self.modification_timestamp = self._io.read_u4le()
self._debug['modification_timestamp']['end'] = self._io.pos()
self._debug['body']['start'] = self._io.pos()
self.body = self._root.PyObject(self._io, self, self._root)
self.body._read()
self._debug['body']['end'] = self._io.pos()
def type_as_predef(self):
"""Numeric type IDs in range of [0..0xff] are reserved for
system usage in Windows, and there are some predefined,
well-known values in that range. This instance allows to get
it as enum value, if applicable.
"""
if hasattr(self, '_m_type_as_predef'):
return self._m_type_as_predef
if ((not (self.type.is_string)) and (self.type.as_numeric <= 255)):
self._m_type_as_predef = KaitaiStream.resolve_enum(
WindowsResourceFile.Resource.PredefTypes,
self.type.as_numeric)
return getattr(self, '_m_type_as_predef', None)
def _read(self):
self._debug['block_type']['start'] = self._io.pos()
self.block_type = KaitaiStream.resolve_enum(
self._root.BlockType, self._io.read_u1())
self._debug['block_type']['end'] = self._io.pos()
self._debug['body']['start'] = self._io.pos()
_on = self.block_type
if _on == self._root.BlockType.extension:
self.body = self._root.Extension(self._io, self, self._root)
self.body._read()
elif _on == self._root.BlockType.local_image_descriptor:
self.body = self._root.LocalImageDescriptor(
self._io, self, self._root)
self.body._read()
self._debug['body']['end'] = self._io.pos()
def _read(self):
self._debug['major_brand']['start'] = self._io.pos()
self.major_brand = KaitaiStream.resolve_enum(
self._root.Brand, self._io.read_u4be())
self._debug['major_brand']['end'] = self._io.pos()
self._debug['minor_version']['start'] = self._io.pos()
self.minor_version = self._io.read_bytes(4)
self._debug['minor_version']['end'] = self._io.pos()
self._debug['compatible_brands']['start'] = self._io.pos()
self.compatible_brands = []
i = 0
while not self._io.is_eof():
if not 'arr' in self._debug['compatible_brands']:
self._debug['compatible_brands']['arr'] = []
self._debug['compatible_brands']['arr'].append(
{'start': self._io.pos()})
self.compatible_brands.append(
KaitaiStream.resolve_enum(self._root.Brand,
self._io.read_u4be()))
self._debug['compatible_brands']['arr'][
len(self.compatible_brands) - 1]['end'] = self._io.pos()
i += 1
self._debug['compatible_brands']['end'] = self._io.pos()
def _read(self):
self.enum_seq = KaitaiStream.resolve_enum(ExprBits.Items,
self._io.read_bits_int_be(2))
self.a = self._io.read_bits_int_be(3)
self._io.align_to_byte()
self.byte_size = self._io.read_bytes(self.a)
self.repeat_expr = [None] * (self.a)
for i in range(self.a):
self.repeat_expr[i] = self._io.read_s1()
_on = self.a
if _on == 2:
self.switch_on_type = self._io.read_s1()
self.switch_on_endian = ExprBits.EndianSwitch(self._io, self,
self._root)
def wire_type(self):
""""Wire type" is a part of the "key" that carries enough
information to parse value from the wire, i.e. read correct
amount of bytes, but there's not enough informaton to
interprete in unambiguously. For example, one can't clearly
distinguish 64-bit fixed-sized integers from 64-bit floats,
signed zigzag-encoded varints from regular unsigned varints,
arbitrary bytes from UTF-8 encoded strings, etc.
"""
if hasattr(self, '_m_wire_type'):
return self._m_wire_type if hasattr(self,
'_m_wire_type') else None
self._m_wire_type = KaitaiStream.resolve_enum(
GoogleProtobuf.Pair.WireTypes, (self.key.value & 7))
return self._m_wire_type if hasattr(self, '_m_wire_type') else None
def _read(self):
self._debug['data']['start'] = self._io.pos()
self.data = self._io.read_bytes(
((self._io.size() - self._io.pos()) - 8))
self._debug['data']['end'] = self._io.pos()
self._debug['type']['start'] = self._io.pos()
self.type = KaitaiStream.resolve_enum(
PharWithoutStub.SignatureType, self._io.read_u4le())
self._debug['type']['end'] = self._io.pos()
self._debug['magic']['start'] = self._io.pos()
self.magic = self._io.read_bytes(4)
self._debug['magic']['end'] = self._io.pos()
if not self.magic == b"\x47\x42\x4D\x42":
raise kaitaistruct.ValidationNotEqualError(
b"\x47\x42\x4D\x42", self.magic, self._io,
u"/types/signature/seq/2")
def _read(self):
self.chunk_type = KaitaiStream.resolve_enum(
AndroidSparse.ChunkTypes, self._io.read_u2le())
self.reserved1 = self._io.read_u2le()
self.num_body_blocks = self._io.read_u4le()
self.len_chunk = self._io.read_u4le()
if not self.len_chunk == (
(self._root.header.len_chunk_header +
self.len_body_expected)
if self.len_body_expected != -1 else self.len_chunk):
raise kaitaistruct.ValidationNotEqualError(
((self._root.header.len_chunk_header +
self.len_body_expected)
if self.len_body_expected != -1 else self.len_chunk),
self.len_chunk, self._io,
u"/types/chunk/types/chunk_header/seq/3")
def _read(self):
self._debug['reserved1']['start'] = self._io.pos()
self.reserved1 = self._io.read_bits_int_be(2)
self._debug['reserved1']['end'] = self._io.pos()
self._debug['bus_conflict']['start'] = self._io.pos()
self.bus_conflict = self._io.read_bits_int_be(1) != 0
self._debug['bus_conflict']['end'] = self._io.pos()
self._debug['prg_ram']['start'] = self._io.pos()
self.prg_ram = self._io.read_bits_int_be(1) != 0
self._debug['prg_ram']['end'] = self._io.pos()
self._debug['reserved2']['start'] = self._io.pos()
self.reserved2 = self._io.read_bits_int_be(2)
self._debug['reserved2']['end'] = self._io.pos()
self._debug['tv_system']['start'] = self._io.pos()
self.tv_system = KaitaiStream.resolve_enum(Ines.Header.F10.TvSystem, self._io.read_bits_int_be(2))
self._debug['tv_system']['end'] = self._io.pos()
def _read(self):
self._debug['lower_mapper']['start'] = self._io.pos()
self.lower_mapper = self._io.read_bits_int_be(4)
self._debug['lower_mapper']['end'] = self._io.pos()
self._debug['four_screen']['start'] = self._io.pos()
self.four_screen = self._io.read_bits_int_be(1) != 0
self._debug['four_screen']['end'] = self._io.pos()
self._debug['trainer']['start'] = self._io.pos()
self.trainer = self._io.read_bits_int_be(1) != 0
self._debug['trainer']['end'] = self._io.pos()
self._debug['has_battery_ram']['start'] = self._io.pos()
self.has_battery_ram = self._io.read_bits_int_be(1) != 0
self._debug['has_battery_ram']['end'] = self._io.pos()
self._debug['mirroring']['start'] = self._io.pos()
self.mirroring = KaitaiStream.resolve_enum(Ines.Header.F6.Mirroring, self._io.read_bits_int_be(1))
self._debug['mirroring']['end'] = self._io.pos()
def _read(self):
self._debug['public_key']['start'] = self._io.pos()
self.public_key = self._root.PublicKeyPacket(self._io, self, self._root)
self.public_key._read()
self._debug['public_key']['end'] = self._io.pos()
self._debug['string_to_key']['start'] = self._io.pos()
self.string_to_key = self._io.read_u1()
self._debug['string_to_key']['end'] = self._io.pos()
if self.string_to_key >= 254:
self._debug['symmetric_encryption_algorithm']['start'] = self._io.pos()
self.symmetric_encryption_algorithm = KaitaiStream.resolve_enum(self._root.SymmetricKeyAlgorithm, self._io.read_u1())
self._debug['symmetric_encryption_algorithm']['end'] = self._io.pos()
self._debug['secret_key']['start'] = self._io.pos()
self.secret_key = self._io.read_bytes_full()
self._debug['secret_key']['end'] = self._io.pos()
def _read(self):
self.opcode = self._io.read_bytes(1)
if not self.opcode == b"\x00":
raise kaitaistruct.ValidationNotEqualError(b"\x00", self.opcode,
self._io, u"/seq/0")
self.rrs_type = KaitaiStream.resolve_enum(
RadioRegistrationService.RrsTypes, self._io.read_u1())
self.message_length = self._io.read_u2le()
self.radio_ip = radio_ip.RadioIp(self._io)
if (self.rrs_type == RadioRegistrationService.RrsTypes.registration_ack
) or (self.rrs_type
== RadioRegistrationService.RrsTypes.online_check_ack):
self.result = self._io.read_u1()
if self.rrs_type == RadioRegistrationService.RrsTypes.registration_ack:
self.valid_time = self._io.read_u4be()
