139 lines
3.7 KiB
Rust
139 lines
3.7 KiB
Rust
use std::io::{Cursor, Write};
|
|
|
|
use androscalpel_serializer::{ReadSeek, Result, Serializable};
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub enum ExtraField {
|
|
Zip64(Zip64ExtraField),
|
|
Generic(GenericExtraField),
|
|
}
|
|
|
|
impl ExtraField {
|
|
fn to_generic(&self) -> Result<GenericExtraField> {
|
|
match self {
|
|
Self::Zip64(field) => field.to_generic_field(),
|
|
Self::Generic(field) => Ok(field.clone()),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Serializable for ExtraField {
|
|
fn serialize(&self, output: &mut dyn Write) -> Result<()> {
|
|
self.to_generic()?.serialize(output)
|
|
}
|
|
|
|
fn deserialize(input: &mut dyn ReadSeek) -> Result<Self> {
|
|
Ok(Self::Generic(GenericExtraField::deserialize(input)?))
|
|
|
|
/*
|
|
match field.id {
|
|
Zip64ExtraField::ID => Ok(Self::Zip64(Zip64ExtraField::from_generic(&field)?)),
|
|
_ => Ok(Self::Generic(field)),
|
|
}
|
|
*/
|
|
}
|
|
|
|
fn size(&self) -> usize {
|
|
self.to_generic().unwrap().size()
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct Zip64ExtraField {
|
|
pub original_size: Option<u64>,
|
|
pub compressed_size: Option<u64>,
|
|
pub offset_header: Option<u64>,
|
|
pub disk_number: Option<u32>,
|
|
}
|
|
|
|
impl Zip64ExtraField {
|
|
pub const ID: u16 = 0x0001;
|
|
fn to_generic_field(&self) -> Result<GenericExtraField> {
|
|
let mut data = Cursor::new(Vec::<u8>::new());
|
|
if let Some(original_size) = self.original_size {
|
|
original_size.serialize(&mut data)?;
|
|
}
|
|
if let Some(compressed_size) = self.compressed_size {
|
|
compressed_size.serialize(&mut data)?;
|
|
}
|
|
if let Some(offset_header) = self.offset_header {
|
|
offset_header.serialize(&mut data)?;
|
|
}
|
|
if let Some(disk_number) = self.disk_number {
|
|
disk_number.serialize(&mut data)?;
|
|
}
|
|
|
|
Ok(GenericExtraField {
|
|
id: Self::ID,
|
|
data: data.into_inner(),
|
|
})
|
|
}
|
|
|
|
pub fn from_generic(
|
|
field: &GenericExtraField,
|
|
original_size: bool,
|
|
compressed_size: bool,
|
|
offset_header: bool,
|
|
disk_number: bool,
|
|
) -> Result<Self> {
|
|
assert_eq!(field.id, Self::ID);
|
|
let mut data = Cursor::new(&field.data);
|
|
let original_size = if original_size {
|
|
Some(u64::deserialize(&mut data)?)
|
|
} else {
|
|
None
|
|
};
|
|
let compressed_size = if compressed_size {
|
|
Some(u64::deserialize(&mut data)?)
|
|
} else {
|
|
None
|
|
};
|
|
let offset_header = if offset_header {
|
|
Some(u64::deserialize(&mut data)?)
|
|
} else {
|
|
None
|
|
};
|
|
let disk_number = if disk_number {
|
|
Some(u32::deserialize(&mut data)?)
|
|
} else {
|
|
None
|
|
};
|
|
Ok(Self {
|
|
original_size,
|
|
compressed_size,
|
|
offset_header,
|
|
disk_number,
|
|
})
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct GenericExtraField {
|
|
pub id: u16,
|
|
pub data: Vec<u8>,
|
|
}
|
|
|
|
impl Serializable for GenericExtraField {
|
|
fn serialize(&self, output: &mut dyn Write) -> Result<()> {
|
|
self.id.serialize(output)?;
|
|
(self.data.len() as u16).serialize(output)?;
|
|
for c in &self.data {
|
|
c.serialize(output)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn deserialize(input: &mut dyn ReadSeek) -> Result<Self> {
|
|
let id = u16::deserialize(input)?;
|
|
let data_size = u16::deserialize(input)?;
|
|
let mut data = vec![];
|
|
for _ in 0..data_size {
|
|
data.push(u8::deserialize(input)?);
|
|
}
|
|
Ok(Self { id, data })
|
|
}
|
|
|
|
fn size(&self) -> usize {
|
|
4 + self.data.len()
|
|
}
|
|
}
|