compression_codecs/gzip/
header.rs

1use compression_core::util::PartialBuffer;
2use std::io;
3
4#[derive(Debug, Default)]
5struct Flags {
6    _ascii: bool,
7    crc: bool,
8    extra: bool,
9    filename: bool,
10    comment: bool,
11}
12
13#[derive(Debug, Default)]
14pub(super) struct Header {
15    flags: Flags,
16}
17
18#[derive(Debug)]
19enum State {
20    Fixed(PartialBuffer<[u8; 10]>),
21    ExtraLen(PartialBuffer<[u8; 2]>),
22    Extra(PartialBuffer<Vec<u8>>),
23    Filename(Vec<u8>),
24    Comment(Vec<u8>),
25    Crc(PartialBuffer<[u8; 2]>),
26    Done,
27}
28
29impl Default for State {
30    fn default() -> Self {
31        State::Fixed(<_>::default())
32    }
33}
34
35#[derive(Debug, Default)]
36pub(super) struct Parser {
37    state: State,
38    header: Header,
39}
40
41impl Header {
42    fn parse(input: &[u8; 10]) -> io::Result<Self> {
43        if input[0..3] != [0x1f, 0x8b, 0x08] {
44            return Err(io::Error::new(
45                io::ErrorKind::InvalidData,
46                "Invalid gzip header",
47            ));
48        }
49
50        let flag = input[3];
51
52        let flags = Flags {
53            _ascii: (flag & 0b0000_0001) != 0,
54            crc: (flag & 0b0000_0010) != 0,
55            extra: (flag & 0b0000_0100) != 0,
56            filename: (flag & 0b0000_1000) != 0,
57            comment: (flag & 0b0001_0000) != 0,
58        };
59
60        Ok(Header { flags })
61    }
62}
63
64impl Parser {
65    pub(super) fn input(&mut self, input: &mut PartialBuffer<&[u8]>) -> io::Result<Option<Header>> {
66        loop {
67            match &mut self.state {
68                State::Fixed(data) => {
69                    data.copy_unwritten_from(input);
70
71                    if data.unwritten().is_empty() {
72                        self.header = Header::parse(&data.take().into_inner())?;
73                        self.state = State::ExtraLen(<_>::default());
74                    } else {
75                        return Ok(None);
76                    }
77                }
78
79                State::ExtraLen(data) => {
80                    if !self.header.flags.extra {
81                        self.state = State::Filename(<_>::default());
82                        continue;
83                    }
84
85                    data.copy_unwritten_from(input);
86
87                    if data.unwritten().is_empty() {
88                        let len = u16::from_le_bytes(data.take().into_inner());
89                        self.state = State::Extra(vec![0; usize::from(len)].into());
90                    } else {
91                        return Ok(None);
92                    }
93                }
94
95                State::Extra(data) => {
96                    data.copy_unwritten_from(input);
97
98                    if data.unwritten().is_empty() {
99                        self.state = State::Filename(<_>::default());
100                    } else {
101                        return Ok(None);
102                    }
103                }
104
105                State::Filename(data) => {
106                    if !self.header.flags.filename {
107                        self.state = State::Comment(<_>::default());
108                        continue;
109                    }
110
111                    if let Some(len) = memchr::memchr(0, input.unwritten()) {
112                        data.extend_from_slice(&input.unwritten()[..len]);
113                        input.advance(len + 1);
114                        self.state = State::Comment(<_>::default());
115                    } else {
116                        data.extend_from_slice(input.unwritten());
117                        input.advance(input.unwritten().len());
118                        return Ok(None);
119                    }
120                }
121
122                State::Comment(data) => {
123                    if !self.header.flags.comment {
124                        self.state = State::Crc(<_>::default());
125                        continue;
126                    }
127
128                    if let Some(len) = memchr::memchr(0, input.unwritten()) {
129                        data.extend_from_slice(&input.unwritten()[..len]);
130                        input.advance(len + 1);
131                        self.state = State::Crc(<_>::default());
132                    } else {
133                        data.extend_from_slice(input.unwritten());
134                        input.advance(input.unwritten().len());
135                        return Ok(None);
136                    }
137                }
138
139                State::Crc(data) => {
140                    if !self.header.flags.crc {
141                        self.state = State::Done;
142                        return Ok(Some(std::mem::take(&mut self.header)));
143                    }
144
145                    data.copy_unwritten_from(input);
146
147                    if data.unwritten().is_empty() {
148                        self.state = State::Done;
149                        return Ok(Some(std::mem::take(&mut self.header)));
150                    } else {
151                        return Ok(None);
152                    }
153                }
154
155                State::Done => {
156                    return Err(io::Error::other("parser used after done"));
157                }
158            };
159        }
160    }
161}
compression_codecs/gzip/header.rs

compression_codecs/gzip/
header.rs
