///|
pub struct LocalFileHeader {
signature : UInt
version_needed : UInt16
flags : UInt16
compression_method : CompressionMethod
last_mod_time : UInt16
last_mod_date : UInt16
crc32 : UInt
compressed_size : UInt
uncompressed_size : UInt
filename_length : UInt16
extra_field_length : UInt16
filename : String
extra_field : Bytes
}
///|
pub struct EndOfCentralDirectoryRecord {
signature : UInt
disk_number : UInt16
cd_start_disk : UInt16
cd_entries_on_disk : UInt16
cd_entries_total : UInt16
cd_size : UInt
cd_offset : UInt
comment_length : UInt16
comment : String
}
///|
pub struct BitReader {
data : Bytes
mut pos : Int
mut bit_pos : Int
}
///|
fn BitReader::new(data : Bytes) -> BitReader {
BitReader::{ data, pos: 0, bit_pos: 0 }
}
///|
fn BitReader::read_bits(self : BitReader, n : Int) -> UInt {
if n <= 0 {
0
} else {
let mut result : UInt = 0
let mut remaining : Int = n
let mut shift : Int = 0
while remaining > 0 {
if self.pos >= self.data.length() {
return result
} else {
let byte : UInt = self.data[self.pos].to_uint()
let bits_in_byte : Int = 8 - self.bit_pos
let take : Int = if remaining < bits_in_byte {
remaining
} else {
bits_in_byte
}
let mask : UInt = (1 << take) - 1
let value : UInt = (byte >> self.bit_pos) & mask
result = result | (value << shift)
shift = shift + take
self.bit_pos = self.bit_pos + take
if self.bit_pos >= 8 {
self.bit_pos = 0
self.pos = self.pos + 1
}
remaining = remaining - take
}
}
result
}
}
///|
fn BitReader::align_to_byte(self : BitReader) -> Unit {
if self.bit_pos != 0 {
self.bit_pos = 0
self.pos = self.pos + 1
}
}
///|
fn BitReader::read_bytes(self : BitReader, n : Int) -> Bytes {
let start : Int = self.pos
let end : Int = if start + n <= self.data.length() {
start + n
} else {
self.data.length()
}
self.pos = end
match self.data.get_view(start~, end~) {
None => Bytes::new(0)
Some(v) => v.to_owned()
}
}
///|
pub struct HuffmanTree {
codes : Array[Int]
lengths : Array[Int]
max_code_len : Int
}
///|
fn HuffmanTree::new(code_lengths : Array[Int], max_code : Int) -> HuffmanTree {
let len : Int = max_code + 1
let codes : Array[Int] = Array::make(len, 0)
let lengths : Array[Int] = Array::make(len, 0)
let mut max_code_len : Int = 0
for i in 0.. max_code_len {
max_code_len = code_lengths[i]
}
}
if max_code_len > 0 {
let bl_count : Array[Int] = Array::make(max_code_len + 1, 0)
for i in 0.. 0 {
bl_count[code_lengths[i]] = bl_count[code_lengths[i]] + 1
}
}
let next_code : Array[Int] = Array::make(max_code_len + 1, 0)
let mut code : Int = 0
for bits in 1..<=max_code_len {
code = (code + bl_count[bits - 1]) << 1
next_code[bits] = code
}
for n in 0.. 0 {
codes[n] = next_code[l]
next_code[l] = next_code[l] + 1
}
}
}
HuffmanTree::{ codes, lengths, max_code_len }
}
///|
fn HuffmanTree::decode(self : HuffmanTree, br : BitReader) -> Int {
let mut bits : UInt = 0
let mut len : Int = 0
while len < self.max_code_len {
bits = (bits << 1) | br.read_bits(1)
len = len + 1
for i in 0.. Bool {
let bfinal : Int = br.read_bits(1).reinterpret_as_int()
let btype : Int = br.read_bits(2).reinterpret_as_int()
if btype == 0 {
br.align_to_byte()
let len : UInt16 = br.read_bits(16).to_uint16()
let nlen : UInt16 = br.read_bits(16).to_uint16()
if (len ^ 0xFFFF) != nlen {
false
} else {
let data : Bytes = br.read_bytes(len.to_int())
for b in data.iter() {
result.push(b)
}
bfinal != 0
}
} else if btype == 1 || btype == 2 {
let literal_len_count : Int = if btype == 1 { 288 } else { 286 }
let dist_count : Int = if btype == 1 { 32 } else { 30 }
let literal_code_lengths : Array[Int] = Array::make(literal_len_count, 0)
let dist_code_lengths : Array[Int] = Array::make(dist_count, 0)
if btype == 2 {
let hlit : Int = br.read_bits(5).reinterpret_as_int() + 257
let hdist : Int = br.read_bits(5).reinterpret_as_int() + 1
let hclen : Int = br.read_bits(4).reinterpret_as_int() + 4
let code_length_code_lengths : Array[Int] = Array::make(19, 0)
let order : Array[Int] = [
16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15,
]
for i in 0.. 0 {
if pos <= hlit {
literal_code_lengths[pos - 1]
} else {
dist_code_lengths[pos - hlit - 1]
}
} else {
0
}
for _ in 0..= 0 && i <= 143 {
literal_code_lengths[i] = 8
} else if i >= 144 && i <= 255 {
literal_code_lengths[i] = 9
} else if i >= 256 && i <= 279 {
literal_code_lengths[i] = 7
} else {
literal_code_lengths[i] = 8
}
}
for i in 0..<32 {
dist_code_lengths[i] = 5
}
}
let literal_tree : HuffmanTree = HuffmanTree::new(
literal_code_lengths,
literal_len_count - 1,
)
let dist_tree : HuffmanTree = HuffmanTree::new(
dist_code_lengths,
dist_count - 1,
)
let keep_going : Bool = true
while keep_going {
let code : Int = literal_tree.decode(br)
if code == -1 {
return false
} else if code == 256 {
return bfinal != 0
} else if code < 256 {
result.push(code.to_byte())
} else {
let len_code : Int = code - 257
let length : Int = if len_code < 4 {
len_code + 3
} else if len_code == 27 {
258
} else {
let extra_bits : Int = (len_code >> 2) - 1
let base : Int = (len_code & 3) + 4
(base << extra_bits) +
3 +
br.read_bits(extra_bits).reinterpret_as_int()
}
let dist_code : Int = dist_tree.decode(br)
if dist_code == -1 {
return false
} else {
let dist : Int = if dist_code < 4 {
dist_code + 1
} else {
let extra_bits : Int = (dist_code >> 1) - 1
let base : Int = (2 + (dist_code & 1)) << extra_bits
base + 1 + br.read_bits(extra_bits).reinterpret_as_int()
}
let start : Int = result.length() - dist
for i in 0..= 0 && idx < result.length() {
result.push(result[idx])
}
}
}
}
}
true
} else {
false
}
}
///|
fn read_u16(data : Bytes, offset : Int) -> UInt16 {
if offset + 1 >= data.length() {
0
} else {
data[offset].to_uint16() | (data[offset + 1].to_uint16() << 8)
}
}
///|
fn read_u32(data : Bytes, offset : Int) -> UInt {
if offset + 4 > data.length() {
0
} else {
data[offset].to_uint() |
(data[offset + 1].to_uint() << 8) |
(data[offset + 2].to_uint() << 16) |
(data[offset + 3].to_uint() << 24)
}
}
///|
fn parse_compression_method(method_val : UInt16) -> CompressionMethod {
match method_val {
0 => CompressionMethod::Stored
8 => CompressionMethod::Deflated
m => CompressionMethod::Unsupported(m)
}
}
///|
fn parse_local_file_header(data : Bytes, offset : Int) -> LocalFileHeader? {
if offset + 30 > data.length() {
None
} else {
let signature : UInt = read_u32(data, offset)
if signature != 0x04034B50 {
None
} else {
let version_needed : UInt16 = read_u16(data, offset + 4)
let flags : UInt16 = read_u16(data, offset + 6)
let compression_method : CompressionMethod = parse_compression_method(
read_u16(data, offset + 8),
)
let last_mod_time : UInt16 = read_u16(data, offset + 10)
let last_mod_date : UInt16 = read_u16(data, offset + 12)
let crc32 : UInt = read_u32(data, offset + 14)
let compressed_size : UInt = read_u32(data, offset + 18)
let uncompressed_size : UInt = read_u32(data, offset + 22)
let filename_length : UInt16 = read_u16(data, offset + 26)
let extra_field_length : UInt16 = read_u16(data, offset + 28)
let header_size : Int = 30 +
filename_length.to_int() +
extra_field_length.to_int()
if offset + header_size > data.length() {
None
} else {
let filename_view = data.get_view(
start=offset + 30,
end=offset + 30 + filename_length.to_int(),
)
let extra_field_view = data.get_view(
start=offset + 30 + filename_length.to_int(),
end=offset + header_size,
)
match (filename_view, extra_field_view) {
(Some(fv), Some(ev)) =>
Some(LocalFileHeader::{
signature,
version_needed,
flags,
compression_method,
last_mod_time,
last_mod_date,
crc32,
compressed_size,
uncompressed_size,
filename_length,
extra_field_length,
filename: @utf8.decode_lossy(fv),
extra_field: ev.to_owned(),
})
_ => None
}
}
}
}
}
///|
fn parse_central_directory_file_header(
data : Bytes,
offset : Int,
) -> CentralDirectoryFileHeader? {
if offset + 46 > data.length() {
None
} else {
let signature : UInt = read_u32(data, offset)
if signature != 0x02014B50 {
None
} else {
let version_made_by : UInt16 = read_u16(data, offset + 4)
let version_needed : UInt16 = read_u16(data, offset + 6)
let flags : UInt16 = read_u16(data, offset + 8)
let compression_method : CompressionMethod = parse_compression_method(
read_u16(data, offset + 10),
)
let last_mod_time : UInt16 = read_u16(data, offset + 12)
let last_mod_date : UInt16 = read_u16(data, offset + 14)
let crc32 : UInt = read_u32(data, offset + 16)
let compressed_size : UInt = read_u32(data, offset + 20)
let uncompressed_size : UInt = read_u32(data, offset + 24)
let filename_length : UInt16 = read_u16(data, offset + 28)
let extra_field_length : UInt16 = read_u16(data, offset + 30)
let comment_length : UInt16 = read_u16(data, offset + 32)
let disk_number_start : UInt16 = read_u16(data, offset + 34)
let internal_file_attrs : UInt16 = read_u16(data, offset + 36)
let external_file_attrs : UInt = read_u32(data, offset + 38)
let local_header_offset : UInt = read_u32(data, offset + 42)
let header_size : Int = 46 +
filename_length.to_int() +
extra_field_length.to_int() +
comment_length.to_int()
if offset + header_size > data.length() {
None
} else {
let filename_view = data.get_view(
start=offset + 46,
end=offset + 46 + filename_length.to_int(),
)
let extra_field_view = data.get_view(
start=offset + 46 + filename_length.to_int(),
end=offset +
46 +
filename_length.to_int() +
extra_field_length.to_int(),
)
let comment_view = data.get_view(
start=offset +
46 +
filename_length.to_int() +
extra_field_length.to_int(),
end=offset + header_size,
)
match (filename_view, extra_field_view, comment_view) {
(Some(fv), Some(ev), Some(cv)) =>
Some(CentralDirectoryFileHeader::{
signature,
version_made_by,
version_needed,
flags,
compression_method,
last_mod_time,
last_mod_date,
crc32,
compressed_size,
uncompressed_size,
filename_length,
extra_field_length,
comment_length,
disk_number_start,
internal_file_attrs,
external_file_attrs,
local_header_offset,
filename: @utf8.decode_lossy(fv),
extra_field: ev.to_owned(),
comment: @utf8.decode_lossy(cv),
})
_ => None
}
}
}
}
}
///|
fn parse_end_of_central_directory_record(
data : Bytes,
) -> EndOfCentralDirectoryRecord? {
let len : Int = data.length()
if len < 22 {
return None
}
let mut offset : Int = if len > 65536 + 22 { len - 65536 - 22 } else { 0 }
while offset <= len - 22 {
if read_u32(data, offset) == 0x06054B50 {
let comment_length : UInt16 = read_u16(data, offset + 20)
if offset + 22 + comment_length.to_int() == len {
let signature : UInt = read_u32(data, offset)
let disk_number : UInt16 = read_u16(data, offset + 4)
let cd_start_disk : UInt16 = read_u16(data, offset + 6)
let cd_entries_on_disk : UInt16 = read_u16(data, offset + 8)
let cd_entries_total : UInt16 = read_u16(data, offset + 10)
let cd_size : UInt = read_u32(data, offset + 12)
let cd_offset : UInt = read_u32(data, offset + 16)
let comment_view = data.get_view(
start=offset + 22,
end=offset + 22 + comment_length.to_int(),
)
match comment_view {
Some(cv) =>
return Some(EndOfCentralDirectoryRecord::{
signature,
disk_number,
cd_start_disk,
cd_entries_on_disk,
cd_entries_total,
cd_size,
cd_offset,
comment_length,
comment: @utf8.decode_lossy(cv),
})
None => ()
}
}
}
offset = offset + 1
}
None
}