zerompk/
read.rs

1#[cfg(feature = "std")]
2use alloc::vec;
3
4use crate::Error;
5use crate::FromMessagePack;
6use crate::Result;
7use crate::consts::*;
8
9/// The maximum allowed depth of nested structures during deserialization.
10pub const MAX_DEPTH: usize = 500;
11
12/// A tag read from a MessagePack stream, which can be either an integer or a string.
13pub enum Tag<'de> {
14    Int(u64),
15    String(alloc::borrow::Cow<'de, str>),
16}
17
18/// A trait for reading values from a MessagePack-encoded input.
19pub trait Read<'de> {
20    /// Increments the current depth of nested structures.
21    ///
22    /// ### Errors
23    ///
24    /// Returns an error if the maximum depth is exceeded.
25    ///
26    /// ### Examples
27    ///
28    /// ```rust
29    /// struct Outer {
30    ///     inner: Inner,
31    /// }
32    ///
33    /// struct Inner {
34    ///     value: i32,
35    /// }
36    ///
37    /// impl<'de> FromMessagePack<'de> for Outer {
38    ///     fn read<R: Read<'de>>(reader: &mut R) -> Result<Self> {
39    ///         reader.increment_depth()?;   
40    ///         let inner = Inner::read(reader)?;
41    ///         reader.decrement_depth();
42    ///         Ok(Self { inner })
43    ///     }
44    /// }
45    ///
46    /// impl<'de> FromMessagePack<'de> for Inner {
47    ///     fn read<R: Read<'de>>(reader: &mut R) -> Result<Self> {
48    ///         reader.increment_depth()?;
49    ///         let value = reader.read_i32()?;
50    ///         reader.decrement_depth();
51    ///         Ok(Self { value })
52    ///     }
53    /// }
54    /// ``
55    ///
56    fn increment_depth(&mut self) -> Result<()>;
57
58    /// Decrements the current depth of nested structures.
59    /// This should be called after finishing reading a nested structure.
60    fn decrement_depth(&mut self);
61
62    /// Reads a nil value from the input.
63    fn read_nil(&mut self) -> Result<()>;
64
65    /// Reads a boolean value from the input.
66    fn read_boolean(&mut self) -> Result<bool>;
67
68    /// Reads an unsigned 8-bit integer from the input.
69    fn read_u8(&mut self) -> Result<u8>;
70
71    /// Reads an unsigned 16-bit integer from the input.
72    fn read_u16(&mut self) -> Result<u16>;
73
74    /// Reads an unsigned 32-bit integer from the input.
75    fn read_u32(&mut self) -> Result<u32>;
76
77    /// Reads an unsigned 64-bit integer from the input.
78    fn read_u64(&mut self) -> Result<u64>;
79
80    /// Reads a signed 8-bit integer from the input.
81    fn read_i8(&mut self) -> Result<i8>;
82
83    /// Reads a signed 16-bit integer from the input.
84    fn read_i16(&mut self) -> Result<i16>;
85
86    /// Reads a signed 32-bit integer from the input.
87    fn read_i32(&mut self) -> Result<i32>;
88
89    /// Reads a signed 64-bit integer from the input.
90    fn read_i64(&mut self) -> Result<i64>;
91
92    /// Reads a 32-bit floating-point number from the input.
93    fn read_f32(&mut self) -> Result<f32>;
94
95    /// Reads a 64-bit floating-point number from the input.
96    fn read_f64(&mut self) -> Result<f64>;
97
98    /// Reads a timestamp from the input, returning the seconds and nanoseconds components.
99    fn read_timestamp(&mut self) -> Result<(i64, u32)>;
100
101    /// Reads the array header and returns the length of the array.
102    fn read_array_len(&mut self) -> Result<usize>;
103
104    /// Reads the map header and returns the number of key-value pairs in the map.
105    fn read_map_len(&mut self) -> Result<usize>;
106
107    /// Reads the extension header and returns the extension type and length of the data.
108    fn read_ext_len(&mut self) -> Result<(i8, usize)>;
109
110    /// Reads a UTF-8 string from the input.
111    /// Returns a `Cow<str>` which may borrow from the input data if possible.
112    fn read_string(&mut self) -> Result<alloc::borrow::Cow<'de, str>>;
113
114    /// Reads the raw bytes of a string from the input, without validating UTF-8.
115    /// Returns a `Cow<[u8]>` which may borrow from the input data if possible.
116    fn read_string_bytes(&mut self) -> Result<alloc::borrow::Cow<'de, [u8]>>;
117
118    /// Reads the raw bytes of a binary blob from the input.
119    /// Returns a `Cow<[u8]>` which may borrow from the input data if possible.
120    fn read_binary(&mut self) -> Result<alloc::borrow::Cow<'de, [u8]>>;
121
122    /// Reads an optional value from the input.
123    /// Returns `None` if the next value is nil, or `Some(value)` if it is not.
124    fn read_option<T: FromMessagePack<'de>>(&mut self) -> Result<Option<T>>;
125
126    /// Reads an array of values from the input, returning a `Vec<T>`.
127    fn read_array<T: FromMessagePack<'de>>(&mut self) -> Result<alloc::vec::Vec<T>>;
128
129    /// Reads a tag from the input, which can be either an integer or a string.
130    fn read_tag(&mut self) -> Result<Tag<'de>>;
131
132    /// Validates that the next value in the input is an array of the expected length, and consumes the array header.
133    #[inline(always)]
134    fn check_array_len(&mut self, expected: usize) -> Result<()> {
135        let actual = self.read_array_len()?;
136        if actual == expected {
137            Ok(())
138        } else {
139            Err(Error::ArrayLengthMismatch { expected, actual })
140        }
141    }
142
143    /// Validates that the next value in the input is a map of the expected length, and consumes the map header.
144    #[inline(always)]
145    fn check_map_len(&mut self, expected: usize) -> Result<()> {
146        let actual = self.read_map_len()?;
147        if actual == expected {
148            Ok(())
149        } else {
150            Err(Error::MapLengthMismatch { expected, actual })
151        }
152    }
153}
154
155pub struct SliceReader<'de> {
156    data: &'de [u8],
157    pos: usize,
158    depth: usize,
159}
160
161impl<'de> SliceReader<'de> {
162    pub fn new(data: &'de [u8]) -> Self {
163        Self {
164            data,
165            pos: 0,
166            depth: 0,
167        }
168    }
169
170    #[inline(always)]
171    fn peek_byte(&mut self) -> Result<u8> {
172        if self.pos < self.data.len() {
173            Ok(self.data[self.pos])
174        } else {
175            Err(Error::BufferTooSmall)
176        }
177    }
178
179    #[inline(always)]
180    fn peek_slice(&mut self, len: usize) -> Result<&'de [u8]> {
181        if self.pos + len <= self.data.len() {
182            unsafe { Ok(self.data.get_unchecked(self.pos..(self.pos + len))) }
183        } else {
184            Err(Error::BufferTooSmall)
185        }
186    }
187
188    #[inline(always)]
189    fn take_byte(&mut self) -> Result<u8> {
190        let byte = self.peek_byte()?;
191        self.pos += 1;
192        Ok(byte)
193    }
194
195    #[inline(always)]
196    fn take_slice(&mut self, len: usize) -> Result<&'de [u8]> {
197        let slice = self.peek_slice(len)?;
198        self.pos += len;
199        Ok(slice)
200    }
201
202    #[inline(always)]
203    fn take_array<const N: usize>(&mut self) -> Result<&'de [u8; N]> {
204        let slice = self.peek_slice(N)?;
205        self.pos += N;
206        Ok(unsafe { &*(slice.as_ptr() as *const [u8; N]) })
207    }
208}
209
210impl<'de> Read<'de> for SliceReader<'de> {
211    #[inline(always)]
212    fn increment_depth(&mut self) -> Result<()> {
213        if self.depth >= MAX_DEPTH {
214            Err(Error::DepthLimitExceeded { max: MAX_DEPTH })
215        } else {
216            self.depth += 1;
217            Ok(())
218        }
219    }
220
221    #[inline(always)]
222    fn decrement_depth(&mut self) {
223        if self.depth > 0 {
224            self.depth -= 1;
225        }
226    }
227
228    #[inline(always)]
229    fn read_nil(&mut self) -> Result<()> {
230        let byte = self.peek_byte()?;
231        if byte == NIL_MARKER {
232            self.pos += 1;
233            Ok(())
234        } else {
235            Err(Error::InvalidMarker(byte))
236        }
237    }
238
239    #[inline(always)]
240    fn read_boolean(&mut self) -> Result<bool> {
241        let byte = self.peek_byte()?;
242        match byte {
243            FALSE_MARKER => {
244                self.pos += 1;
245                Ok(false)
246            }
247            TRUE_MARKER => {
248                self.pos += 1;
249                Ok(true)
250            }
251            _ => Err(Error::InvalidMarker(byte)),
252        }
253    }
254
255    #[inline(always)]
256    fn read_u8(&mut self) -> Result<u8> {
257        let byte = self.peek_byte()?;
258        match byte {
259            // Positive FixInt
260            POS_FIXINT_START..=POS_FIXINT_END => {
261                self.pos += 1;
262                Ok(byte)
263            }
264            // uint 8
265            UINT8_MARKER => {
266                self.pos += 1;
267                let byte = self.take_byte()?;
268                Ok(byte)
269            }
270            _ => Err(Error::InvalidMarker(byte)),
271        }
272    }
273
274    #[inline(always)]
275    fn read_u16(&mut self) -> Result<u16> {
276        let byte = self.peek_byte()?;
277        match byte {
278            // Positive FixInt
279            POS_FIXINT_START..=POS_FIXINT_END => {
280                self.pos += 1;
281                Ok(byte as u16)
282            }
283            // uint 8
284            UINT8_MARKER => {
285                self.pos += 1;
286                let byte = self.take_byte()?;
287                Ok(byte as u16)
288            }
289            // uint 16
290            UINT16_MARKER => {
291                self.pos += 1;
292                let bytes = self.take_array::<2>()?;
293                Ok(u16::from_be_bytes(*bytes))
294            }
295            _ => Err(Error::InvalidMarker(byte)),
296        }
297    }
298
299    #[inline(always)]
300    fn read_u32(&mut self) -> Result<u32> {
301        let byte = self.peek_byte()?;
302        match byte {
303            // Positive FixInt
304            POS_FIXINT_START..=POS_FIXINT_END => {
305                self.pos += 1;
306                Ok(byte as u32)
307            }
308            // uint 8
309            UINT8_MARKER => {
310                self.pos += 1;
311                let byte = self.take_byte()?;
312                Ok(byte as u32)
313            }
314            // uint 16
315            UINT16_MARKER => {
316                self.pos += 1;
317                let bytes = self.take_array::<2>()?;
318                Ok(u16::from_be_bytes(*bytes) as u32)
319            }
320            // uint 32
321            UINT32_MARKER => {
322                self.pos += 1;
323                let bytes = self.take_array::<4>()?;
324                Ok(u32::from_be_bytes(*bytes))
325            }
326            _ => Err(Error::InvalidMarker(byte)),
327        }
328    }
329
330    #[inline(always)]
331    fn read_u64(&mut self) -> Result<u64> {
332        let byte = self.peek_byte()?;
333        match byte {
334            // Positive FixInt
335            POS_FIXINT_START..=POS_FIXINT_END => {
336                self.pos += 1;
337                Ok(byte as u64)
338            }
339            // uint 8
340            UINT8_MARKER => {
341                self.pos += 1;
342                let byte = self.take_byte()?;
343                Ok(byte as u64)
344            }
345            // uint 16
346            UINT16_MARKER => {
347                self.pos += 1;
348                let bytes = self.take_array::<2>()?;
349                Ok(u16::from_be_bytes(*bytes) as u64)
350            }
351            // uint 32
352            UINT32_MARKER => {
353                self.pos += 1;
354                let bytes = self.take_array::<4>()?;
355                Ok(u32::from_be_bytes(*bytes) as u64)
356            }
357            // uint 64
358            UINT64_MARKER => {
359                self.pos += 1;
360                let bytes = self.take_array::<8>()?;
361                Ok(u64::from_be_bytes(*bytes))
362            }
363            _ => Err(Error::InvalidMarker(byte)),
364        }
365    }
366
367    #[inline(always)]
368    fn read_i8(&mut self) -> Result<i8> {
369        let byte = self.peek_byte()?;
370        match byte {
371            // Positive FixInt
372            POS_FIXINT_START..=POS_FIXINT_END => {
373                self.pos += 1;
374                Ok(byte as i8)
375            }
376            // Negative FixInt
377            NEG_FIXINT_START..=NEG_FIXINT_END => {
378                self.pos += 1;
379                Ok(byte as i8)
380            }
381            // int 8
382            INT8_MARKER => {
383                self.pos += 1;
384                let byte = self.take_byte()?;
385                Ok(byte as i8)
386            }
387            _ => Err(Error::InvalidMarker(byte)),
388        }
389    }
390
391    #[inline(always)]
392    fn read_i16(&mut self) -> Result<i16> {
393        let byte = self.peek_byte()?;
394        match byte {
395            // Positive FixInt
396            POS_FIXINT_START..=POS_FIXINT_END => {
397                self.pos += 1;
398                Ok(byte as i16)
399            }
400            // Negative FixInt
401            NEG_FIXINT_START..=NEG_FIXINT_END => {
402                self.pos += 1;
403                Ok((byte as i8) as i16)
404            }
405            // int 8
406            INT8_MARKER => {
407                self.pos += 1;
408                let byte = self.take_byte()?;
409                Ok(byte as i8 as i16)
410            }
411            // int 16
412            INT16_MARKER => {
413                self.pos += 1;
414                let bytes = self.take_array::<2>()?;
415                Ok(i16::from_be_bytes(*bytes))
416            }
417            _ => Err(Error::InvalidMarker(byte)),
418        }
419    }
420
421    #[inline(always)]
422    fn read_i32(&mut self) -> Result<i32> {
423        let byte = self.peek_byte()?;
424        match byte {
425            // Positive FixInt
426            POS_FIXINT_START..=POS_FIXINT_END => {
427                self.pos += 1;
428                Ok(byte as i32)
429            }
430            // Negative FixInt
431            NEG_FIXINT_START..=NEG_FIXINT_END => {
432                self.pos += 1;
433                Ok((byte as i8) as i32)
434            }
435            // int 8
436            INT8_MARKER => {
437                self.pos += 1;
438                let byte = self.take_byte()?;
439                Ok(byte as i8 as i32)
440            }
441            // int 16
442            INT16_MARKER => {
443                self.pos += 1;
444                let bytes = self.take_array::<2>()?;
445                Ok(i16::from_be_bytes(*bytes) as i32)
446            }
447            // int 32
448            INT32_MARKER => {
449                self.pos += 1;
450                let bytes = self.take_array::<4>()?;
451                Ok(i32::from_be_bytes(*bytes))
452            }
453            _ => Err(Error::InvalidMarker(byte)),
454        }
455    }
456
457    #[inline(always)]
458    fn read_i64(&mut self) -> Result<i64> {
459        let byte = self.peek_byte()?;
460        match byte {
461            // Positive FixInt
462            POS_FIXINT_START..=POS_FIXINT_END => {
463                self.pos += 1;
464                Ok(byte as i64)
465            }
466            // Negative FixInt
467            NEG_FIXINT_START..=NEG_FIXINT_END => {
468                self.pos += 1;
469                Ok((byte as i8) as i64)
470            }
471            // int 8
472            INT8_MARKER => {
473                self.pos += 1;
474                let byte = self.take_byte()?;
475                Ok(byte as i8 as i64)
476            }
477            // int 16
478            INT16_MARKER => {
479                self.pos += 1;
480                let bytes = self.take_array::<2>()?;
481                Ok(i16::from_be_bytes(*bytes) as i64)
482            }
483            // int 32
484            INT32_MARKER => {
485                self.pos += 1;
486                let bytes = self.take_array::<4>()?;
487                Ok(i32::from_be_bytes(*bytes) as i64)
488            }
489            // int 64
490            INT64_MARKER => {
491                self.pos += 1;
492                let bytes = self.take_array::<8>()?;
493                Ok(i64::from_be_bytes(*bytes))
494            }
495            _ => Err(Error::InvalidMarker(byte)),
496        }
497    }
498
499    #[inline(always)]
500    fn read_f32(&mut self) -> Result<f32> {
501        let byte = self.peek_byte()?;
502        match byte {
503            // float 32
504            0xca => {
505                self.pos += 1;
506                let bytes = self.take_array::<4>()?;
507                Ok(f32::from_bits(u32::from_be_bytes(*bytes)))
508            }
509            _ => Err(Error::InvalidMarker(byte)),
510        }
511    }
512
513    #[inline(always)]
514    fn read_f64(&mut self) -> Result<f64> {
515        let byte = self.peek_byte()?;
516        match byte {
517            // float 64
518            0xcb => {
519                self.pos += 1;
520                let bytes = self.take_array::<8>()?;
521                Ok(f64::from_bits(u64::from_be_bytes(*bytes)))
522            }
523            _ => Err(Error::InvalidMarker(byte)),
524        }
525    }
526
527    #[inline(always)]
528    fn read_string(&mut self) -> Result<alloc::borrow::Cow<'de, str>> {
529        let byte = self.peek_byte()?;
530        let len = match byte {
531            // fixstr
532            FIXSTR_START..=FIXSTR_END => {
533                self.pos += 1;
534                (byte - FIXSTR_START) as usize
535            }
536            // str 8
537            STR8_MARKER => {
538                self.pos += 1;
539                let byte = self.take_byte()?;
540                byte as usize
541            }
542            // str 16
543            STR16_MARKER => {
544                self.pos += 1;
545                let bytes = self.take_array::<2>()?;
546                u16::from_be_bytes(*bytes) as usize
547            }
548            // str 32
549            STR32_MARKER => {
550                self.pos += 1;
551                let bytes = self.take_array::<4>()?;
552                u32::from_be_bytes(*bytes) as usize
553            }
554            _ => return Err(Error::InvalidMarker(byte)),
555        };
556        let bytes = self.take_slice(len)?;
557        match core::str::from_utf8(bytes) {
558            Ok(s) => Ok(alloc::borrow::Cow::Borrowed(s)),
559            Err(err) => Err(Error::InvalidUtf8(err)),
560        }
561    }
562
563    #[inline(always)]
564    fn read_string_bytes(&mut self) -> Result<alloc::borrow::Cow<'de, [u8]>> {
565        let byte = self.peek_byte()?;
566        let len = match byte {
567            // fixstr
568            FIXSTR_START..=FIXSTR_END => {
569                self.pos += 1;
570                (byte - FIXSTR_START) as usize
571            }
572            // str 8
573            STR8_MARKER => {
574                self.pos += 1;
575                let byte = self.take_byte()?;
576                byte as usize
577            }
578            // str 16
579            STR16_MARKER => {
580                self.pos += 1;
581                let bytes = self.take_array::<2>()?;
582                u16::from_be_bytes(*bytes) as usize
583            }
584            // str 32
585            STR32_MARKER => {
586                self.pos += 1;
587                let bytes = self.take_array::<4>()?;
588                u32::from_be_bytes(*bytes) as usize
589            }
590            _ => return Err(Error::InvalidMarker(byte)),
591        };
592        let bytes = self.take_slice(len)?;
593        Ok(alloc::borrow::Cow::Borrowed(bytes))
594    }
595
596    #[inline(always)]
597    fn read_binary(&mut self) -> Result<alloc::borrow::Cow<'de, [u8]>> {
598        let byte = self.peek_byte()?;
599        let len = match byte {
600            // bin 8
601            BIN8_MARKER => {
602                self.pos += 1;
603                let byte = self.take_byte()?;
604                byte as usize
605            }
606            // bin 16
607            BIN16_MARKER => {
608                self.pos += 1;
609                let bytes = self.take_array::<2>()?;
610                u16::from_be_bytes(*bytes) as usize
611            }
612            // bin 32
613            BIN32_MARKER => {
614                self.pos += 1;
615                let bytes = self.take_array::<4>()?;
616                u32::from_be_bytes(*bytes) as usize
617            }
618            _ => return Err(Error::InvalidMarker(byte)),
619        };
620        let bytes = self.take_slice(len)?;
621        Ok(alloc::borrow::Cow::Borrowed(bytes))
622    }
623
624    #[inline(always)]
625    fn read_timestamp(&mut self) -> Result<(i64, u32)> {
626        let byte = self.peek_byte()?;
627        match byte {
628            // fixext 4 with type -1
629            TIMESTAMP32_MARKER => {
630                self.pos += 1;
631                let ext_info = self.take_array::<5>()?;
632                let [ext, tail @ ..] = *ext_info;
633                if ext as i8 != TIMESTAMP_EXT_TYPE {
634                    return Err(Error::InvalidMarker(ext));
635                }
636
637                let seconds = u32::from_be_bytes(tail) as i64;
638                Ok((seconds, 0))
639            }
640            // fixext 8 with type -1
641            TIMESTAMP64_MARKER => {
642                self.pos += 1;
643                let ext_info = self.take_array::<9>()?;
644                let [ext, tail @ ..] = *ext_info;
645                if ext as i8 != TIMESTAMP_EXT_TYPE {
646                    return Err(Error::InvalidMarker(ext));
647                }
648
649                let data64 = u64::from_be_bytes(tail);
650                let nanoseconds = (data64 >> 34) as u32;
651                let seconds = (data64 & 0x0000_0003_ffff_ffff) as i64;
652                if nanoseconds >= 1_000_000_000 {
653                    return Err(Error::InvalidTimestamp);
654                }
655                Ok((seconds, nanoseconds))
656            }
657            // ext8(12) with type -1
658            TIMESTAMP96_MARKER => {
659                self.pos += 1;
660                let len = self.take_byte()? as usize;
661                if len != 12 {
662                    return Err(Error::InvalidMarker(len as u8));
663                }
664
665                let ext_info = self.take_array::<13>()?;
666                let [ext, tail @ ..] = *ext_info;
667                if ext as i8 != TIMESTAMP_EXT_TYPE {
668                    return Err(Error::InvalidMarker(ext));
669                }
670
671                // Instead of using pointers, use `try_into().unwrap()`.
672                // This is faster because it is properly optimized by the compiler.
673                let nanoseconds = u32::from_be_bytes(tail[0..4].try_into().unwrap());
674                let seconds = i64::from_be_bytes(tail[4..12].try_into().unwrap());
675                if nanoseconds >= 1_000_000_000 {
676                    return Err(Error::InvalidTimestamp);
677                }
678                Ok((seconds, nanoseconds))
679            }
680            _ => Err(Error::InvalidMarker(byte)),
681        }
682    }
683
684    #[inline(always)]
685    fn read_array_len(&mut self) -> Result<usize> {
686        let byte = self.peek_byte()?;
687        match byte {
688            // fixarray
689            FIXARRAY_START..=FIXARRAY_END => {
690                self.pos += 1;
691                Ok((byte - FIXARRAY_START) as usize)
692            }
693            // array 16
694            ARRAY16_MARKER => {
695                self.pos += 1;
696                let bytes = self.take_array::<2>()?;
697                Ok(u16::from_be_bytes(*bytes) as usize)
698            }
699            // array 32
700            ARRAY32_MARKER => {
701                self.pos += 1;
702                let bytes = self.take_array::<4>()?;
703                Ok(u32::from_be_bytes(*bytes) as usize)
704            }
705            _ => Err(Error::InvalidMarker(byte)),
706        }
707    }
708
709    #[inline(always)]
710    fn read_map_len(&mut self) -> Result<usize> {
711        let byte = self.peek_byte()?;
712        match byte {
713            // fixmap
714            FIXMAP_START..=FIXMAP_END => {
715                self.pos += 1;
716                Ok((byte - FIXMAP_START) as usize)
717            }
718            // map 16
719            MAP16_MARKER => {
720                self.pos += 1;
721                let bytes = self.take_array::<2>()?;
722                Ok(u16::from_be_bytes(*bytes) as usize)
723            }
724            // map 32
725            MAP32_MARKER => {
726                self.pos += 1;
727                let bytes = self.take_array::<4>()?;
728                Ok(u32::from_be_bytes(*bytes) as usize)
729            }
730            _ => Err(Error::InvalidMarker(byte)),
731        }
732    }
733
734    #[inline(always)]
735    fn read_ext_len(&mut self) -> Result<(i8, usize)> {
736        let byte = self.peek_byte()?;
737        let len = match byte {
738            // fixext 1
739            FIXEXT1_MARKER => {
740                self.pos += 1;
741                1
742            }
743            // fixext 2
744            FIXEXT2_MARKER => {
745                self.pos += 1;
746                2
747            }
748            // fixext 4
749            FIXEXT4_MARKER => {
750                self.pos += 1;
751                4
752            }
753            // fixext 8
754            FIXEXT8_MARKER => {
755                self.pos += 1;
756                8
757            }
758            // fixext 16
759            FIXEXT16_MARKER => {
760                self.pos += 1;
761                16
762            }
763            // ext 8
764            EXT8_MARKER => {
765                self.pos += 1;
766                let byte = self.take_byte()?;
767                byte as usize
768            }
769            // ext 16
770            EXT16_MARKER => {
771                self.pos += 1;
772                let bytes = self.take_array::<2>()?;
773                u16::from_be_bytes(*bytes) as usize
774            }
775            // ext 32
776            EXT32_MARKER => {
777                self.pos += 1;
778                let bytes = self.take_array::<4>()?;
779                u32::from_be_bytes(*bytes) as usize
780            }
781            _ => return Err(Error::InvalidMarker(byte)),
782        };
783        let ext_type = self.take_byte()? as i8;
784        Ok((ext_type, len))
785    }
786
787    #[inline(always)]
788    fn read_array<T: FromMessagePack<'de>>(&mut self) -> Result<alloc::vec::Vec<T>>
789    where
790        Self: Sized,
791    {
792        let len = self.read_array_len()?;
793
794        // Protect against OOM
795        // Strict checks are performed using T::read.
796        // This is intended to prevent pre-allocation of memory,
797        // which can be used in attacks that exploit abnormal sizes.
798        if self.data.len() - self.pos < len {
799            return Err(Error::BufferTooSmall);
800        }
801
802        let mut vec = alloc::vec::Vec::with_capacity(len);
803        unsafe {
804            let mut ptr: *mut T = vec.as_mut_ptr();
805            for _ in 0..len {
806                let value = T::read(self)?;
807                ptr.write(value);
808                ptr = ptr.add(1);
809            }
810            vec.set_len(len);
811        }
812        Ok(vec)
813    }
814
815    #[inline(always)]
816    fn read_option<T: FromMessagePack<'de>>(&mut self) -> Result<Option<T>>
817    where
818        Self: Sized,
819    {
820        let byte = self.peek_byte()?;
821        if byte == NIL_MARKER {
822            self.pos += 1;
823            Ok(None)
824        } else {
825            Ok(Some(T::read(self)?))
826        }
827    }
828
829    #[inline(always)]
830    fn read_tag(&mut self) -> Result<Tag<'de>> {
831        let byte = self.peek_byte()?;
832        match byte {
833            POS_FIXINT_START..=POS_FIXINT_END => {
834                self.pos += 1;
835                Ok(Tag::Int(byte as u64))
836            }
837            UINT8_MARKER => {
838                self.pos += 1;
839                let byte = self.take_byte()?;
840                Ok(Tag::Int(byte as u64))
841            }
842            UINT16_MARKER => {
843                self.pos += 1;
844                let bytes = self.take_array::<2>()?;
845                Ok(Tag::Int(u16::from_be_bytes(*bytes) as u64))
846            }
847            UINT32_MARKER => {
848                self.pos += 1;
849                let bytes = self.take_array::<4>()?;
850                Ok(Tag::Int(u32::from_be_bytes(*bytes) as u64))
851            }
852            UINT64_MARKER => {
853                self.pos += 1;
854                let bytes = self.take_array::<8>()?;
855                Ok(Tag::Int(u64::from_be_bytes(*bytes)))
856            }
857            FIXSTR_START..=FIXSTR_END => {
858                self.pos += 1;
859                let len = (byte - FIXSTR_START) as usize;
860                let bytes = self.take_slice(len)?;
861                match core::str::from_utf8(bytes) {
862                    Ok(s) => Ok(Tag::String(alloc::borrow::Cow::Borrowed(s))),
863                    Err(err) => Err(Error::InvalidUtf8(err)),
864                }
865            }
866            STR8_MARKER => {
867                self.pos += 1;
868                let byte = self.take_byte()?;
869                let len = byte as usize;
870                let bytes = self.take_slice(len)?;
871                match core::str::from_utf8(bytes) {
872                    Ok(s) => Ok(Tag::String(alloc::borrow::Cow::Borrowed(s))),
873                    Err(err) => Err(Error::InvalidUtf8(err)),
874                }
875            }
876            STR16_MARKER => {
877                self.pos += 1;
878                let bytes = self.take_array::<2>()?;
879                let len = u16::from_be_bytes(*bytes) as usize;
880
881                let bytes = self.take_slice(len)?;
882                match core::str::from_utf8(bytes) {
883                    Ok(s) => Ok(Tag::String(alloc::borrow::Cow::Borrowed(s))),
884                    Err(err) => Err(Error::InvalidUtf8(err)),
885                }
886            }
887            STR32_MARKER => {
888                self.pos += 1;
889                let bytes = self.take_array::<4>()?;
890                let len = u32::from_be_bytes(*bytes) as usize;
891
892                let bytes = self.take_slice(len)?;
893                match core::str::from_utf8(bytes) {
894                    Ok(s) => Ok(Tag::String(alloc::borrow::Cow::Borrowed(s))),
895                    Err(err) => Err(Error::InvalidUtf8(err)),
896                }
897            }
898            _ => Err(Error::InvalidMarker(byte)),
899        }
900    }
901}
902
903#[cfg(feature = "std")]
904pub struct IOReader<R: std::io::Read> {
905    reader: R,
906    depth: usize,
907    peeked: Option<u8>,
908}
909
910#[cfg(feature = "std")]
911impl<R: std::io::Read> IOReader<R> {
912    pub fn new(reader: R) -> Self {
913        Self {
914            reader,
915            depth: 0,
916            peeked: None,
917        }
918    }
919
920    #[inline(always)]
921    fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> {
922        self.reader
923            .read_exact(buf)
924            .map_err(|err| Error::IoError(err))
925    }
926
927    #[inline(always)]
928    fn read_byte(&mut self) -> Result<u8> {
929        if let Some(byte) = self.peeked.take() {
930            Ok(byte)
931        } else {
932            let mut buf = [0u8; 1];
933            self.read_exact(&mut buf)?;
934            Ok(buf[0])
935        }
936    }
937
938    #[inline(always)]
939    fn unread_byte(&mut self, byte: u8) {
940        debug_assert!(self.peeked.is_none());
941        self.peeked = Some(byte);
942    }
943
944    #[inline(always)]
945    fn read_exact_vec(&mut self, len: usize) -> Result<alloc::vec::Vec<u8>> {
946        const CHUNK_SIZE: usize = 8192;
947
948        if len == 0 {
949            return Ok(alloc::vec::Vec::new());
950        } else if len < CHUNK_SIZE {
951            let mut buf = vec![0u8; len];
952            self.reader.read_exact(&mut buf).map_err(Error::IoError)?;
953            return Ok(buf);
954        }
955
956        let mut out = alloc::vec::Vec::new();
957        let mut remaining = len;
958        let mut chunk = [0u8; CHUNK_SIZE];
959
960        while remaining > 0 {
961            let to_read = core::cmp::min(remaining, chunk.len());
962            let n = self
963                .reader
964                .read(&mut chunk[..to_read])
965                .map_err(Error::IoError)?;
966            if n == 0 {
967                return Err(Error::BufferTooSmall);
968            }
969            out.extend_from_slice(&chunk[..n]);
970            remaining -= n;
971        }
972
973        Ok(out)
974    }
975}
976
977#[cfg(feature = "std")]
978impl<'de, R: std::io::Read> Read<'de> for IOReader<R> {
979    #[inline(always)]
980    fn increment_depth(&mut self) -> Result<()> {
981        if self.depth >= MAX_DEPTH {
982            Err(Error::DepthLimitExceeded { max: MAX_DEPTH })
983        } else {
984            self.depth += 1;
985            Ok(())
986        }
987    }
988
989    #[inline(always)]
990    fn decrement_depth(&mut self) {
991        self.depth -= 1;
992    }
993
994    #[inline(always)]
995    fn read_nil(&mut self) -> Result<()> {
996        let byte = self.read_byte()?;
997        if byte == NIL_MARKER {
998            Ok(())
999        } else {
1000            Err(Error::InvalidMarker(byte))
1001        }
1002    }
1003
1004    #[inline(always)]
1005    fn read_boolean(&mut self) -> Result<bool> {
1006        let byte = self.read_byte()?;
1007        match byte {
1008            FALSE_MARKER => Ok(false),
1009            TRUE_MARKER => Ok(true),
1010            _ => Err(Error::InvalidMarker(byte)),
1011        }
1012    }
1013
1014    #[inline(always)]
1015    fn read_u8(&mut self) -> Result<u8> {
1016        let byte = self.read_byte()?;
1017        match byte {
1018            POS_FIXINT_START..=POS_FIXINT_END => Ok(byte),
1019            UINT8_MARKER => {
1020                let value = self.read_byte()?;
1021                Ok(value)
1022            }
1023            _ => Err(Error::InvalidMarker(byte)),
1024        }
1025    }
1026
1027    #[inline(always)]
1028    fn read_u16(&mut self) -> Result<u16> {
1029        let byte = self.read_byte()?;
1030        match byte {
1031            POS_FIXINT_START..=POS_FIXINT_END => Ok(byte as u16),
1032            UINT8_MARKER => {
1033                let value = self.read_byte()?;
1034                Ok(value as u16)
1035            }
1036            UINT16_MARKER => {
1037                let mut buf = [0u8; 2];
1038                self.read_exact(&mut buf)?;
1039                Ok(u16::from_be_bytes(buf))
1040            }
1041            _ => Err(Error::InvalidMarker(byte)),
1042        }
1043    }
1044
1045    #[inline(always)]
1046    fn read_u32(&mut self) -> Result<u32> {
1047        let byte = self.read_byte()?;
1048        match byte {
1049            POS_FIXINT_START..=POS_FIXINT_END => Ok(byte as u32),
1050            UINT8_MARKER => {
1051                let value = self.read_byte()?;
1052                Ok(value as u32)
1053            }
1054            UINT16_MARKER => {
1055                let mut buf = [0u8; 2];
1056                self.read_exact(&mut buf)?;
1057                Ok(u16::from_be_bytes(buf) as u32)
1058            }
1059            UINT32_MARKER => {
1060                let mut buf = [0u8; 4];
1061                self.read_exact(&mut buf)?;
1062                Ok(u32::from_be_bytes(buf))
1063            }
1064            _ => Err(Error::InvalidMarker(byte)),
1065        }
1066    }
1067
1068    #[inline(always)]
1069    fn read_u64(&mut self) -> Result<u64> {
1070        let byte = self.read_byte()?;
1071        match byte {
1072            POS_FIXINT_START..=POS_FIXINT_END => Ok(byte as u64),
1073            UINT8_MARKER => {
1074                let value = self.read_byte()?;
1075                Ok(value as u64)
1076            }
1077            UINT16_MARKER => {
1078                let mut buf = [0u8; 2];
1079                self.read_exact(&mut buf)?;
1080                Ok(u16::from_be_bytes(buf) as u64)
1081            }
1082            UINT32_MARKER => {
1083                let mut buf = [0u8; 4];
1084                self.read_exact(&mut buf)?;
1085                Ok(u32::from_be_bytes(buf) as u64)
1086            }
1087            UINT64_MARKER => {
1088                let mut buf = [0u8; 8];
1089                self.read_exact(&mut buf)?;
1090                Ok(u64::from_be_bytes(buf))
1091            }
1092            _ => Err(Error::InvalidMarker(byte)),
1093        }
1094    }
1095
1096    #[inline(always)]
1097    fn read_i8(&mut self) -> Result<i8> {
1098        let byte = self.read_byte()?;
1099        match byte {
1100            POS_FIXINT_START..=POS_FIXINT_END => Ok(byte as i8),
1101            NEG_FIXINT_START..=NEG_FIXINT_END => Ok(byte as i8),
1102            INT8_MARKER => {
1103                let value = self.read_byte()?;
1104                Ok(value as i8)
1105            }
1106            _ => Err(Error::InvalidMarker(byte)),
1107        }
1108    }
1109
1110    #[inline(always)]
1111    fn read_i16(&mut self) -> Result<i16> {
1112        let byte = self.read_byte()?;
1113        match byte {
1114            POS_FIXINT_START..=POS_FIXINT_END => Ok(byte as i16),
1115            NEG_FIXINT_START..=NEG_FIXINT_END => Ok((byte as i8) as i16),
1116            INT8_MARKER => {
1117                let value = self.read_byte()?;
1118                Ok((value as i8) as i16)
1119            }
1120            INT16_MARKER => {
1121                let mut buf = [0u8; 2];
1122                self.read_exact(&mut buf)?;
1123                Ok(i16::from_be_bytes(buf))
1124            }
1125            _ => Err(Error::InvalidMarker(byte)),
1126        }
1127    }
1128
1129    #[inline(always)]
1130    fn read_i32(&mut self) -> Result<i32> {
1131        let byte = self.read_byte()?;
1132        match byte {
1133            POS_FIXINT_START..=POS_FIXINT_END => Ok(byte as i32),
1134            NEG_FIXINT_START..=NEG_FIXINT_END => Ok((byte as i8) as i32),
1135            INT8_MARKER => {
1136                let value = self.read_byte()?;
1137                Ok((value as i8) as i32)
1138            }
1139            INT16_MARKER => {
1140                let mut buf = [0u8; 2];
1141                self.read_exact(&mut buf)?;
1142                Ok(i16::from_be_bytes(buf) as i32)
1143            }
1144            INT32_MARKER => {
1145                let mut buf = [0u8; 4];
1146                self.read_exact(&mut buf)?;
1147                Ok(i32::from_be_bytes(buf))
1148            }
1149            _ => Err(Error::InvalidMarker(byte)),
1150        }
1151    }
1152
1153    #[inline(always)]
1154    fn read_i64(&mut self) -> Result<i64> {
1155        let byte = self.read_byte()?;
1156        match byte {
1157            POS_FIXINT_START..=POS_FIXINT_END => Ok(byte as i64),
1158            NEG_FIXINT_START..=NEG_FIXINT_END => Ok((byte as i8) as i64),
1159            INT8_MARKER => {
1160                let value = self.read_byte()?;
1161                Ok((value as i8) as i64)
1162            }
1163            INT16_MARKER => {
1164                let mut buf = [0u8; 2];
1165                self.read_exact(&mut buf)?;
1166                Ok(i16::from_be_bytes(buf) as i64)
1167            }
1168            INT32_MARKER => {
1169                let mut buf = [0u8; 4];
1170                self.read_exact(&mut buf)?;
1171                Ok(i32::from_be_bytes(buf) as i64)
1172            }
1173            INT64_MARKER => {
1174                let mut buf = [0u8; 8];
1175                self.read_exact(&mut buf)?;
1176                Ok(i64::from_be_bytes(buf))
1177            }
1178            _ => Err(Error::InvalidMarker(byte)),
1179        }
1180    }
1181
1182    #[inline(always)]
1183    fn read_f32(&mut self) -> Result<f32> {
1184        let byte = self.read_byte()?;
1185        match byte {
1186            FLOAT32_MARKER => {
1187                let mut buf = [0u8; 4];
1188                self.read_exact(&mut buf)?;
1189                Ok(f32::from_bits(u32::from_be_bytes(buf)))
1190            }
1191            _ => Err(Error::InvalidMarker(byte)),
1192        }
1193    }
1194
1195    #[inline(always)]
1196    fn read_f64(&mut self) -> Result<f64> {
1197        let byte = self.read_byte()?;
1198        match byte {
1199            FLOAT64_MARKER => {
1200                let mut buf = [0u8; 8];
1201                self.read_exact(&mut buf)?;
1202                Ok(f64::from_bits(u64::from_be_bytes(buf)))
1203            }
1204            _ => Err(Error::InvalidMarker(byte)),
1205        }
1206    }
1207
1208    #[inline(always)]
1209    fn read_string(&mut self) -> Result<alloc::borrow::Cow<'de, str>> {
1210        let mut buf = [0u8; 1];
1211        let byte = self.read_byte()?;
1212        let len = match byte {
1213            FIXSTR_START..=FIXSTR_END => (byte - FIXSTR_START) as usize,
1214            STR8_MARKER => {
1215                self.read_exact(&mut buf)?;
1216                buf[0] as usize
1217            }
1218            STR16_MARKER => {
1219                let mut buf = [0u8; 2];
1220                self.read_exact(&mut buf)?;
1221                u16::from_be_bytes(buf) as usize
1222            }
1223            STR32_MARKER => {
1224                let mut buf = [0u8; 4];
1225                self.read_exact(&mut buf)?;
1226                u32::from_be_bytes(buf) as usize
1227            }
1228            _ => return Err(Error::InvalidMarker(byte)),
1229        };
1230
1231        let str_buf = self.read_exact_vec(len)?;
1232
1233        match alloc::string::String::from_utf8(str_buf) {
1234            Ok(s) => Ok(alloc::borrow::Cow::Owned(s)),
1235            Err(err) => Err(Error::InvalidUtf8(err.utf8_error())),
1236        }
1237    }
1238
1239    #[inline(always)]
1240    fn read_string_bytes(&mut self) -> Result<alloc::borrow::Cow<'de, [u8]>> {
1241        let mut buf = [0u8; 1];
1242        let byte = self.read_byte()?;
1243        let len = match byte {
1244            FIXSTR_START..=FIXSTR_END => (byte - FIXSTR_START) as usize,
1245            STR8_MARKER => {
1246                self.read_exact(&mut buf)?;
1247                buf[0] as usize
1248            }
1249            STR16_MARKER => {
1250                let mut buf = [0u8; 2];
1251                self.read_exact(&mut buf)?;
1252                u16::from_be_bytes(buf) as usize
1253            }
1254            STR32_MARKER => {
1255                let mut buf = [0u8; 4];
1256                self.read_exact(&mut buf)?;
1257                u32::from_be_bytes(buf) as usize
1258            }
1259            _ => return Err(Error::InvalidMarker(byte)),
1260        };
1261
1262        let str_buf = self.read_exact_vec(len)?;
1263        Ok(alloc::borrow::Cow::Owned(str_buf))
1264    }
1265
1266    #[inline(always)]
1267    fn read_binary(&mut self) -> Result<alloc::borrow::Cow<'de, [u8]>> {
1268        let mut buf = [0u8; 1];
1269        let byte = self.read_byte()?;
1270        let len = match byte {
1271            BIN8_MARKER => {
1272                self.read_exact(&mut buf)?;
1273                buf[0] as usize
1274            }
1275            BIN16_MARKER => {
1276                let mut buf = [0u8; 2];
1277                self.read_exact(&mut buf)?;
1278                u16::from_be_bytes(buf) as usize
1279            }
1280            BIN32_MARKER => {
1281                let mut buf = [0u8; 4];
1282                self.read_exact(&mut buf)?;
1283                u32::from_be_bytes(buf) as usize
1284            }
1285            _ => return Err(Error::InvalidMarker(byte)),
1286        };
1287
1288        let data_buf = self.read_exact_vec(len)?;
1289        Ok(alloc::borrow::Cow::Owned(data_buf))
1290    }
1291
1292    #[inline(always)]
1293    fn read_timestamp(&mut self) -> Result<(i64, u32)> {
1294        let byte = self.read_byte()?;
1295        match byte {
1296            TIMESTAMP32_MARKER => {
1297                let mut ext_info = [0u8; 5];
1298                self.read_exact(&mut ext_info)?;
1299
1300                let [ext, tail @ ..] = ext_info;
1301                if ext != TIMESTAMP_EXT_TYPE as u8 {
1302                    return Err(Error::InvalidMarker(ext));
1303                }
1304                let seconds = u32::from_be_bytes(tail) as i64;
1305                Ok((seconds, 0))
1306            }
1307            TIMESTAMP64_MARKER => {
1308                let mut ext_info = [0u8; 9];
1309                self.read_exact(&mut ext_info)?;
1310
1311                let [ext, tail @ ..] = ext_info;
1312                if ext != -1i8 as u8 {
1313                    return Err(Error::InvalidMarker(ext));
1314                }
1315
1316                let data64 = u64::from_be_bytes(tail);
1317                let nanoseconds = (data64 >> 34) as u32;
1318                let seconds = (data64 & 0x0000_0003_ffff_ffff) as i64;
1319                if nanoseconds >= 1_000_000_000 {
1320                    return Err(Error::InvalidTimestamp);
1321                }
1322                Ok((seconds, nanoseconds))
1323            }
1324            TIMESTAMP96_MARKER => {
1325                let len = self.read_byte()? as usize;
1326                if len != 12 {
1327                    return Err(Error::InvalidMarker(len as u8));
1328                }
1329
1330                let mut ext_info = [0u8; 13];
1331                self.read_exact(&mut ext_info)?;
1332                let [ext, tail @ ..] = ext_info;
1333                if ext != TIMESTAMP_EXT_TYPE as u8 {
1334                    return Err(Error::InvalidMarker(ext));
1335                }
1336
1337                // Instead of using pointers, use `try_into().unwrap()`.
1338                // This is faster because it is properly optimized by the compiler.
1339                let nanoseconds = u32::from_be_bytes(tail[0..4].try_into().unwrap());
1340                let seconds = i64::from_be_bytes(tail[4..12].try_into().unwrap());
1341                if nanoseconds >= 1_000_000_000 {
1342                    return Err(Error::InvalidTimestamp);
1343                }
1344
1345                Ok((seconds, nanoseconds))
1346            }
1347            _ => Err(Error::InvalidMarker(byte)),
1348        }
1349    }
1350
1351    #[inline(always)]
1352    fn read_array_len(&mut self) -> Result<usize> {
1353        let byte = self.read_byte()?;
1354        match byte {
1355            FIXARRAY_START..=FIXARRAY_END => Ok((byte - FIXARRAY_START) as usize),
1356            ARRAY16_MARKER => {
1357                let mut buf = [0u8; 2];
1358                self.read_exact(&mut buf)?;
1359                Ok(u16::from_be_bytes(buf) as usize)
1360            }
1361            ARRAY32_MARKER => {
1362                let mut buf = [0u8; 4];
1363                self.read_exact(&mut buf)?;
1364                Ok(u32::from_be_bytes(buf) as usize)
1365            }
1366            _ => Err(Error::InvalidMarker(byte)),
1367        }
1368    }
1369
1370    #[inline(always)]
1371    fn read_map_len(&mut self) -> Result<usize> {
1372        let byte = self.read_byte()?;
1373        match byte {
1374            FIXMAP_START..=FIXMAP_END => Ok((byte - FIXMAP_START) as usize),
1375            MAP16_MARKER => {
1376                let mut buf = [0u8; 2];
1377                self.read_exact(&mut buf)?;
1378                Ok(u16::from_be_bytes(buf) as usize)
1379            }
1380            MAP32_MARKER => {
1381                let mut buf = [0u8; 4];
1382                self.read_exact(&mut buf)?;
1383                Ok(u32::from_be_bytes(buf) as usize)
1384            }
1385            _ => Err(Error::InvalidMarker(byte)),
1386        }
1387    }
1388
1389    #[inline(always)]
1390    fn read_ext_len(&mut self) -> Result<(i8, usize)> {
1391        let mut buf = [0u8; 1];
1392        let byte = self.read_byte()?;
1393        let len = match byte {
1394            FIXEXT1_MARKER => 1,
1395            FIXEXT2_MARKER => 2,
1396            FIXEXT4_MARKER => 4,
1397            FIXEXT8_MARKER => 8,
1398            FIXEXT16_MARKER => 16,
1399            EXT8_MARKER => {
1400                self.read_exact(&mut buf)?;
1401                buf[0] as usize
1402            }
1403            EXT16_MARKER => {
1404                let mut buf = [0u8; 2];
1405                self.read_exact(&mut buf)?;
1406                u16::from_be_bytes(buf) as usize
1407            }
1408            EXT32_MARKER => {
1409                let mut buf = [0u8; 4];
1410                self.read_exact(&mut buf)?;
1411                u32::from_be_bytes(buf) as usize
1412            }
1413            _ => return Err(Error::InvalidMarker(byte)),
1414        };
1415        self.read_exact(&mut buf)?;
1416        let ext_type = buf[0] as i8;
1417        Ok((ext_type, len))
1418    }
1419
1420    #[inline(always)]
1421    fn read_option<T: FromMessagePack<'de>>(&mut self) -> Result<Option<T>> {
1422        let byte = self.read_byte()?;
1423        if byte == NIL_MARKER {
1424            Ok(None)
1425        } else {
1426            self.unread_byte(byte);
1427            Ok(Some(T::read(self)?))
1428        }
1429    }
1430
1431    #[inline(always)]
1432    fn read_array<T: FromMessagePack<'de>>(&mut self) -> Result<alloc::vec::Vec<T>> {
1433        let len = self.read_array_len()?;
1434        let mut vec = alloc::vec::Vec::new();
1435        for _ in 0..len {
1436            vec.push(T::read(self)?);
1437        }
1438        Ok(vec)
1439    }
1440
1441    fn read_tag(&mut self) -> Result<Tag<'de>> {
1442        let mut buf = [0u8; 1];
1443        let byte = self.read_byte()?;
1444        match byte {
1445            POS_FIXINT_START..=POS_FIXINT_END => Ok(Tag::Int(byte as u64)),
1446            UINT8_MARKER => {
1447                let value = self.read_byte()?;
1448                Ok(Tag::Int(value as u64))
1449            }
1450            UINT16_MARKER => {
1451                let mut buf = [0u8; 2];
1452                self.read_exact(&mut buf)?;
1453                Ok(Tag::Int(u16::from_be_bytes(buf) as u64))
1454            }
1455            UINT32_MARKER => {
1456                let mut buf = [0u8; 4];
1457                self.read_exact(&mut buf)?;
1458                Ok(Tag::Int(u32::from_be_bytes(buf) as u64))
1459            }
1460            UINT64_MARKER => {
1461                let mut buf = [0u8; 8];
1462                self.read_exact(&mut buf)?;
1463                Ok(Tag::Int(u64::from_be_bytes(buf)))
1464            }
1465            FIXSTR_START..=FIXSTR_END => {
1466                let len = (byte - FIXSTR_START) as usize;
1467                let str_buf = self.read_exact_vec(len)?;
1468                match alloc::string::String::from_utf8(str_buf) {
1469                    Ok(s) => Ok(Tag::String(s.into())),
1470                    Err(err) => Err(Error::InvalidUtf8(err.utf8_error())),
1471                }
1472            }
1473            STR8_MARKER => {
1474                self.read_exact(&mut buf)?;
1475                let len = buf[0] as usize;
1476                let str_buf = self.read_exact_vec(len)?;
1477                match alloc::string::String::from_utf8(str_buf) {
1478                    Ok(s) => Ok(Tag::String(s.into())),
1479                    Err(err) => Err(Error::InvalidUtf8(err.utf8_error())),
1480                }
1481            }
1482            STR16_MARKER => {
1483                let mut buf = [0u8; 2];
1484                self.read_exact(&mut buf)?;
1485                let len = u16::from_be_bytes(buf) as usize;
1486                let str_buf = self.read_exact_vec(len)?;
1487                match alloc::string::String::from_utf8(str_buf) {
1488                    Ok(s) => Ok(Tag::String(s.into())),
1489                    Err(err) => Err(Error::InvalidUtf8(err.utf8_error())),
1490                }
1491            }
1492            STR32_MARKER => {
1493                let mut buf = [0u8; 4];
1494                self.read_exact(&mut buf)?;
1495                let len = u32::from_be_bytes(buf) as usize;
1496                let str_buf = self.read_exact_vec(len)?;
1497                match alloc::string::String::from_utf8(str_buf) {
1498                    Ok(s) => Ok(Tag::String(s.into())),
1499                    Err(err) => Err(Error::InvalidUtf8(err.utf8_error())),
1500                }
1501            }
1502            _ => Err(Error::InvalidMarker(byte)),
1503        }
1504    }
1505}
zerompk/read.rs

zerompk/
read.rs
