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()