chrono/offset/local/tz_info/
parser.rs

Help
1use std::io::{self, ErrorKind};
2use std::iter;
3use std::num::ParseIntError;
4use std::str::{self, FromStr};
5
6use super::Error;
7use super::rule::TransitionRule;
8use super::timezone::{LeapSecond, LocalTimeType, TimeZone, Transition};
9
10pub(super) fn parse(bytes: &[u8]) -> Result<TimeZone, Error> {
11    let mut cursor = Cursor::new(bytes);
12    let state = State::new(&mut cursor, true)?;
13    let (state, footer) = match state.header.version {
14        Version::V1 => match cursor.is_empty() {
15            true => (state, None),
16            false => {
17                return Err(Error::InvalidTzFile("remaining data after end of TZif v1 data block"));
18            }
19        },
20        Version::V2 | Version::V3 => {
21            let state = State::new(&mut cursor, false)?;
22            (state, Some(cursor.remaining()))
23        }
24    };
25
26    let mut transitions = Vec::with_capacity(state.header.transition_count);
27    for (arr_time, &local_time_type_index) in
28        state.transition_times.chunks_exact(state.time_size).zip(state.transition_types)
29    {
30        let unix_leap_time =
31            state.parse_time(&arr_time[0..state.time_size], state.header.version)?;
32        let local_time_type_index = local_time_type_index as usize;
33        transitions.push(Transition::new(unix_leap_time, local_time_type_index));
34    }
35
36    let mut local_time_types = Vec::with_capacity(state.header.type_count);
37    for arr in state.local_time_types.chunks_exact(6) {
38        let ut_offset = read_be_i32(&arr[..4])?;
39
40        let is_dst = match arr[4] {
41            0 => false,
42            1 => true,
43            _ => return Err(Error::InvalidTzFile("invalid DST indicator")),
44        };
45
46        let char_index = arr[5] as usize;
47        if char_index >= state.header.char_count {
48            return Err(Error::InvalidTzFile("invalid time zone name char index"));
49        }
50
51        let position = match state.names[char_index..].iter().position(|&c| c == b'\0') {
52            Some(position) => position,
53            None => return Err(Error::InvalidTzFile("invalid time zone name char index")),
54        };
55
56        let name = &state.names[char_index..char_index + position];
57        let name = if !name.is_empty() { Some(name) } else { None };
58        local_time_types.push(LocalTimeType::new(ut_offset, is_dst, name)?);
59    }
60
61    let mut leap_seconds = Vec::with_capacity(state.header.leap_count);
62    for arr in state.leap_seconds.chunks_exact(state.time_size + 4) {
63        let unix_leap_time = state.parse_time(&arr[0..state.time_size], state.header.version)?;
64        let correction = read_be_i32(&arr[state.time_size..state.time_size + 4])?;
65        leap_seconds.push(LeapSecond::new(unix_leap_time, correction));
66    }
67
68    let std_walls_iter = state.std_walls.iter().copied().chain(iter::repeat(0));
69    let ut_locals_iter = state.ut_locals.iter().copied().chain(iter::repeat(0));
70    if std_walls_iter.zip(ut_locals_iter).take(state.header.type_count).any(|pair| pair == (0, 1)) {
71        return Err(Error::InvalidTzFile(
72            "invalid couple of standard/wall and UT/local indicators",
73        ));
74    }
75
76    let extra_rule = match footer {
77        Some(footer) => {
78            let footer = str::from_utf8(footer)?;
79            if !(footer.starts_with('\n') && footer.ends_with('\n')) {
80                return Err(Error::InvalidTzFile("invalid footer"));
81            }
82
83            let tz_string = footer.trim_matches(|c: char| c.is_ascii_whitespace());
84            if tz_string.starts_with(':') || tz_string.contains('\0') {
85                return Err(Error::InvalidTzFile("invalid footer"));
86            }
87
88            match tz_string.is_empty() {
89                true => None,
90                false => Some(TransitionRule::from_tz_string(
91                    tz_string.as_bytes(),
92                    state.header.version == Version::V3,
93                )?),
94            }
95        }
96        None => None,
97    };
98
99    TimeZone::new(transitions, local_time_types, leap_seconds, extra_rule)
100}
101
102/// TZif data blocks
103struct State<'a> {
104    header: Header,
105    /// Time size in bytes
106    time_size: usize,
107    /// Transition times data block
108    transition_times: &'a [u8],
109    /// Transition types data block
110    transition_types: &'a [u8],
111    /// Local time types data block
112    local_time_types: &'a [u8],
113    /// Time zone names data block
114    names: &'a [u8],
115    /// Leap seconds data block
116    leap_seconds: &'a [u8],
117    /// UT/local indicators data block
118    std_walls: &'a [u8],
119    /// Standard/wall indicators data block
120    ut_locals: &'a [u8],
121}
122
123impl<'a> State<'a> {
124    /// Read TZif data blocks
125    fn new(cursor: &mut Cursor<'a>, first: bool) -> Result<Self, Error> {
126        let header = Header::new(cursor)?;
127        let time_size = match first {
128            true => 4, // We always parse V1 first
129            false => 8,
130        };
131
132        Ok(Self {
133            time_size,
134            transition_times: cursor.read_exact(header.transition_count * time_size)?,
135            transition_types: cursor.read_exact(header.transition_count)?,
136            local_time_types: cursor.read_exact(header.type_count * 6)?,
137            names: cursor.read_exact(header.char_count)?,
138            leap_seconds: cursor.read_exact(header.leap_count * (time_size + 4))?,
139            std_walls: cursor.read_exact(header.std_wall_count)?,
140            ut_locals: cursor.read_exact(header.ut_local_count)?,
141            header,
142        })
143    }
144
145    /// Parse time values
146    fn parse_time(&self, arr: &[u8], version: Version) -> Result<i64, Error> {
147        match version {
148            Version::V1 => Ok(read_be_i32(&arr[..4])?.into()),
149            Version::V2 | Version::V3 => read_be_i64(arr),
150        }
151    }
152}
153
154/// TZif header
155#[derive(Debug)]
156struct Header {
157    /// TZif version
158    version: Version,
159    /// Number of UT/local indicators
160    ut_local_count: usize,
161    /// Number of standard/wall indicators
162    std_wall_count: usize,
163    /// Number of leap-second records
164    leap_count: usize,
165    /// Number of transition times
166    transition_count: usize,
167    /// Number of local time type records
168    type_count: usize,
169    /// Number of time zone names bytes
170    char_count: usize,
171}
172
173impl Header {
174    fn new(cursor: &mut Cursor) -> Result<Self, Error> {
175        let magic = cursor.read_exact(4)?;
176        if magic != *b"TZif" {
177            return Err(Error::InvalidTzFile("invalid magic number"));
178        }
179
180        let version = match cursor.read_exact(1)? {
181            [0x00] => Version::V1,
182            [0x32] => Version::V2,
183            [0x33] => Version::V3,
184            _ => return Err(Error::UnsupportedTzFile("unsupported TZif version")),
185        };
186
187        cursor.read_exact(15)?;
188        let ut_local_count = cursor.read_be_u32()?;
189        let std_wall_count = cursor.read_be_u32()?;
190        let leap_count = cursor.read_be_u32()?;
191        let transition_count = cursor.read_be_u32()?;
192        let type_count = cursor.read_be_u32()?;
193        let char_count = cursor.read_be_u32()?;
194
195        if !(type_count != 0
196            && char_count != 0
197            && (ut_local_count == 0 || ut_local_count == type_count)
198            && (std_wall_count == 0 || std_wall_count == type_count))
199        {
200            return Err(Error::InvalidTzFile("invalid header"));
201        }
202
203        Ok(Self {
204            version,
205            ut_local_count: ut_local_count as usize,
206            std_wall_count: std_wall_count as usize,
207            leap_count: leap_count as usize,
208            transition_count: transition_count as usize,
209            type_count: type_count as usize,
210            char_count: char_count as usize,
211        })
212    }
213}
214
215/// A `Cursor` contains a slice of a buffer and a read count.
216#[derive(Debug, Eq, PartialEq)]
217pub(crate) struct Cursor<'a> {
218    /// Slice representing the remaining data to be read
219    remaining: &'a [u8],
220    /// Number of already read bytes
221    read_count: usize,
222}
223
224impl<'a> Cursor<'a> {
225    /// Construct a new `Cursor` from remaining data
226    pub(crate) const fn new(remaining: &'a [u8]) -> Self {
227        Self { remaining, read_count: 0 }
228    }
229
230    pub(crate) fn peek(&self) -> Option<&u8> {
231        self.remaining().first()
232    }
233
234    /// Returns remaining data
235    pub(crate) const fn remaining(&self) -> &'a [u8] {
236        self.remaining
237    }
238
239    /// Returns `true` if data is remaining
240    pub(crate) const fn is_empty(&self) -> bool {
241        self.remaining.is_empty()
242    }
243
244    pub(crate) fn read_be_u32(&mut self) -> Result<u32, Error> {
245        let mut buf = [0; 4];
246        buf.copy_from_slice(self.read_exact(4)?);
247        Ok(u32::from_be_bytes(buf))
248    }
249
250    #[cfg(target_env = "ohos")]
251    pub(crate) fn seek_after(&mut self, offset: usize) -> Result<usize, io::Error> {
252        if offset < self.read_count {
253            return Err(io::Error::from(ErrorKind::UnexpectedEof));
254        }
255        match self.remaining.get((offset - self.read_count)..) {
256            Some(remaining) => {
257                self.remaining = remaining;
258                self.read_count = offset;
259                Ok(offset)
260            }
261            _ => Err(io::Error::from(ErrorKind::UnexpectedEof)),
262        }
263    }
264
265    /// Read exactly `count` bytes, reducing remaining data and incrementing read count
266    pub(crate) fn read_exact(&mut self, count: usize) -> Result<&'a [u8], io::Error> {
267        match (self.remaining.get(..count), self.remaining.get(count..)) {
268            (Some(result), Some(remaining)) => {
269                self.remaining = remaining;
270                self.read_count += count;
271                Ok(result)
272            }
273            _ => Err(io::Error::from(ErrorKind::UnexpectedEof)),
274        }
275    }
276
277    /// Read bytes and compare them to the provided tag
278    pub(crate) fn read_tag(&mut self, tag: &[u8]) -> Result<(), io::Error> {
279        if self.read_exact(tag.len())? == tag {
280            Ok(())
281        } else {
282            Err(io::Error::from(ErrorKind::InvalidData))
283        }
284    }
285
286    /// Read bytes if the remaining data is prefixed by the provided tag
287    pub(crate) fn read_optional_tag(&mut self, tag: &[u8]) -> Result<bool, io::Error> {
288        if self.remaining.starts_with(tag) {
289            self.read_exact(tag.len())?;
290            Ok(true)
291        } else {
292            Ok(false)
293        }
294    }
295
296    /// Read bytes as long as the provided predicate is true
297    pub(crate) fn read_while<F: Fn(&u8) -> bool>(&mut self, f: F) -> Result<&'a [u8], io::Error> {
298        match self.remaining.iter().position(|x| !f(x)) {
299            None => self.read_exact(self.remaining.len()),
300            Some(position) => self.read_exact(position),
301        }
302    }
303
304    // Parse an integer out of the ASCII digits
305    pub(crate) fn read_int<T: FromStr<Err = ParseIntError>>(&mut self) -> Result<T, Error> {
306        let bytes = self.read_while(u8::is_ascii_digit)?;
307        Ok(str::from_utf8(bytes)?.parse()?)
308    }
309
310    /// Read bytes until the provided predicate is true
311    pub(crate) fn read_until<F: Fn(&u8) -> bool>(&mut self, f: F) -> Result<&'a [u8], io::Error> {
312        match self.remaining.iter().position(f) {
313            None => self.read_exact(self.remaining.len()),
314            Some(position) => self.read_exact(position),
315        }
316    }
317}
318
319pub(crate) fn read_be_i32(bytes: &[u8]) -> Result<i32, Error> {
320    if bytes.len() != 4 {
321        return Err(Error::InvalidSlice("too short for i32"));
322    }
323
324    let mut buf = [0; 4];
325    buf.copy_from_slice(bytes);
326    Ok(i32::from_be_bytes(buf))
327}
328
329pub(crate) fn read_be_i64(bytes: &[u8]) -> Result<i64, Error> {
330    if bytes.len() != 8 {
331        return Err(Error::InvalidSlice("too short for i64"));
332    }
333
334    let mut buf = [0; 8];
335    buf.copy_from_slice(bytes);
336    Ok(i64::from_be_bytes(buf))
337}
338
339/// TZif version
340#[derive(Debug, Copy, Clone, Eq, PartialEq)]
341enum Version {
342    /// Version 1
343    V1,
344    /// Version 2
345    V2,
346    /// Version 3
347    V3,
348}
chrono/offset/local/tz_info/parser.rs

chrono/offset/local/tz_info/
parser.rs
