zip 9.1.3

Library to support the reading and writing of zip files.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! Custom extra field

use crate::result::ZipResult;
use crate::result::invalid;
use std::io::Write;

/// A Custom Extra Field
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct CustomExtraField {
    /// If true, this field will be included in the central directory entry but not the local file header.
    pub(crate) central_only: bool,
    /// Header ID of the extra field
    pub header_id: u16,
    /// Data of the extra field
    pub data: Box<[u8]>,
}

impl CustomExtraField {
    pub(crate) fn new(central_only: bool, header_id: u16, data: Box<[u8]>) -> Self {
        Self {
            central_only,
            header_id,
            data,
        }
    }

    #[allow(unused)] // used for tests
    pub(crate) fn new_from_raw(central_only: bool, data: &[u8]) -> ZipResult<Self> {
        if data.len() < 2 {
            return Err(invalid!("Cannot build a CustomExtraField: no header_id"));
        }
        if data.len() < 4 {
            return Err(invalid!("Cannot build a CustomExtraField: no size"));
        }
        let header_id = u16::from_le_bytes([data[0], data[1]]);
        let size = u16::from_le_bytes([data[2], data[3]]) as usize;
        if size > (u16::MAX - 4) as usize {
            return Err(invalid!("Cannot build a CustomExtraField: size too big"));
        }
        let data_rest = &data[4..];
        if size != data_rest.len() {
            return Err(invalid!("Cannot build a CustomExtraField: incorrect size"));
        }
        Ok(Self {
            central_only,
            header_id,
            data: data_rest.to_vec().into_boxed_slice(),
        })
    }

    pub(crate) fn full_size(&self, is_local_header: bool) -> usize {
        if self.central_only && is_local_header {
            return 0;
        }
        let size = self.data.len();
        size_of::<u16>() + size_of::<u16>() + size
    }

    pub(crate) fn write<W: Write>(&self, write: &mut W, is_local_header: bool) -> ZipResult<()> {
        if self.central_only && is_local_header {
            return Ok(());
        }
        write.write_all(&self.header_id.to_le_bytes())?;
        let size = self.data.len() as u16;
        write.write_all(&size.to_le_bytes())?;
        write.write_all(&self.data)?;
        Ok(())
    }
}

#[cfg(feature = "_arbitrary")]
impl arbitrary::Arbitrary<'_> for CustomExtraField {
    fn arbitrary(u: &mut arbitrary::Unstructured<'_>) -> arbitrary::Result<Self> {
        use crate::ExtraField;
        use crate::format::blocks::{Pod, ZipLocalEntryBlock};
        use std::io::Cursor;
        let extra_field = CustomExtraField {
            central_only: u.arbitrary()?,
            header_id: u.arbitrary()?,
            data: u.arbitrary()?,
        };
        let mut serialized_extra_field = Vec::with_capacity(extra_field.data.len() + 4);
        if extra_field
            .write(&mut serialized_extra_field, true)
            .is_err()
        {
            return Err(arbitrary::Error::IncorrectFormat);
        }
        let block = ZipLocalEntryBlock::zeroed();
        if ExtraField::parse(&mut Cursor::new(&serialized_extra_field), &block, true).is_err() {
            Err(arbitrary::Error::IncorrectFormat)
        } else {
            Ok(extra_field)
        }
    }
}