def read(self,stream): stream.seek(-44, 2) footer_offset = stream.tell() footer = stream.read(44) magic, version, index_offset, index_size, index_sha1 = st_unpack('<IIQQ20s',footer) if magic != UE4_PACKAGE_MAGIC: raise ValueError('Invalid pak file') if version != 3: raise ValueError('Unknown pak version: %d' % version) if index_offset + index_size > footer_offset: raise ValueError('Corrupt pak file') stream.seek(index_offset, 0) mount_point = self.read_string(stream) entry_count = st_unpack('<I',stream.read(4))[0] self.initialize(version, index_offset, index_size, footer_offset, index_sha1, mount_point) for i in xrange(entry_count): filename = self.read_string(stream) record = self.read_record(stream, filename) self.records.append(record) if stream.tell() > footer_offset: raise ValueError('Records exceed size')
def read(self, stream): stream.seek(-44, 2) footer_offset = stream.tell() footer = stream.read(44) magic, version, index_offset, index_size, index_sha1 = st_unpack( '<IIQQ20s', footer) if magic != UE4_PACKAGE_MAGIC: raise ValueError('Invalid pak file') if version != 3: raise ValueError('Unknown pak version: %d' % version) if index_offset + index_size > footer_offset: raise ValueError('Corrupt pak file') stream.seek(index_offset, 0) mount_point = self.read_string(stream) entry_count = st_unpack('<I', stream.read(4))[0] self.initialize(version, index_offset, index_size, footer_offset, index_sha1, mount_point) for i in xrange(entry_count): filename = self.read_string(stream) record = self.read_record(stream, filename) self.records.append(record) if stream.tell() > footer_offset: raise ValueError('Records exceed size')
def read_record_v3(stream, filename): offset, compressed_size, uncompressed_size, compression_method, sha1 = \ st_unpack('<QQQI20s',stream.read(48)) if compression_method != COMPR_NONE: block_count, = st_unpack('<I',stream.read(4)) blocks = st_unpack('<%dQ' % (block_count * 2), stream.read(16 * block_count)) blocks = [(blocks[i], blocks[i+1]) for i in xrange(0, block_count * 2, 2)] else: blocks = None encrypted, compression_block_size = st_unpack('<BI',stream.read(5)) return RecordV3(filename, offset, compressed_size, uncompressed_size, compression_method, sha1, blocks, encrypted != 0, compression_block_size)
def read_record_v3(stream, filename): offset, compressed_size, uncompressed_size, compression_method, sha1 = \ st_unpack('<QQQI20s',stream.read(48)) if compression_method != COMPR_NONE: block_count, = st_unpack('<I',stream.read(4)) blocks = st_unpack('<%dQ' % (block_count * 2), stream.read(16 * block_count)) blocks = [(blocks[i], blocks[i+1]) for i in xrange(0,block_count,2)] else: blocks = None encrypted, compression_block_size = st_unpack('<BI',stream.read(5)) return RecordV3(filename, offset, compressed_size, uncompressed_size, compression_method, sha1, blocks, encrypted != 0, compression_block_size)
def unpack(self, buf): Packet.unpack(self, buf) if self.type > 1500: # Ethernet II self._unpack_data(self.data) elif self.dst.startswith('\x01\x00\x0c\x00\x00') or \ self.dst.startswith('\x03\x00\x0c\x00\x00'): # Cisco ISL #self.vlan = st_unpack('>H', self.data[6:8])[0] self.unpack(self.data[12:]) elif self.data.startswith('\xff\xff'): # Novell "raw" 802.3 self.type = ETH_TYPE_IPX self.data = self.ipx = ipx.IPX(self.data[2:]) else: # 802.2 LLC #self.dsap, self.ssap, self.ctl = st_unpack('BBB', self.data[:3]) if self.data.startswith('\xaa\xaa'): # SNAP self.type = st_unpack('>H', self.data[6:8])[0] self._unpack_data(self.data[8:]) else: # non-SNAP dsap = ord(self.data[0]) if dsap == 0x06: # SAP_IP self.data = self.ip = ip.IP(self.data[3:]) elif dsap == 0x10 or dsap == 0xe0: # SAP_NETWARE{1,2} self.data = self.ipx = ipx.IPX(self.data[3:]) elif dsap == 0x42: # SAP_STP self.data = self.stp = stp.STP(self.data[3:])
def read_record_v4(stream, filename): offset, compressed_size, uncompressed_size, compression_method, sha1 = \ st_unpack('<QQQI20s', stream.read(48)) # sys.stdout.write('compression_method = %s\n' % compression_method) if compression_method != COMPR_NONE: block_count, = st_unpack('<I', stream.read(4)) blocks = st_unpack('<%dQ' % (block_count * 2), stream.read(16 * block_count)) blocks = [(blocks[i], blocks[i + 1]) for i in xrange(0, block_count * 2, 2)] else: blocks = None encrypted, compression_block_size, unknown = st_unpack('<BII', stream.read(9)) return RecordV4(filename, offset, compressed_size, uncompressed_size, compression_method, sha1, blocks, encrypted != 0, compression_block_size)
def read_record(self, stream, filename): # skip, we don't need extra info stream.seek(8, 1) # offset stream.seek(8, 1) # size stream.seek(8, 1) # uncompressed compression_method, = st_unpack('<I', stream.read(4)) stream.seek(20, 1) # sha1 if compression_method != 0x00: block_count, = st_unpack('<I', stream.read(4)) stream.seek(block_count * 16, 1) # compression block stream.seek(1, 1) # encrypted stream.seek(4, 1) # compression block size return Record(filename)
def read_record(self,stream, filename): # skip, we don't need extra info stream.seek(8, 1) # offset stream.seek(8, 1) # size stream.seek(8, 1) # uncompressed compression_method, = st_unpack('<I',stream.read(4)) stream.seek(20, 1) # sha1 if compression_method != 0x00: block_count, = st_unpack('<I', stream.read(4)) stream.seek(block_count * 16, 1) # compression block stream.seek(1, 1) # encrypted stream.seek(4, 1) # compression block size return Record(filename)
def _unpack_data(self, buf): if self.type == ETH_TYPE_8021Q: self.tag, self.type = st_unpack('>HH', buf[:4]) buf = buf[4:] elif self.type == ETH_TYPE_MPLS or \ self.type == ETH_TYPE_MPLS_MCAST: # XXX - skip labels for i in range(24): if st_unpack('>I', buf[i:i+4])[0] & 0x0100: # MPLS_STACK_BOTTOM break self.type = ETH_TYPE_IP buf = buf[(i + 1) * 4:] try: self.data = self._typesw[self.type](buf) setattr(self, self.data.__class__.__name__.lower(), self.data) except: self.data = buf
def capture_1sec(self): raw_data = b'' while len(raw_data) < 2 * self.audio_sampling_rate: length, data = self.inp.read() if length > 0: raw_data += data return array( st_unpack("%ih" % self.audio_sampling_rate, raw_data[:2 * self.audio_sampling_rate]))
def read_index(stream,check_integrity=False): stream.seek(-44, 2) footer_offset = stream.tell() footer = stream.read(44) magic, version, index_offset, index_size, index_sha1 = st_unpack('<IIQQ20s',footer) if magic != 0x5A6F12E1: raise ValueError('illegal file magic: 0x%08x' % magic) if version == 1: read_record = read_record_v1 elif version == 2: read_record = read_record_v2 elif version == 3: read_record = read_record_v3 elif version == 4: read_record = read_record_v4 else: raise ValueError('unsupported version: %d' % version) if index_offset + index_size > footer_offset: raise ValueError('illegal index offset/size') stream.seek(index_offset, 0) mount_point = read_path(stream) entry_count = st_unpack('<I',stream.read(4))[0] pak = Pak(version, index_offset, index_size, footer_offset, index_sha1, mount_point) for i in xrange(entry_count): filename = read_path(stream) record = read_record(stream, filename) pak.records.append(record) if stream.tell() > footer_offset: raise ValueError('index bleeds into footer') if check_integrity: pak.check_integrity(stream) return pak
def read_index(stream,check_integrity=False): stream.seek(-44, 2) footer_offset = stream.tell() footer = stream.read(44) magic, version, index_offset, index_size, index_sha1 = st_unpack('<IIQQ20s',footer) if magic != 0x5A6F12E1: raise ValueError('illegal file magic: 0x%08x' % magic) if version == 1: read_record = read_record_v1 elif version == 2: read_record = read_record_v2 elif version == 3: read_record = read_record_v3 else: raise ValueError('unsupported version: %d' % version) if index_offset + index_size > footer_offset: raise ValueError('illegal index offset/size') stream.seek(index_offset, 0) mount_point = read_path(stream) entry_count = st_unpack('<I',stream.read(4))[0] pak = Pak(version, index_offset, index_size, footer_offset, index_sha1, mount_point) for i in xrange(entry_count): filename = read_path(stream) record = read_record(stream, filename) pak.records.append(record) if stream.tell() > footer_offset: raise ValueError('index bleeds into footer') if check_integrity: pak.check_integrity(stream) return pak
def read_index(stream,check_integrity=False,ignore_magic=False,encoding='utf-8',force_version=None): stream.seek(-52, 2) footer_offset = stream.tell() footer = stream.read(52) magic, version, patch_version, index_offset, index_size, index_sha1 = st_unpack('<IIQQQ20s',footer) if not ignore_magic and magic != 0x5A6F12E1: raise ValueError('illegal file magic: 0x%08x' % magic) if force_version is not None: version = force_version if version == 4: read_record = read_record_v4 else: raise ValueError('unsupported version: %d' % version) if index_offset + index_size > footer_offset: raise ValueError('illegal index offset/size') stream.seek(index_offset, 0) mount_point = read_path(stream, encoding) entry_count = st_unpack('<I',stream.read(4))[0] pak = Pak(version, index_offset, index_size, footer_offset, index_sha1, mount_point) for i in xrange(entry_count): filename = read_path(stream, encoding) record = read_record(stream, filename) pak.records.append(record) if stream.tell() > footer_offset: raise ValueError('index bleeds into footer') if check_integrity: pak.check_integrity(stream) return pak
def read_from(fd): record_offset = fd.tell() typed = fd.read(4) if not typed: return None try: rec_type, = st_unpack("4s", typed) except: print "Fail read header at:", repr(typed) raise rc_class = RECORD_TYPES[rec_type] rec = rc_class() rec._tag = rec_type rec._file_offset = record_offset rec.read_header(fd) return rec
def capture_1sec(self): # Use a lock to avoid reentrancy with self.lock: # Since there's no way to pause capture (pause() unimplemented in alsaaudio), and we don't read continuously, we expect overruns. # Discard first buffer. This will flush the overrun and restart the acquisition chain. length, data = self.inp.read() raw_data = b'' while len(raw_data) < 2 * self.audio_sampling_rate: length, data = self.inp.read() if length < 0: print('overrun! discarding data...') raise IOError elif length == 0: print('empty read!') break # should this ever happen? elif length > 0: raw_data += data return array( st_unpack("%ih" % self.audio_sampling_rate, raw_data[:2 * self.audio_sampling_rate]))
def capture_1sec(self): raw_data = b''.join(self.capture( 1)) # self.pa_stream.read(self.audio_sampling_rate) unpacked_data = st_unpack("{}h".format(self.audio_sampling_rate), raw_data) return array(unpacked_data)
def read_record_v2(stream, filename): return RecordV2(filename, *st_unpack('<QQQI20s',stream.read(48)))
def read_path(stream): path_len, = st_unpack('<I',stream.read(4)) return stream.read(path_len).rstrip(b'\0').decode('utf-8').replace('/',os.path.sep)
def read(cls, fd): rec = cls() rec._file_offset = fd.tell() rec._tag, = st_unpack("4s", fd.read(4)) rec.read_header(fd) return rec
def read_string(self,stream): path_len, = st_unpack('<I',stream.read(4)) return stream.read(path_len).rstrip(b'\0').decode('utf-8').replace('/',os.path.sep)
def read_record_v1(stream, filename): return RecordV1(filename, *st_unpack('<QQQIQ20s',stream.read(56)))
def capture_1sec(self): raw_data = b''.join(self.capture(1)) # self.pa_stream.read(self.audio_sampling_rate) unpacked_data = st_unpack("{}h".format(self.audio_sampling_rate), raw_data) return array(unpacked_data)
def capture_1sec(self): raw_data = b'' while len(raw_data) < 2 * self.audio_sampling_rate: length,data = self.inp.read() if length> 0: raw_data += data return array(st_unpack("%ih"%self.audio_sampling_rate, raw_data[:2 * self.audio_sampling_rate]))