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

cs_serde_cbor/
de.rs
