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 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_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 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 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]))
def read_record_v1(stream, filename):
return RecordV1(filename, *st_unpack('<QQQIQ20s',stream.read(56)))
