multi_cbor/
de.rs

1//! Deserialization.
2
3use core::f32;
4use core::marker::PhantomData;
5use core::result;
6use core::str;
7use half::f16;
8use serde::de;
9#[cfg(feature = "std")]
10use std::io;
11
12use crate::config::DeserializerConfig;
13use crate::error::{Error, ErrorCode, Result};
14#[cfg(not(feature = "unsealed_read_write"))]
15use crate::read::EitherLifetime;
16#[cfg(feature = "unsealed_read_write")]
17pub use crate::read::EitherLifetime;
18#[cfg(feature = "std")]
19pub use crate::read::IoRead;
20use crate::read::Offset;
21#[cfg(any(feature = "std", feature = "alloc"))]
22pub use crate::read::SliceRead;
23pub use crate::read::{MutSliceRead, Read, SliceReadFixed};
24#[cfg(feature = "tags")]
25use crate::tags::TagGuard;
26/// Decodes a value from CBOR data in a slice.
27///
28/// # Examples
29///
30/// Deserialize a `String`
31///
32/// ```
33/// # use multi_cbor::de;
34/// let v: Vec<u8> = vec![0x66, 0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72];
35/// let value: String = de::from_slice(&v[..]).unwrap();
36/// assert_eq!(value, "foobar");
37/// ```
38///
39/// Deserialize a borrowed string with zero copies.
40///
41/// ```
42/// # use multi_cbor::de;
43/// let v: Vec<u8> = vec![0x66, 0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72];
44/// let value: &str = de::from_slice(&v[..]).unwrap();
45/// assert_eq!(value, "foobar");
46/// ```
47#[cfg(any(feature = "std", feature = "alloc"))]
48pub fn from_slice<'a, T>(slice: &'a [u8]) -> Result<T>
49where
50    T: de::Deserialize<'a>,
51{
52    let mut deserializer = Deserializer::from_slice(slice);
53    let value = de::Deserialize::deserialize(&mut deserializer)?;
54    deserializer.end()?;
55    Ok(value)
56}
57
58// When the "std" feature is enabled there should be little to no need to ever use this function,
59// as `from_slice` covers all use cases (at the expense of being less efficient).
60/// Decode a value from CBOR data in a mutable slice.
61///
62/// This can be used in analogy to `from_slice`. Unlike `from_slice`, this will use the slice's
63/// mutability to rearrange data in it in order to resolve indefinite byte or text strings without
64/// resorting to allocations.
65pub fn from_mut_slice<'a, T>(slice: &'a mut [u8]) -> Result<T>
66where
67    T: de::Deserialize<'a>,
68{
69    let mut deserializer = Deserializer::from_mut_slice(slice);
70    let value = de::Deserialize::deserialize(&mut deserializer)?;
71    deserializer.end()?;
72    Ok(value)
73}
74
75// When the "std" feature is enabled there should be little to no need to ever use this function,
76// as `from_slice` covers all use cases and is much more reliable (at the expense of being less
77// efficient).
78/// Decode a value from CBOR data using a scratch buffer.
79///
80/// Users should generally prefer to use `from_slice` or `from_mut_slice` over this function,
81/// as decoding may fail when the scratch buffer turns out to be too small.
82///
83/// A realistic use case for this method would be decoding in a `no_std` environment from an
84/// immutable slice that is too large to copy.
85pub fn from_slice_with_scratch<'a, 'b, T>(slice: &'a [u8], scratch: &'b mut [u8]) -> Result<T>
86where
87    T: de::Deserialize<'a>,
88{
89    let mut deserializer = Deserializer::from_slice_with_scratch(slice, scratch);
90    let value = de::Deserialize::deserialize(&mut deserializer)?;
91    deserializer.end()?;
92    Ok(value)
93}
94
95/// Decodes a value from CBOR data in a reader.
96///
97/// # Examples
98///
99/// Deserialize a `String`
100///
101/// ```
102/// # use multi_cbor::de;
103/// let v: Vec<u8> = vec![0x66, 0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72];
104/// let value: String = de::from_reader(&v[..]).unwrap();
105/// assert_eq!(value, "foobar");
106/// ```
107///
108/// Note that `from_reader` cannot borrow data:
109///
110/// ```compile_fail
111/// # use multi_cbor::de;
112/// let v: Vec<u8> = vec![0x66, 0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72];
113/// let value: &str = de::from_reader(&v[..]).unwrap();
114/// assert_eq!(value, "foobar");
115/// ```
116#[cfg(feature = "std")]
117pub fn from_reader<T, R>(reader: R) -> Result<T>
118where
119    T: de::DeserializeOwned,
120    R: io::Read,
121{
122    let mut deserializer = Deserializer::from_reader(reader);
123    let value = de::Deserialize::deserialize(&mut deserializer)?;
124    deserializer.end()?;
125    Ok(value)
126}
127
128/// A Serde `Deserialize`r of CBOR data.
129#[derive(Debug)]
130pub struct Deserializer<R> {
131    read: R,
132    remaining_depth: u8,
133    config: DeserializerConfig,
134    accept_named: bool,
135    accept_packed: bool,
136    accept_standard_enums: bool,
137    accept_legacy_enums: bool,
138}
139
140#[cfg(feature = "std")]
141impl<R> Deserializer<IoRead<R>>
142where
143    R: io::Read,
144{
145    /// Constructs a `Deserializer` which reads from a `Read`er.
146    pub fn from_reader(reader: R) -> Self {
147        Self::new(IoRead::new(reader))
148    }
149}
150
151#[cfg(any(feature = "std", feature = "alloc"))]
152impl<'a> Deserializer<SliceRead<'a>> {
153    /// Constructs a `Deserializer` which reads from a slice.
154    ///
155    /// Borrowed strings and byte slices will be provided when possible.
156    #[must_use]
157    pub fn from_slice(bytes: &'a [u8]) -> Self {
158        Deserializer::new(SliceRead::new(bytes))
159    }
160}
161
162impl<'a> Deserializer<MutSliceRead<'a>> {
163    /// Constructs a `Deserializer` which reads from a mutable slice that doubles as its own
164    /// scratch buffer.
165    ///
166    /// Borrowed strings and byte slices will be provided even for indefinite strings.
167    pub fn from_mut_slice(bytes: &'a mut [u8]) -> Self {
168        Deserializer::new(MutSliceRead::new(bytes))
169    }
170}
171
172impl<'a, 'b> Deserializer<SliceReadFixed<'a, 'b>> {
173    #[doc(hidden)]
174    pub fn from_slice_with_scratch(bytes: &'a [u8], scratch: &'b mut [u8]) -> Self {
175        Deserializer::new(SliceReadFixed::new(bytes, scratch))
176    }
177}
178
179impl<'de, R> Deserializer<R>
180where
181    R: Read<'de>,
182{
183    /// Constructs a `Deserializer` from one of the possible `multi_cbor` input sources.
184    ///
185    /// `from_slice` and `from_reader` should normally be used instead of this method.
186    pub fn new(read: R) -> Self {
187        let config = DeserializerConfig::default();
188        let remaining_depth = config.get_max_recursion_depth();
189        Self {
190            read,
191            remaining_depth,
192            config,
193            accept_named: true,
194            accept_packed: true,
195            accept_standard_enums: true,
196            accept_legacy_enums: true,
197        }
198    }
199
200    /// Sets the deserializer configuration.
201    ///
202    /// This allows you to configure limits for `DoS` protection.
203    ///
204    /// # Examples
205    ///
206    /// ```
207    /// # use multi_cbor::de::Deserializer;
208    /// # use multi_cbor::config::DeserializerConfig;
209    /// let config = DeserializerConfig::strict();
210    /// let data = &[0x82, 0x01, 0x02]; // CBOR array [1, 2]
211    /// let de = Deserializer::from_slice(data).config(config);
212    /// ```
213    #[must_use]
214    pub const fn config(mut self, config: DeserializerConfig) -> Self {
215        self.remaining_depth = config.get_max_recursion_depth();
216        self.config = config;
217        self
218    }
219
220    /// Don't accept named variants and fields.
221    #[must_use]
222    pub const fn disable_named_format(mut self) -> Self {
223        self.accept_named = false;
224        self
225    }
226
227    /// Don't accept numbered variants and fields.
228    #[must_use]
229    pub const fn disable_packed_format(mut self) -> Self {
230        self.accept_packed = false;
231        self
232    }
233
234    /// Don't accept the new enum format used by `multi_cbor` versions >= v0.10.
235    #[must_use]
236    pub const fn disable_standard_enums(mut self) -> Self {
237        self.accept_standard_enums = false;
238        self
239    }
240
241    /// Don't accept the old enum format used by `multi_cbor` versions <= v0.9.
242    #[must_use]
243    pub const fn disable_legacy_enums(mut self) -> Self {
244        self.accept_legacy_enums = false;
245        self
246    }
247
248    /// This method should be called after a value has been deserialized to ensure there is no
249    /// trailing data in the input source.
250    pub fn end(&mut self) -> Result<()> {
251        match self.next()? {
252            Some(_) => Err(self.error(ErrorCode::TrailingData)),
253            None => Ok(()),
254        }
255    }
256
257    /// Turn a CBOR deserializer into an iterator over values of type T.
258    #[allow(clippy::should_implement_trait)] // Trait doesn't allow unconstrained T.
259    pub const fn into_iter<T>(self) -> StreamDeserializer<'de, R, T>
260    where
261        T: de::Deserialize<'de>,
262    {
263        StreamDeserializer {
264            de: self,
265            output: PhantomData,
266            lifetime: PhantomData,
267        }
268    }
269
270    fn next(&mut self) -> Result<Option<u8>> {
271        self.read.next()
272    }
273
274    fn peek(&mut self) -> Result<Option<u8>> {
275        self.read.peek()
276    }
277
278    fn consume(&mut self) {
279        self.read.discard();
280    }
281
282    fn error(&self, reason: ErrorCode) -> Error {
283        let offset = self.read.offset();
284        Error::syntax(reason, offset)
285    }
286
287    fn parse_u8(&mut self) -> Result<u8> {
288        match self.next()? {
289            Some(byte) => Ok(byte),
290            None => Err(self.error(ErrorCode::EofWhileParsingValue)),
291        }
292    }
293
294    fn parse_u16(&mut self) -> Result<u16> {
295        let mut buf = [0; 2];
296        self.read
297            .read_into(&mut buf)
298            .map(|()| u16::from_be_bytes(buf))
299    }
300
301    fn parse_u32(&mut self) -> Result<u32> {
302        let mut buf = [0; 4];
303        self.read
304            .read_into(&mut buf)
305            .map(|()| u32::from_be_bytes(buf))
306    }
307
308    fn parse_u64(&mut self) -> Result<u64> {
309        let mut buf = [0; 8];
310        self.read
311            .read_into(&mut buf)
312            .map(|()| u64::from_be_bytes(buf))
313    }
314
315    fn parse_bytes<V>(&mut self, len: usize, visitor: V) -> Result<V::Value>
316    where
317        V: de::Visitor<'de>,
318    {
319        match self.read.read(len)? {
320            EitherLifetime::Long(buf) => visitor.visit_borrowed_bytes(buf),
321            EitherLifetime::Short(buf) => visitor.visit_bytes(buf),
322        }
323    }
324
325    fn parse_indefinite_bytes<V>(&mut self, visitor: V) -> Result<V::Value>
326    where
327        V: de::Visitor<'de>,
328    {
329        self.read.clear_buffer();
330        loop {
331            let byte = self.parse_u8()?;
332            let len = match byte {
333                0x40..=0x57 => byte as usize - 0x40,
334                0x58 => self.parse_u8()? as usize,
335                0x59 => self.parse_u16()? as usize,
336                0x5a => self.parse_u32()? as usize,
337                0x5b => {
338                    let len = self.parse_u64()?;
339                    if len > usize::MAX as u64 {
340                        return Err(self.error(ErrorCode::LengthOutOfRange));
341                    }
342                    len as usize
343                }
344                0xff => break,
345                _ => return Err(self.error(ErrorCode::UnexpectedCode)),
346            };
347
348            self.read.read_to_buffer(len)?;
349        }
350
351        match self.read.take_buffer() {
352            EitherLifetime::Long(buf) => visitor.visit_borrowed_bytes(buf),
353            EitherLifetime::Short(buf) => visitor.visit_bytes(buf),
354        }
355    }
356
357    fn convert_str(buf: &[u8], buf_end_offset: u64) -> Result<&str> {
358        match str::from_utf8(buf) {
359            Ok(s) => Ok(s),
360            Err(e) => {
361                let shift = buf.len() - e.valid_up_to();
362                let offset = buf_end_offset - shift as u64;
363                Err(Error::syntax(ErrorCode::InvalidUtf8, offset))
364            }
365        }
366    }
367
368    fn parse_str<V>(&mut self, len: usize, visitor: V) -> Result<V::Value>
369    where
370        V: de::Visitor<'de>,
371    {
372        if let Some(offset) = self.read.offset().checked_add(len as u64) {
373            match self.read.read(len)? {
374                EitherLifetime::Long(buf) => {
375                    let s = Self::convert_str(buf, offset)?;
376                    visitor.visit_borrowed_str(s)
377                }
378                EitherLifetime::Short(buf) => {
379                    let s = Self::convert_str(buf, offset)?;
380                    visitor.visit_str(s)
381                }
382            }
383        } else {
384            // An overflow would have occured.
385            Err(Error::syntax(
386                ErrorCode::LengthOutOfRange,
387                self.read.offset(),
388            ))
389        }
390    }
391
392    fn parse_indefinite_str<V>(&mut self, visitor: V) -> Result<V::Value>
393    where
394        V: de::Visitor<'de>,
395    {
396        self.read.clear_buffer();
397        loop {
398            let byte = self.parse_u8()?;
399            let len = match byte {
400                0x60..=0x77 => byte as usize - 0x60,
401                0x78 => self.parse_u8()? as usize,
402                0x79 => self.parse_u16()? as usize,
403                0x7a => self.parse_u32()? as usize,
404                0x7b => {
405                    let len = self.parse_u64()?;
406                    if len > usize::MAX as u64 {
407                        return Err(self.error(ErrorCode::LengthOutOfRange));
408                    }
409                    len as usize
410                }
411                0xff => break,
412                _ => return Err(self.error(ErrorCode::UnexpectedCode)),
413            };
414
415            self.read.read_to_buffer(len)?;
416        }
417
418        let offset = self.read.offset();
419        match self.read.take_buffer() {
420            EitherLifetime::Long(buf) => {
421                let s = Self::convert_str(buf, offset)?;
422                visitor.visit_borrowed_str(s)
423            }
424            EitherLifetime::Short(buf) => {
425                let s = Self::convert_str(buf, offset)?;
426                visitor.visit_str(s)
427            }
428        }
429    }
430
431    #[cfg(feature = "tags")]
432    fn handle_tagged_value<V>(&mut self, tag: u64, visitor: V) -> Result<V::Value>
433    where
434        V: de::Visitor<'de>,
435    {
436        self.recursion_checked(|d| {
437            let _guard = TagGuard::new(Some(tag));
438            visitor.visit_newtype_struct(d)
439        })
440    }
441
442    #[cfg(not(feature = "tags"))]
443    fn handle_tagged_value<V>(&mut self, _tag: u64, visitor: V) -> Result<V::Value>
444    where
445        V: de::Visitor<'de>,
446    {
447        self.recursion_checked(|de| de.parse_value(visitor))
448    }
449
450    fn recursion_checked<F, T>(&mut self, f: F) -> Result<T>
451    where
452        F: FnOnce(&mut Self) -> Result<T>,
453    {
454        self.remaining_depth -= 1;
455        if self.remaining_depth == 0 {
456            return Err(self.error(ErrorCode::RecursionLimitExceeded));
457        }
458        let r = f(self);
459        self.remaining_depth += 1;
460        r
461    }
462
463    fn parse_array<V>(&mut self, mut len: usize, visitor: V) -> Result<V::Value>
464    where
465        V: de::Visitor<'de>,
466    {
467        // Check array size limit
468        if let Some(max) = self.config.get_max_array_size() {
469            if len > max {
470                return Err(self.error(ErrorCode::ArraySizeLimitExceeded));
471            }
472        }
473
474        self.recursion_checked(|de| {
475            let value = visitor.visit_seq(SeqAccess { de, len: &mut len })?;
476
477            if len != 0 {
478                Err(de.error(ErrorCode::TrailingData))
479            } else {
480                Ok(value)
481            }
482        })
483    }
484
485    fn parse_indefinite_array<V>(&mut self, visitor: V) -> Result<V::Value>
486    where
487        V: de::Visitor<'de>,
488    {
489        let max_iterations = self.config.get_max_indefinite_iterations();
490        self.recursion_checked(|de| {
491            let value = visitor.visit_seq(IndefiniteSeqAccess {
492                de,
493                max_iterations,
494                iteration_count: 0,
495            })?;
496            match de.next()? {
497                Some(0xff) => Ok(value),
498                Some(_) => Err(de.error(ErrorCode::TrailingData)),
499                None => Err(de.error(ErrorCode::EofWhileParsingArray)),
500            }
501        })
502    }
503
504    fn parse_map<V>(&mut self, mut len: usize, visitor: V) -> Result<V::Value>
505    where
506        V: de::Visitor<'de>,
507    {
508        // Check map size limit
509        if let Some(max) = self.config.get_max_map_size() {
510            if len > max {
511                return Err(self.error(ErrorCode::MapSizeLimitExceeded));
512            }
513        }
514
515        let accept_packed = self.accept_packed;
516        let accept_named = self.accept_named;
517        self.recursion_checked(|de| {
518            let value = visitor.visit_map(MapAccess {
519                de,
520                len: &mut len,
521                accept_named,
522                accept_packed,
523            })?;
524
525            if len != 0 {
526                Err(de.error(ErrorCode::TrailingData))
527            } else {
528                Ok(value)
529            }
530        })
531    }
532
533    fn parse_indefinite_map<V>(&mut self, visitor: V) -> Result<V::Value>
534    where
535        V: de::Visitor<'de>,
536    {
537        let accept_named = self.accept_named;
538        let accept_packed = self.accept_packed;
539        let max_iterations = self.config.get_max_indefinite_iterations();
540        self.recursion_checked(|de| {
541            let value = visitor.visit_map(IndefiniteMapAccess {
542                de,
543                accept_packed,
544                accept_named,
545                max_iterations,
546                iteration_count: 0,
547            })?;
548            match de.next()? {
549                Some(0xff) => Ok(value),
550                Some(_) => Err(de.error(ErrorCode::TrailingData)),
551                None => Err(de.error(ErrorCode::EofWhileParsingMap)),
552            }
553        })
554    }
555
556    fn parse_enum<V>(&mut self, mut len: usize, visitor: V) -> Result<V::Value>
557    where
558        V: de::Visitor<'de>,
559    {
560        self.recursion_checked(|de| {
561            let value = visitor.visit_enum(VariantAccess {
562                seq: SeqAccess { de, len: &mut len },
563            })?;
564
565            if len != 0 {
566                Err(de.error(ErrorCode::TrailingData))
567            } else {
568                Ok(value)
569            }
570        })
571    }
572
573    fn parse_enum_map<V>(&mut self, visitor: V) -> Result<V::Value>
574    where
575        V: de::Visitor<'de>,
576    {
577        let accept_named = self.accept_named;
578        let accept_packed = self.accept_packed;
579        self.recursion_checked(|de| {
580            let mut len = 1;
581            let value = visitor.visit_enum(VariantAccessMap {
582                map: MapAccess {
583                    de,
584                    len: &mut len,
585                    accept_packed,
586                    accept_named,
587                },
588            })?;
589
590            if len != 0 {
591                Err(de.error(ErrorCode::TrailingData))
592            } else {
593                Ok(value)
594            }
595        })
596    }
597
598    fn parse_indefinite_enum<V>(&mut self, visitor: V) -> Result<V::Value>
599    where
600        V: de::Visitor<'de>,
601    {
602        let max_iterations = self.config.get_max_indefinite_iterations();
603        self.recursion_checked(|de| {
604            let value = visitor.visit_enum(VariantAccess {
605                seq: IndefiniteSeqAccess {
606                    de,
607                    max_iterations,
608                    iteration_count: 0,
609                },
610            })?;
611            match de.next()? {
612                Some(0xff) => Ok(value),
613                Some(_) => Err(de.error(ErrorCode::TrailingData)),
614                None => Err(de.error(ErrorCode::EofWhileParsingArray)),
615            }
616        })
617    }
618
619    fn parse_f16(&mut self) -> Result<f32> {
620        Ok(f32::from(f16::from_bits(self.parse_u16()?)))
621    }
622
623    fn parse_f32(&mut self) -> Result<f32> {
624        self.parse_u32().map(f32::from_bits)
625    }
626
627    fn parse_f64(&mut self) -> Result<f64> {
628        self.parse_u64().map(f64::from_bits)
629    }
630
631    // Don't warn about the `unreachable!` in case
632    // exhaustive integer pattern matching is enabled.
633    #[allow(unreachable_patterns)]
634    fn parse_value<V>(&mut self, visitor: V) -> Result<V::Value>
635    where
636        V: de::Visitor<'de>,
637    {
638        let byte = self.parse_u8()?;
639        match byte {
640            // Major type 0: an unsigned integer
641            0x00..=0x17 => visitor.visit_u8(byte),
642            0x18 => {
643                let value = self.parse_u8()?;
644                visitor.visit_u8(value)
645            }
646            0x19 => {
647                let value = self.parse_u16()?;
648                visitor.visit_u16(value)
649            }
650            0x1a => {
651                let value = self.parse_u32()?;
652                visitor.visit_u32(value)
653            }
654            0x1b => {
655                let value = self.parse_u64()?;
656                visitor.visit_u64(value)
657            }
658            0x1c..=0x1f => Err(self.error(ErrorCode::UnassignedCode)),
659
660            // Major type 1: a negative integer
661            0x20..=0x37 => visitor.visit_i8(-1 - (byte - 0x20) as i8),
662            0x38 => {
663                let value = self.parse_u8()?;
664                visitor.visit_i16(-1 - i16::from(value))
665            }
666            0x39 => {
667                let value = self.parse_u16()?;
668                visitor.visit_i32(-1 - i32::from(value))
669            }
670            0x3a => {
671                let value = self.parse_u32()?;
672                visitor.visit_i64(-1 - i64::from(value))
673            }
674            0x3b => {
675                let value = self.parse_u64()?;
676                if value > i64::MAX as u64 {
677                    return visitor.visit_i128(-1 - i128::from(value));
678                }
679                visitor.visit_i64(-1 - value as i64)
680            }
681            0x3c..=0x3f => Err(self.error(ErrorCode::UnassignedCode)),
682
683            // Major type 2: a byte string
684            0x40..=0x57 => self.parse_bytes(byte as usize - 0x40, visitor),
685            0x58 => {
686                let len = self.parse_u8()?;
687                self.parse_bytes(len as usize, visitor)
688            }
689            0x59 => {
690                let len = self.parse_u16()?;
691                self.parse_bytes(len as usize, visitor)
692            }
693            0x5a => {
694                let len = self.parse_u32()?;
695                self.parse_bytes(len as usize, visitor)
696            }
697            0x5b => {
698                let len = self.parse_u64()?;
699                if len > usize::MAX as u64 {
700                    return Err(self.error(ErrorCode::LengthOutOfRange));
701                }
702                self.parse_bytes(len as usize, visitor)
703            }
704            0x5c..=0x5e => Err(self.error(ErrorCode::UnassignedCode)),
705            0x5f => self.parse_indefinite_bytes(visitor),
706
707            // Major type 3: a text string
708            0x60..=0x77 => self.parse_str(byte as usize - 0x60, visitor),
709            0x78 => {
710                let len = self.parse_u8()?;
711                self.parse_str(len as usize, visitor)
712            }
713            0x79 => {
714                let len = self.parse_u16()?;
715                self.parse_str(len as usize, visitor)
716            }
717            0x7a => {
718                let len = self.parse_u32()?;
719                self.parse_str(len as usize, visitor)
720            }
721            0x7b => {
722                let len = self.parse_u64()?;
723                if len > usize::MAX as u64 {
724                    return Err(self.error(ErrorCode::LengthOutOfRange));
725                }
726                self.parse_str(len as usize, visitor)
727            }
728            0x7c..=0x7e => Err(self.error(ErrorCode::UnassignedCode)),
729            0x7f => self.parse_indefinite_str(visitor),
730
731            // Major type 4: an array of data items
732            0x80..=0x97 => self.parse_array(byte as usize - 0x80, visitor),
733            0x98 => {
734                let len = self.parse_u8()?;
735                self.parse_array(len as usize, visitor)
736            }
737            0x99 => {
738                let len = self.parse_u16()?;
739                self.parse_array(len as usize, visitor)
740            }
741            0x9a => {
742                let len = self.parse_u32()?;
743                self.parse_array(len as usize, visitor)
744            }
745            0x9b => {
746                let len = self.parse_u64()?;
747                if len > usize::MAX as u64 {
748                    return Err(self.error(ErrorCode::LengthOutOfRange));
749                }
750                self.parse_array(len as usize, visitor)
751            }
752            0x9c..=0x9e => Err(self.error(ErrorCode::UnassignedCode)),
753            0x9f => self.parse_indefinite_array(visitor),
754
755            // Major type 5: a map of pairs of data items
756            0xa0..=0xb7 => self.parse_map(byte as usize - 0xa0, visitor),
757            0xb8 => {
758                let len = self.parse_u8()?;
759                self.parse_map(len as usize, visitor)
760            }
761            0xb9 => {
762                let len = self.parse_u16()?;
763                self.parse_map(len as usize, visitor)
764            }
765            0xba => {
766                let len = self.parse_u32()?;
767                self.parse_map(len as usize, visitor)
768            }
769            0xbb => {
770                let len = self.parse_u64()?;
771                if len > usize::MAX as u64 {
772                    return Err(self.error(ErrorCode::LengthOutOfRange));
773                }
774                self.parse_map(len as usize, visitor)
775            }
776            0xbc..=0xbe => Err(self.error(ErrorCode::UnassignedCode)),
777            0xbf => self.parse_indefinite_map(visitor),
778
779            // Major type 6: optional semantic tagging of other major types
780            0xc0..=0xd7 => {
781                let tag = u64::from(byte) - 0xc0;
782                self.handle_tagged_value(tag, visitor)
783            }
784            0xd8 => {
785                let tag = self.parse_u8()?;
786                self.handle_tagged_value(tag.into(), visitor)
787            }
788            0xd9 => {
789                let tag = self.parse_u16()?;
790                self.handle_tagged_value(tag.into(), visitor)
791            }
792            0xda => {
793                let tag = self.parse_u32()?;
794                self.handle_tagged_value(tag.into(), visitor)
795            }
796            0xdb => {
797                let tag = self.parse_u64()?;
798                self.handle_tagged_value(tag, visitor)
799            }
800            0xdc..=0xdf => Err(self.error(ErrorCode::UnassignedCode)),
801
802            // Major type 7: floating-point numbers and other simple data types that need no content
803            0xe0..=0xf3 => Err(self.error(ErrorCode::UnassignedCode)),
804            0xf4 => visitor.visit_bool(false),
805            0xf5 => visitor.visit_bool(true),
806            0xf6 => visitor.visit_unit(),
807            0xf7 => visitor.visit_unit(),
808            0xf8 => Err(self.error(ErrorCode::UnassignedCode)),
809            0xf9 => {
810                let value = self.parse_f16()?;
811                visitor.visit_f32(value)
812            }
813            0xfa => {
814                let value = self.parse_f32()?;
815                visitor.visit_f32(value)
816            }
817            0xfb => {
818                let value = self.parse_f64()?;
819                visitor.visit_f64(value)
820            }
821            0xfc..=0xfe => Err(self.error(ErrorCode::UnassignedCode)),
822            0xff => Err(self.error(ErrorCode::UnexpectedCode)),
823
824            _ => unreachable!(),
825        }
826    }
827}
828
829impl<'de, R> de::Deserializer<'de> for &mut Deserializer<R>
830where
831    R: Read<'de>,
832{
833    type Error = Error;
834
835    #[inline]
836    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
837    where
838        V: de::Visitor<'de>,
839    {
840        self.parse_value(visitor)
841    }
842
843    #[inline]
844    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
845    where
846        V: de::Visitor<'de>,
847    {
848        match self.peek()? {
849            Some(0xf6) => {
850                self.consume();
851                visitor.visit_none()
852            }
853            _ => visitor.visit_some(self),
854        }
855    }
856
857    #[inline]
858    fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value>
859    where
860        V: de::Visitor<'de>,
861    {
862        visitor.visit_newtype_struct(self)
863    }
864
865    // Unit variants are encoded as just the variant identifier.
866    // Tuple variants are encoded as an array of the variant identifier followed by the fields.
867    // Struct variants are encoded as an array of the variant identifier followed by the struct.
868    #[inline]
869    fn deserialize_enum<V>(
870        self,
871        _name: &str,
872        _variants: &'static [&'static str],
873        visitor: V,
874    ) -> Result<V::Value>
875    where
876        V: de::Visitor<'de>,
877    {
878        match self.peek()? {
879            Some(byte @ 0x80..=0x9f) => {
880                if !self.accept_legacy_enums {
881                    return Err(self.error(ErrorCode::WrongEnumFormat));
882                }
883                self.consume();
884                match byte {
885                    0x80..=0x97 => self.parse_enum(byte as usize - 0x80, visitor),
886                    0x98 => {
887                        let len = self.parse_u8()?;
888                        self.parse_enum(len as usize, visitor)
889                    }
890                    0x99 => {
891                        let len = self.parse_u16()?;
892                        self.parse_enum(len as usize, visitor)
893                    }
894                    0x9a => {
895                        let len = self.parse_u32()?;
896                        self.parse_enum(len as usize, visitor)
897                    }
898                    0x9b => {
899                        let len = self.parse_u64()?;
900                        if len > usize::MAX as u64 {
901                            return Err(self.error(ErrorCode::LengthOutOfRange));
902                        }
903                        self.parse_enum(len as usize, visitor)
904                    }
905                    0x9c..=0x9e => Err(self.error(ErrorCode::UnassignedCode)),
906                    0x9f => self.parse_indefinite_enum(visitor),
907
908                    _ => unreachable!(),
909                }
910            }
911            Some(0xa1) => {
912                if !self.accept_standard_enums {
913                    return Err(self.error(ErrorCode::WrongEnumFormat));
914                }
915                self.consume();
916                self.parse_enum_map(visitor)
917            }
918            None => Err(self.error(ErrorCode::EofWhileParsingValue)),
919            _ => {
920                if !self.accept_standard_enums && !self.accept_legacy_enums {
921                    return Err(self.error(ErrorCode::WrongEnumFormat));
922                }
923                visitor.visit_enum(UnitVariantAccess { de: self })
924            }
925        }
926    }
927
928    #[inline]
929    fn is_human_readable(&self) -> bool {
930        false
931    }
932
933    serde::forward_to_deserialize_any! {
934        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string unit
935        unit_struct seq tuple tuple_struct map struct identifier ignored_any
936        bytes byte_buf
937    }
938}
939
940impl<R> Deserializer<R>
941where
942    R: Offset,
943{
944    /// Return the current offset in the reader
945    #[inline]
946    pub fn byte_offset(&self) -> usize {
947        self.read.byte_offset()
948    }
949}
950
951trait MakeError {
952    fn error(&self, code: ErrorCode) -> Error;
953}
954
955struct SeqAccess<'a, R> {
956    de: &'a mut Deserializer<R>,
957    len: &'a mut usize,
958}
959
960impl<'de, R> de::SeqAccess<'de> for SeqAccess<'_, R>
961where
962    R: Read<'de>,
963{
964    type Error = Error;
965
966    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
967    where
968        T: de::DeserializeSeed<'de>,
969    {
970        if *self.len == 0 {
971            return Ok(None);
972        }
973        *self.len -= 1;
974
975        let value = seed.deserialize(&mut *self.de)?;
976        Ok(Some(value))
977    }
978
979    fn size_hint(&self) -> Option<usize> {
980        Some(*self.len)
981    }
982}
983
984impl<'de, R> MakeError for SeqAccess<'_, R>
985where
986    R: Read<'de>,
987{
988    fn error(&self, code: ErrorCode) -> Error {
989        self.de.error(code)
990    }
991}
992
993struct IndefiniteSeqAccess<'a, R> {
994    de: &'a mut Deserializer<R>,
995    max_iterations: Option<usize>,
996    iteration_count: usize,
997}
998
999impl<'de, R> de::SeqAccess<'de> for IndefiniteSeqAccess<'_, R>
1000where
1001    R: Read<'de>,
1002{
1003    type Error = Error;
1004
1005    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
1006    where
1007        T: de::DeserializeSeed<'de>,
1008    {
1009        // Check iteration limit
1010        if let Some(max) = self.max_iterations {
1011            if self.iteration_count >= max {
1012                return Err(self.de.error(ErrorCode::IndefiniteIterationLimitExceeded));
1013            }
1014        }
1015
1016        match self.de.peek()? {
1017            Some(0xff) => return Ok(None),
1018            Some(_) => {}
1019            None => return Err(self.de.error(ErrorCode::EofWhileParsingArray)),
1020        }
1021
1022        self.iteration_count += 1;
1023        let value = seed.deserialize(&mut *self.de)?;
1024        Ok(Some(value))
1025    }
1026}
1027
1028impl<'de, R> MakeError for IndefiniteSeqAccess<'_, R>
1029where
1030    R: Read<'de>,
1031{
1032    fn error(&self, code: ErrorCode) -> Error {
1033        self.de.error(code)
1034    }
1035}
1036
1037struct MapAccess<'a, R> {
1038    de: &'a mut Deserializer<R>,
1039    len: &'a mut usize,
1040    accept_named: bool,
1041    accept_packed: bool,
1042}
1043
1044impl<'de, R> de::MapAccess<'de> for MapAccess<'_, R>
1045where
1046    R: Read<'de>,
1047{
1048    type Error = Error;
1049
1050    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
1051    where
1052        K: de::DeserializeSeed<'de>,
1053    {
1054        if *self.len == 0 {
1055            return Ok(None);
1056        }
1057        *self.len -= 1;
1058
1059        match self.de.peek()? {
1060            Some(_byte @ 0x00..=0x1b) if !self.accept_packed => {
1061                return Err(self.de.error(ErrorCode::WrongStructFormat));
1062            }
1063            Some(_byte @ 0x60..=0x7f) if !self.accept_named => {
1064                return Err(self.de.error(ErrorCode::WrongStructFormat));
1065            }
1066            _ => {}
1067        }
1068
1069        let value = seed.deserialize(&mut *self.de)?;
1070        Ok(Some(value))
1071    }
1072
1073    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
1074    where
1075        V: de::DeserializeSeed<'de>,
1076    {
1077        seed.deserialize(&mut *self.de)
1078    }
1079
1080    fn size_hint(&self) -> Option<usize> {
1081        Some(*self.len)
1082    }
1083}
1084
1085impl<'de, R> MakeError for MapAccess<'_, R>
1086where
1087    R: Read<'de>,
1088{
1089    fn error(&self, code: ErrorCode) -> Error {
1090        self.de.error(code)
1091    }
1092}
1093
1094struct IndefiniteMapAccess<'a, R> {
1095    de: &'a mut Deserializer<R>,
1096    accept_packed: bool,
1097    accept_named: bool,
1098    max_iterations: Option<usize>,
1099    iteration_count: usize,
1100}
1101
1102impl<'de, R> de::MapAccess<'de> for IndefiniteMapAccess<'_, R>
1103where
1104    R: Read<'de>,
1105{
1106    type Error = Error;
1107
1108    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
1109    where
1110        K: de::DeserializeSeed<'de>,
1111    {
1112        // Check iteration limit
1113        if let Some(max) = self.max_iterations {
1114            if self.iteration_count >= max {
1115                return Err(self.de.error(ErrorCode::IndefiniteIterationLimitExceeded));
1116            }
1117        }
1118
1119        match self.de.peek()? {
1120            Some(_byte @ 0x00..=0x1b) if !self.accept_packed => {
1121                return Err(self.de.error(ErrorCode::WrongStructFormat))
1122            }
1123            Some(_byte @ 0x60..=0x7f) if !self.accept_named => {
1124                return Err(self.de.error(ErrorCode::WrongStructFormat))
1125            }
1126            Some(0xff) => return Ok(None),
1127            Some(_) => {}
1128            None => return Err(self.de.error(ErrorCode::EofWhileParsingMap)),
1129        }
1130
1131        self.iteration_count += 1;
1132        let value = seed.deserialize(&mut *self.de)?;
1133        Ok(Some(value))
1134    }
1135
1136    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
1137    where
1138        V: de::DeserializeSeed<'de>,
1139    {
1140        seed.deserialize(&mut *self.de)
1141    }
1142}
1143
1144struct UnitVariantAccess<'a, R> {
1145    de: &'a mut Deserializer<R>,
1146}
1147
1148impl<'de, R> de::EnumAccess<'de> for UnitVariantAccess<'_, R>
1149where
1150    R: Read<'de>,
1151{
1152    type Error = Error;
1153    type Variant = Self;
1154
1155    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self)>
1156    where
1157        V: de::DeserializeSeed<'de>,
1158    {
1159        let variant = seed.deserialize(&mut *self.de)?;
1160        Ok((variant, self))
1161    }
1162}
1163
1164impl<'de, R> de::VariantAccess<'de> for UnitVariantAccess<'_, R>
1165where
1166    R: Read<'de>,
1167{
1168    type Error = Error;
1169
1170    fn unit_variant(self) -> Result<()> {
1171        Ok(())
1172    }
1173
1174    fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value>
1175    where
1176        T: de::DeserializeSeed<'de>,
1177    {
1178        Err(de::Error::invalid_type(
1179            de::Unexpected::UnitVariant,
1180            &"newtype variant",
1181        ))
1182    }
1183
1184    fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value>
1185    where
1186        V: de::Visitor<'de>,
1187    {
1188        Err(de::Error::invalid_type(
1189            de::Unexpected::UnitVariant,
1190            &"tuple variant",
1191        ))
1192    }
1193
1194    fn struct_variant<V>(self, _fields: &'static [&'static str], _visitor: V) -> Result<V::Value>
1195    where
1196        V: de::Visitor<'de>,
1197    {
1198        Err(de::Error::invalid_type(
1199            de::Unexpected::UnitVariant,
1200            &"struct variant",
1201        ))
1202    }
1203}
1204
1205struct VariantAccess<T> {
1206    seq: T,
1207}
1208
1209impl<'de, T> de::EnumAccess<'de> for VariantAccess<T>
1210where
1211    T: de::SeqAccess<'de, Error = Error> + MakeError,
1212{
1213    type Error = Error;
1214    type Variant = Self;
1215
1216    fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self)>
1217    where
1218        V: de::DeserializeSeed<'de>,
1219    {
1220        let variant = match self.seq.next_element_seed(seed) {
1221            Ok(Some(variant)) => variant,
1222            Ok(None) => return Err(self.seq.error(ErrorCode::ArrayTooShort)),
1223            Err(e) => return Err(e),
1224        };
1225        Ok((variant, self))
1226    }
1227}
1228
1229impl<'de, T> de::VariantAccess<'de> for VariantAccess<T>
1230where
1231    T: de::SeqAccess<'de, Error = Error> + MakeError,
1232{
1233    type Error = Error;
1234
1235    fn unit_variant(mut self) -> Result<()> {
1236        match self.seq.next_element() {
1237            Ok(Some(())) => Ok(()),
1238            Ok(None) => Err(self.seq.error(ErrorCode::ArrayTooLong)),
1239            Err(e) => Err(e),
1240        }
1241    }
1242
1243    fn newtype_variant_seed<S>(mut self, seed: S) -> Result<S::Value>
1244    where
1245        S: de::DeserializeSeed<'de>,
1246    {
1247        match self.seq.next_element_seed(seed) {
1248            Ok(Some(variant)) => Ok(variant),
1249            Ok(None) => Err(self.seq.error(ErrorCode::ArrayTooShort)),
1250            Err(e) => Err(e),
1251        }
1252    }
1253
1254    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
1255    where
1256        V: de::Visitor<'de>,
1257    {
1258        visitor.visit_seq(self.seq)
1259    }
1260
1261    fn struct_variant<V>(mut self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
1262    where
1263        V: de::Visitor<'de>,
1264    {
1265        let seed = StructVariantSeed { visitor };
1266        match self.seq.next_element_seed(seed) {
1267            Ok(Some(variant)) => Ok(variant),
1268            Ok(None) => Err(self.seq.error(ErrorCode::ArrayTooShort)),
1269            Err(e) => Err(e),
1270        }
1271    }
1272}
1273
1274struct StructVariantSeed<V> {
1275    visitor: V,
1276}
1277
1278impl<'de, V> de::DeserializeSeed<'de> for StructVariantSeed<V>
1279where
1280    V: de::Visitor<'de>,
1281{
1282    type Value = V::Value;
1283
1284    fn deserialize<D>(self, de: D) -> result::Result<V::Value, D::Error>
1285    where
1286        D: de::Deserializer<'de>,
1287    {
1288        de.deserialize_any(self.visitor)
1289    }
1290}
1291
1292/// Iterator that deserializes a stream into multiple CBOR values.
1293///
1294/// A stream deserializer can be created from any CBOR deserializer using the
1295/// `Deserializer::into_iter` method.
1296///
1297/// ```
1298/// # extern crate multi_cbor;
1299/// use multi_cbor::de::Deserializer;
1300/// use multi_cbor::value::Value;
1301///
1302/// # fn main() {
1303/// let data: Vec<u8> = vec![
1304///     0x01, 0x66, 0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72,
1305/// ];
1306/// let mut it = Deserializer::from_slice(&data[..]).into_iter::<Value>();
1307/// assert_eq!(
1308///     Value::Integer(1),
1309///     it.next().unwrap().unwrap()
1310/// );
1311/// assert_eq!(
1312///     Value::Text("foobar".to_string()),
1313///     it.next().unwrap().unwrap()
1314/// );
1315/// # }
1316/// ```
1317#[derive(Debug)]
1318pub struct StreamDeserializer<'de, R, T> {
1319    de: Deserializer<R>,
1320    output: PhantomData<T>,
1321    lifetime: PhantomData<&'de ()>,
1322}
1323
1324impl<'de, R, T> StreamDeserializer<'de, R, T>
1325where
1326    R: Read<'de>,
1327    T: de::Deserialize<'de>,
1328{
1329    /// Create a new CBOR stream deserializer from one of the possible
1330    /// `multi_cbor` input sources.
1331    ///
1332    /// Typically it is more convenient to use one of these methods instead:
1333    ///
1334    /// * `Deserializer::from_slice(...).into_iter()`
1335    /// * `Deserializer::from_reader(...).into_iter()`
1336    pub fn new(read: R) -> Self {
1337        StreamDeserializer {
1338            de: Deserializer::new(read),
1339            output: PhantomData,
1340            lifetime: PhantomData,
1341        }
1342    }
1343}
1344
1345impl<'de, R, T> StreamDeserializer<'de, R, T>
1346where
1347    R: Offset,
1348    T: de::Deserialize<'de>,
1349{
1350    /// Return the current offset in the reader
1351    #[inline]
1352    pub fn byte_offset(&self) -> usize {
1353        self.de.byte_offset()
1354    }
1355}
1356
1357impl<'de, R, T> Iterator for StreamDeserializer<'de, R, T>
1358where
1359    R: Read<'de>,
1360    T: de::Deserialize<'de>,
1361{
1362    type Item = Result<T>;
1363
1364    fn next(&mut self) -> Option<Result<T>> {
1365        match self.de.peek() {
1366            Ok(Some(_)) => Some(T::deserialize(&mut self.de)),
1367            Ok(None) => None,
1368            Err(e) => Some(Err(e)),
1369        }
1370    }
1371}
1372
1373struct VariantAccessMap<T> {
1374    map: T,
1375}
1376
1377impl<'de, T> de::EnumAccess<'de> for VariantAccessMap<T>
1378where
1379    T: de::MapAccess<'de, Error = Error> + MakeError,
1380{
1381    type Error = Error;
1382    type Variant = Self;
1383
1384    fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self)>
1385    where
1386        V: de::DeserializeSeed<'de>,
1387    {
1388        let variant = match self.map.next_key_seed(seed) {
1389            Ok(Some(variant)) => variant,
1390            Ok(None) => return Err(self.map.error(ErrorCode::ArrayTooShort)),
1391            Err(e) => return Err(e),
1392        };
1393        Ok((variant, self))
1394    }
1395}
1396
1397impl<'de, T> de::VariantAccess<'de> for VariantAccessMap<T>
1398where
1399    T: de::MapAccess<'de, Error = Error> + MakeError,
1400{
1401    type Error = Error;
1402
1403    fn unit_variant(mut self) -> Result<()> {
1404        match self.map.next_value() {
1405            Ok(()) => Ok(()),
1406            Err(e) => Err(e),
1407        }
1408    }
1409
1410    fn newtype_variant_seed<S>(mut self, seed: S) -> Result<S::Value>
1411    where
1412        S: de::DeserializeSeed<'de>,
1413    {
1414        self.map.next_value_seed(seed)
1415    }
1416
1417    fn tuple_variant<V>(mut self, _len: usize, visitor: V) -> Result<V::Value>
1418    where
1419        V: de::Visitor<'de>,
1420    {
1421        let seed = StructVariantSeed { visitor };
1422        self.map.next_value_seed(seed)
1423    }
1424
1425    fn struct_variant<V>(mut self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
1426    where
1427        V: de::Visitor<'de>,
1428    {
1429        let seed = StructVariantSeed { visitor };
1430        self.map.next_value_seed(seed)
1431    }
1432}
multi_cbor/de.rs

multi_cbor/
de.rs
