cbor_smol/
de.rs

1use core::convert::TryInto;
2
3use serde_core as serde;
4
5use serde::de::{self, Deserialize, DeserializeSeed, IntoDeserializer, Visitor};
6
7use super::error::{Error, Result};
8use crate::consts::*;
9
10/// Deserialize a message of type `T` from a byte slice. The unused portion (if any)
11/// of the byte slice is returned for further usage
12pub fn from_bytes<'a, T>(s: &'a [u8]) -> Result<T>
13where
14    T: Deserialize<'a>,
15{
16    let mut deserializer = Deserializer::from_bytes(s);
17    let t = T::deserialize(&mut deserializer)?;
18    Ok(t)
19}
20
21/// Deserialize a message of type `T` from a byte slice. The unused portion (if any)
22/// of the byte slice is returned for further usage
23pub fn take_from_bytes<'a, T>(s: &'a [u8]) -> Result<(T, &'a [u8])>
24where
25    T: Deserialize<'a>,
26{
27    let mut deserializer = Deserializer::from_bytes(s);
28    let t = T::deserialize(&mut deserializer)?;
29    Ok((t, deserializer.input))
30}
31
32////////////////////////////////////////////////////////////////////////////////
33
34/// A structure for deserializing a cbor-smol message.
35pub struct Deserializer<'de> {
36    // This string starts with the input data and characters are truncated off
37    // the beginning as data is parsed.
38    pub(crate) input: &'de [u8],
39}
40
41impl<'de> Deserializer<'de> {
42    /// Obtain a Deserializer from a slice of bytes
43    pub fn from_bytes(input: &'de [u8]) -> Self {
44        Deserializer { input }
45    }
46}
47
48impl<'de> Deserializer<'de> {
49    fn try_take_n(&mut self, count: usize) -> Result<&'de [u8]> {
50        if self.input.len() >= count {
51            let (a, b) = self.input.split_at(count);
52            self.input = b;
53            Ok(a)
54        } else {
55            Err(Error::DeserializeUnexpectedEnd)
56        }
57    }
58
59    fn peek_major(&mut self) -> Result<u8> {
60        if !self.input.is_empty() {
61            let byte = self.input[0];
62            Ok(byte >> MAJOR_OFFSET)
63        } else {
64            Err(Error::DeserializeUnexpectedEnd)
65        }
66    }
67
68    fn peek(&mut self) -> Result<u8> {
69        if !self.input.is_empty() {
70            Ok(self.input[0])
71        } else {
72            Err(Error::DeserializeUnexpectedEnd)
73        }
74    }
75
76    fn consume(&mut self) -> Result<u8> {
77        if !self.input.is_empty() {
78            let ret = self.input[0];
79            self.input = &self.input[1..];
80            Ok(ret)
81        } else {
82            Err(Error::DeserializeUnexpectedEnd)
83        }
84    }
85
86    fn expect_major(&mut self, major: u8) -> Result<u8> {
87        let byte = self.try_take_n(1)?[0];
88        if major != (byte >> MAJOR_OFFSET) {
89            // logging::info_now!("expecting {}, got {} in byte {}", major, byte >> 5, byte).ok();
90            // logging::info_now!("remaining data: {:?}", &self.input).ok();
91            return Err(Error::DeserializeBadMajor);
92        }
93        Ok(byte & ((1 << MAJOR_OFFSET) - 1))
94    }
95
96    // TODO: name something like "one-byte-integer"
97    fn raw_deserialize_u8(&mut self, major: u8) -> Result<u8> {
98        let additional = self.expect_major(major)?;
99
100        match additional {
101            byte @ 0..=23 => Ok(byte),
102            24 => match self.try_take_n(1)?[0] {
103                0..=23 => Err(Error::DeserializeNonMinimal),
104                byte => Ok(byte),
105            },
106            _ => Err(Error::DeserializeBadU8),
107        }
108    }
109
110    fn raw_deserialize_u16(&mut self, major: u8) -> Result<u16> {
111        let number = self.raw_deserialize_u32(major)?;
112        if number <= u16::MAX as u32 {
113            Ok(number as u16)
114        } else {
115            Err(Error::DeserializeBadU16)
116        }
117    }
118
119    fn raw_deserialize_u32(&mut self, major: u8) -> Result<u32> {
120        let additional = self.expect_major(major)?;
121
122        match additional {
123            byte @ 0..=23 => Ok(byte as u32),
124            24 => match self.try_take_n(1)?[0] {
125                0..=23 => Err(Error::DeserializeNonMinimal),
126                byte => Ok(byte as u32),
127            },
128            25 => {
129                let unsigned = u16::from_be_bytes(
130                    self.try_take_n(2)?
131                        .try_into()
132                        .map_err(|_| Error::InexistentSliceToArrayError)?,
133                );
134                match unsigned {
135                    0..=255 => Err(Error::DeserializeNonMinimal),
136                    unsigned => Ok(unsigned as u32),
137                }
138            }
139            26 => {
140                let unsigned = u32::from_be_bytes(
141                    self.try_take_n(4)?
142                        .try_into()
143                        .map_err(|_| Error::InexistentSliceToArrayError)?,
144                );
145                match unsigned {
146                    0..=65535 => Err(Error::DeserializeNonMinimal),
147                    unsigned => Ok(unsigned),
148                }
149            }
150            _ => Err(Error::DeserializeBadU32),
151        }
152    }
153    fn raw_deserialize_u64(&mut self, major: u8) -> Result<u64> {
154        let additional = self.expect_major(major)?;
155
156        match additional {
157            byte @ 0..=23 => Ok(byte as u64),
158            24 => match self.try_take_n(1)?[0] {
159                0..=23 => Err(Error::DeserializeNonMinimal),
160                byte => Ok(byte as u64),
161            },
162            25 => {
163                let unsigned = u16::from_be_bytes(
164                    self.try_take_n(2)?
165                        .try_into()
166                        .map_err(|_| Error::InexistentSliceToArrayError)?,
167                );
168                match unsigned {
169                    0..=255 => Err(Error::DeserializeNonMinimal),
170                    unsigned => Ok(unsigned as u64),
171                }
172            }
173            26 => {
174                let unsigned = u32::from_be_bytes(
175                    self.try_take_n(4)?
176                        .try_into()
177                        .map_err(|_| Error::InexistentSliceToArrayError)?,
178                );
179                match unsigned {
180                    0..=65535 => Err(Error::DeserializeNonMinimal),
181                    unsigned => Ok(unsigned as u64),
182                }
183            }
184            27 => {
185                let unsigned = u64::from_be_bytes(
186                    self.try_take_n(8)?
187                        .try_into()
188                        .map_err(|_| Error::InexistentSliceToArrayError)?,
189                );
190                match unsigned {
191                    0..=0xFFFFFFFF => Err(Error::DeserializeNonMinimal),
192                    unsigned => Ok(unsigned),
193                }
194            }
195            _ => Err(Error::DeserializeBadU64),
196        }
197    }
198
199    fn ignore_int(&mut self, major: u8) -> Result<()> {
200        let additional = self.expect_major(major)?;
201        match additional {
202            0..=23 => {}
203            24 => {
204                self.try_take_n(1)?;
205            }
206            25 => {
207                self.try_take_n(2)?;
208            }
209            26 => {
210                self.try_take_n(4)?;
211            }
212            27 => {
213                self.try_take_n(8)?;
214            }
215            _ => return Err(Error::DeserializeBadU16),
216        };
217        Ok(())
218    }
219
220    fn ignore_bytes(&mut self, major: u8) -> Result<()> {
221        let length = self.raw_deserialize_u32(major)? as usize;
222        self.try_take_n(length)?;
223        Ok(())
224    }
225
226    fn ignore_array(&mut self, major: u8, mult: usize) -> Result<()> {
227        let length = self.raw_deserialize_u32(major)? as usize;
228        let Some(real_length) = length.checked_mul(mult) else {
229            return Err(Error::InexistentSliceToArrayError);
230        };
231        for _ in 0..real_length {
232            self.ignore()?;
233        }
234        Ok(())
235    }
236
237    fn ignore_float(&mut self) -> Result<()> {
238        let additional = self.expect_major(7)?;
239        match additional {
240            0..=23 => {}
241            24 => {
242                self.try_take_n(1)?;
243            }
244            25 => {
245                self.try_take_n(2)?;
246            }
247            26 => {
248                self.try_take_n(4)?;
249            }
250            27 => {
251                self.try_take_n(8)?;
252            }
253            _ => return Err(Error::DeserializeBadMajor),
254        };
255        Ok(())
256    }
257
258    fn ignore(&mut self) -> Result<()> {
259        let major = self.peek_major()?;
260        match major {
261            MAJOR_POSINT | MAJOR_NEGINT => self.ignore_int(major)?,
262            MAJOR_BYTES | MAJOR_STR => self.ignore_bytes(major)?,
263            MAJOR_ARRAY => self.ignore_array(MAJOR_ARRAY, 1)?,
264            MAJOR_MAP => self.ignore_array(MAJOR_MAP, 2)?,
265            6 => {
266                self.ignore_int(6)?;
267                self.ignore()?;
268            }
269            MAJOR_FLOAT => self.ignore_float()?,
270            _ => return Err(Error::DeserializeBadMajor),
271        }
272        Ok(())
273    }
274
275    // fn try_take_varint(&mut self) -> Result<usize> {
276    //     for i in 0..VarintUsize::varint_usize_max() {
277    //         let val = self.input.get(i).ok_or(Error::DeserializeUnexpectedEnd)?;
278    //         if (val & 0x80) == 0 {
279    //             let (a, b) = self.input.split_at(i + 1);
280    //             self.input = b;
281    //             let mut out = 0usize;
282    //             for byte in a.iter().rev() {
283    //                 out <<= 7;
284    //                 out |= (byte & 0x7F) as usize;
285    //             }
286    //             return Ok(out);
287    //         }
288    //     }
289
290    //     Err(Error::DeserializeBadVarint)
291    // }
292}
293
294struct SeqAccess<'a, 'b: 'a> {
295    deserializer: &'a mut Deserializer<'b>,
296    len: usize,
297}
298
299impl<'a, 'b: 'a> serde::de::SeqAccess<'b> for SeqAccess<'a, 'b> {
300    type Error = Error;
301
302    fn next_element_seed<V>(&mut self, seed: V) -> Result<Option<V::Value>>
303    where
304        V: DeserializeSeed<'b>,
305    {
306        if self.len > 0 {
307            self.len -= 1;
308            Ok(Some(seed.deserialize(&mut *self.deserializer)?))
309        } else {
310            Ok(None)
311        }
312    }
313
314    fn size_hint(&self) -> Option<usize> {
315        Some(self.len)
316    }
317}
318
319struct MapAccess<'a, 'b: 'a> {
320    deserializer: &'a mut Deserializer<'b>,
321    len: usize,
322}
323
324impl<'a, 'b: 'a> serde::de::MapAccess<'b> for MapAccess<'a, 'b> {
325    type Error = Error;
326
327    fn next_key_seed<V>(&mut self, seed: V) -> Result<Option<V::Value>>
328    where
329        V: DeserializeSeed<'b>,
330    {
331        if self.len > 0 {
332            self.len -= 1;
333            Ok(Some(seed.deserialize(&mut *self.deserializer)?))
334        } else {
335            Ok(None)
336        }
337    }
338
339    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
340    where
341        V: de::DeserializeSeed<'b>,
342    {
343        seed.deserialize(&mut *self.deserializer)
344    }
345
346    fn size_hint(&self) -> Option<usize> {
347        Some(self.len)
348    }
349}
350
351struct EnumAccess<'a, 'b: 'a> {
352    deserializer: &'a mut Deserializer<'b>,
353    variant_len: usize,
354}
355
356impl<'de, 'a> serde::de::VariantAccess<'de> for EnumAccess<'a, 'de> {
357    type Error = Error;
358
359    fn unit_variant(self) -> Result<()> {
360        if self.variant_len != 0 {
361            return Err(Error::DeserializeBadEnum);
362        }
363        Ok(())
364    }
365
366    fn newtype_variant_seed<V: DeserializeSeed<'de>>(self, seed: V) -> Result<V::Value> {
367        if 2 != self.variant_len {
368            return Err(Error::DeserializeBadEnum);
369        }
370        DeserializeSeed::deserialize(seed, self.deserializer)
371    }
372
373    fn tuple_variant<V: Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value> {
374        if len + 1 != self.variant_len {
375            return Err(Error::DeserializeBadEnum);
376        }
377
378        visitor.visit_seq(SeqAccess {
379            deserializer: self.deserializer,
380            len,
381        })
382    }
383
384    fn struct_variant<V: Visitor<'de>>(
385        self,
386        _fields: &'static [&'static str],
387        visitor: V,
388    ) -> Result<V::Value> {
389        if 2 != self.variant_len {
390            return Err(Error::DeserializeBadEnum);
391        }
392        serde::de::Deserializer::deserialize_map(self.deserializer, visitor)
393    }
394}
395
396impl<'de, 'a> serde::de::EnumAccess<'de> for EnumAccess<'a, 'de> {
397    type Error = Error;
398    type Variant = Self;
399
400    fn variant_seed<V: DeserializeSeed<'de>>(self, seed: V) -> Result<(V::Value, Self)> {
401        let discriminant = self.deserializer.raw_deserialize_u32(MAJOR_POSINT)?;
402        // if discriminant > 0xFFFF_FFFF {
403        //     return Err(Error::DeserializeBadEnum);
404        // }
405        let v = DeserializeSeed::deserialize(seed, discriminant.into_deserializer())?;
406        Ok((v, self))
407    }
408}
409
410impl<'de> de::Deserializer<'de> for &mut Deserializer<'de> {
411    type Error = Error;
412
413    // cbor-smol does not support structures not known at compile time
414    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
415    where
416        V: Visitor<'de>,
417    {
418        // We wont ever support this.
419        // If you need this, use `serde_cbor`.
420        Err(Error::WontImplement)
421    }
422
423    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
424    where
425        V: Visitor<'de>,
426    {
427        let val = match self.try_take_n(1)?[0] {
428            VALUE_FALSE => false,
429            VALUE_TRUE => true,
430            _ => return Err(Error::DeserializeBadBool),
431        };
432        visitor.visit_bool(val)
433    }
434
435    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
436    where
437        V: Visitor<'de>,
438    {
439        match self.peek_major()? {
440            MAJOR_POSINT => {
441                let raw_u8 = self.raw_deserialize_u8(0)?;
442                if raw_u8 <= i8::MAX as u8 {
443                    visitor.visit_i8(raw_u8 as i8)
444                } else {
445                    Err(Error::DeserializeBadI8)
446                }
447            }
448            MAJOR_NEGINT => {
449                let raw_u8 = self.raw_deserialize_u8(1)?;
450                // if raw_u8 <= 1 + i8::MAX as u8 {
451                if raw_u8 <= 128 {
452                    visitor.visit_i8(-1 - (raw_u8 as i16) as i8)
453                } else {
454                    Err(Error::DeserializeBadI8)
455                }
456            }
457            _ => Err(Error::DeserializeBadI8),
458        }
459    }
460
461    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
462    where
463        V: Visitor<'de>,
464    {
465        match self.peek_major()? {
466            MAJOR_POSINT => {
467                let raw = self.raw_deserialize_u16(0)?;
468                if raw <= i16::MAX as u16 {
469                    visitor.visit_i16(raw as i16)
470                } else {
471                    Err(Error::DeserializeBadI16)
472                }
473            }
474            MAJOR_NEGINT => {
475                let raw = self.raw_deserialize_u16(1)?;
476                if raw <= i16::MAX as u16 {
477                    visitor.visit_i16(-1 - (raw as i16))
478                } else {
479                    Err(Error::DeserializeBadI16)
480                }
481            }
482            _ => Err(Error::DeserializeBadI16),
483        }
484    }
485
486    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
487    where
488        V: Visitor<'de>,
489    {
490        match self.peek_major()? {
491            // TODO: figure out if this is BAAAAD for size or speed
492            major @ 0..=1 => {
493                let raw = self.raw_deserialize_u32(major)?;
494                if raw <= i32::MAX as u32 {
495                    if major == MAJOR_POSINT {
496                        visitor.visit_i32(raw as i32)
497                    } else {
498                        visitor.visit_i32(-1 - (raw as i32))
499                    }
500                } else {
501                    Err(Error::DeserializeBadI32)
502                }
503            }
504            _ => Err(Error::DeserializeBadI16),
505        }
506    }
507
508    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
509    where
510        V: Visitor<'de>,
511    {
512        match self.peek_major()? {
513            // TODO: figure out if this is BAAAAD for size or speed
514            major @ 0..=1 => {
515                let raw = self.raw_deserialize_u64(major)?;
516                if raw <= i64::MAX as u64 {
517                    if major == MAJOR_POSINT {
518                        visitor.visit_i64(raw as i64)
519                    } else {
520                        visitor.visit_i64(-1 - (raw as i64))
521                    }
522                } else {
523                    Err(Error::DeserializeBadI64)
524                }
525            }
526            _ => Err(Error::DeserializeBadI16),
527        }
528    }
529
530    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
531    where
532        V: Visitor<'de>,
533    {
534        let raw = self.raw_deserialize_u8(MAJOR_POSINT)?;
535        visitor.visit_u8(raw)
536    }
537
538    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
539    where
540        V: Visitor<'de>,
541    {
542        let raw = self.raw_deserialize_u16(MAJOR_POSINT)?;
543        visitor.visit_u16(raw)
544    }
545
546    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
547    where
548        V: Visitor<'de>,
549    {
550        let raw = self.raw_deserialize_u32(MAJOR_POSINT)?;
551        visitor.visit_u32(raw)
552    }
553
554    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
555    where
556        V: Visitor<'de>,
557    {
558        let raw = self.raw_deserialize_u64(MAJOR_POSINT)?;
559        visitor.visit_u64(raw)
560    }
561
562    fn deserialize_f32<V>(self, _visitor: V) -> Result<V::Value>
563    where
564        V: Visitor<'de>,
565    {
566        Err(Error::NotYetImplemented)
567    }
568
569    fn deserialize_f64<V>(self, _visitor: V) -> Result<V::Value>
570    where
571        V: Visitor<'de>,
572    {
573        Err(Error::NotYetImplemented)
574    }
575
576    fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value>
577    where
578        V: Visitor<'de>,
579    {
580        // not sure, can this be implemented?
581        // todo!("implement `deserialize_char`");
582        Err(Error::NotYetImplemented)
583        // let mut buf = [0u8; 4];
584        // let bytes = self.try_take_n(4)?;
585        // buf.copy_from_slice(bytes);
586        // let integer = u32::from_le_bytes(buf);
587        // visitor.visit_char(core::char::from_u32(integer).ok_or(Error::DeserializeBadChar)?)
588    }
589
590    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
591    where
592        V: Visitor<'de>,
593    {
594        let major = self.peek_major()?;
595        match major {
596            MAJOR_ARRAY => {
597                let len = self.raw_deserialize_u32(MAJOR_ARRAY)?;
598                visitor.visit_seq(SeqAccess {
599                    deserializer: self,
600                    len: len as usize,
601                })
602            }
603            MAJOR_BYTES => {
604                // major type 2: "byte string"
605                let length = self.raw_deserialize_u32(MAJOR_BYTES)? as usize;
606                let bytes: &'de [u8] = self.try_take_n(length)?;
607                visitor.visit_borrowed_bytes(bytes)
608            }
609            _ => Err(Error::DeserializeBadMajor),
610        }
611    }
612
613    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
614    where
615        V: Visitor<'de>,
616    {
617        self.deserialize_bytes(visitor)
618    }
619
620    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
621    where
622        V: Visitor<'de>,
623    {
624        // major type 3: "text string"
625        let length = self.raw_deserialize_u32(MAJOR_STR)? as usize;
626        let bytes: &'de [u8] = self.try_take_n(length)?;
627        let string_slice = core::str::from_utf8(bytes).map_err(|_| Error::DeserializeBadUtf8)?;
628        visitor.visit_borrowed_str(string_slice)
629    }
630
631    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
632    where
633        V: Visitor<'de>,
634    {
635        self.deserialize_str(visitor)
636    }
637
638    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
639    where
640        V: de::Visitor<'de>,
641    {
642        match self.peek()? {
643            0xf6 => {
644                self.consume()?;
645                visitor.visit_none()
646            }
647            _ => visitor.visit_some(self),
648        }
649    }
650
651    // In Serde, unit means an anonymous value containing no data.
652    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
653    where
654        V: Visitor<'de>,
655    {
656        match self.peek()? {
657            VALUE_NULL => {
658                self.consume()?;
659                visitor.visit_unit()
660            }
661            _ => Err(Error::DeserializeExpectedNull),
662        }
663    }
664
665    // Unit struct means a named value containing no data.
666    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
667    where
668        V: Visitor<'de>,
669    {
670        self.deserialize_unit(visitor)
671    }
672
673    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
674    where
675        V: Visitor<'de>,
676    {
677        visitor.visit_newtype_struct(self)
678    }
679
680    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
681    where
682        V: Visitor<'de>,
683    {
684        let len = self.raw_deserialize_u32(MAJOR_ARRAY)? as usize;
685
686        visitor.visit_seq(SeqAccess {
687            deserializer: self,
688            len,
689        })
690    }
691
692    #[inline(never)]
693    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
694    where
695        V: Visitor<'de>,
696    {
697        let len = self.raw_deserialize_u32(MAJOR_ARRAY)? as usize;
698        visitor.visit_seq(SeqAccess {
699            deserializer: self,
700            len,
701        })
702    }
703
704    fn deserialize_tuple_struct<V>(
705        self,
706        _name: &'static str,
707        len: usize,
708        visitor: V,
709    ) -> Result<V::Value>
710    where
711        V: Visitor<'de>,
712    {
713        self.deserialize_tuple(len, visitor)
714    }
715
716    #[inline(never)]
717    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
718    where
719        V: Visitor<'de>,
720    {
721        let len = self.raw_deserialize_u32(MAJOR_MAP)? as usize;
722
723        visitor.visit_map(MapAccess {
724            deserializer: self,
725            len,
726        })
727    }
728
729    fn deserialize_struct<V>(
730        self,
731        _name: &'static str,
732        _fields: &'static [&'static str],
733        visitor: V,
734    ) -> Result<V::Value>
735    where
736        V: Visitor<'de>,
737    {
738        self.deserialize_map(visitor)
739    }
740
741    // fn deserialize_enum<V>(
742    //     self,
743    //     _name: &'static str,
744    //     _variants: &'static [&'static str],
745    //     visitor: V,
746    // ) -> Result<V::Value>
747    // where
748    //     V: Visitor<'de>,
749    // {
750    //     todo!("implement `deserialize_enum`");
751    // }
752
753    // fn parse_enum<V>(&mut self, mut len: usize, visitor: V) -> Result<V::Value>
754    // where
755    //     V: de::Visitor<'de>,
756    // {
757    //     self.recursion_checked(|de| {
758    //         let value = visitor.visit_enum(VariantAccess {
759    //             seq: SeqAccess { de, len: &mut len },
760    //         })?;
761
762    //         if len != 0 {
763    //             Err(de.error(ErrorCode::TrailingData))
764    //         } else {
765    //             Ok(value)
766    //         }
767    //     })
768    // }
769
770    fn deserialize_enum<V>(
771        self,
772        _name: &'static str,
773        _variants: &'static [&'static str],
774        visitor: V,
775    ) -> Result<V::Value>
776    where
777        V: Visitor<'de>,
778    {
779        match self.peek_major()? {
780            // Data variant
781            MAJOR_ARRAY => {
782                let len = self.raw_deserialize_u32(MAJOR_ARRAY)?;
783                visitor.visit_enum(EnumAccess {
784                    deserializer: self,
785                    variant_len: len as usize,
786                })
787            }
788            // Unit variant
789            MAJOR_POSINT => visitor.visit_enum(EnumAccess {
790                deserializer: self,
791                variant_len: 0,
792            }),
793            _ => Err(Error::DeserializeBadMajor),
794        }
795    }
796
797    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
798    where
799        V: Visitor<'de>,
800    {
801        let major = self.peek_major()?;
802        match major {
803            MAJOR_BYTES | MAJOR_STR => {
804                // Rust identifiers are always valid UTF-8 so we can assume that bytes are
805                // UTF-8-encoded strings.  This has the benefit that we only need a mapping from
806                // strings to fields (and the mapping from bytes to fields can be optimized out).
807                let length = self.raw_deserialize_u32(major)? as usize;
808                let bytes: &'de [u8] = self.try_take_n(length)?;
809                let string_slice =
810                    core::str::from_utf8(bytes).map_err(|_| Error::DeserializeBadUtf8)?;
811                visitor.visit_borrowed_str(string_slice)
812            }
813            MAJOR_POSINT => self.deserialize_u64(visitor),
814            _ => Err(Error::DeserializeBadMajor),
815        }
816    }
817
818    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
819    where
820        V: Visitor<'de>,
821    {
822        // Ignore extra fields/options
823        self.ignore()?;
824        visitor.visit_none()
825    }
826}
827
828// impl<'de, 'a> serde::de::VariantAccess<'de> for &'a mut Deserializer<'de> {
829//     type Error = Error;
830
831//     fn unit_variant(self) -> Result<()> {
832//         Ok(())
833//     }
834
835//     fn newtype_variant_seed<V: DeserializeSeed<'de>>(self, seed: V) -> Result<V::Value> {
836//         DeserializeSeed::deserialize(seed, self)
837//     }
838
839//     fn tuple_variant<V: Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value> {
840//         serde::de::Deserializer::deserialize_tuple(self, len, visitor)
841//     }
842
843//     fn struct_variant<V: Visitor<'de>>(
844//         self,
845//         fields: &'static [&'static str],
846//         visitor: V,
847//     ) -> Result<V::Value> {
848//         serde::de::Deserializer::deserialize_tuple(self, fields.len(), visitor)
849//     }
850// }
851
852// impl<'de, 'a> serde::de::EnumAccess<'de> for &'a mut Deserializer<'de> {
853//     type Error = Error;
854//     type Variant = Self;
855
856//     fn variant_seed<V: DeserializeSeed<'de>>(self, seed: V) -> Result<(V::Value, Self)> {
857//         // let varint = self.try_take_varint()?;
858//         // if varint > 0xFFFF_FFFF {
859//         //     return Err(Error::DeserializeBadEnum);
860//         // }
861//         let varint = self.raw_deserialize_u32(0)?;
862//         let v = DeserializeSeed::deserialize(seed, (varint as u32).into_deserializer())?;
863//         Ok((v, self))
864//     }
865// }
866
867// // // `MapAccess` is provided to the `Visitor` to give it the ability to iterate
868// // // through entries of the map.
869// // impl<'de, 'a> MapAccess<'de> for CommaSeparated<'a, 'de> {
870// //     type Error = Error;
871
872// //     fn next_key_seed<K>(&mut self, _seed: K) -> Result<Option<K::Value>>
873// //     where
874// //         K: DeserializeSeed<'de>,
875// //     {
876// //         // // Check if there are no more entries.
877// //         // if self.de.peek_char()? == '}' {
878// //         //     return Ok(None);
879// //         // }
880// //         // // Comma is required before every entry except the first.
881// //         // if !self.first && self.de.next_char()? != ',' {
882// //         //     return Err(Error::ExpectedMapComma);
883// //         // }
884// //         // self.first = false;
885// //         // // Deserialize a map key.
886// //         // seed.deserialize(&mut *self.de).map(Some)
887// //         unimplemented!()
888// //     }
889
890// //     fn next_value_seed<V>(&mut self, _seed: V) -> Result<V::Value>
891// //     where
892// //         V: DeserializeSeed<'de>,
893// //     {
894// //         // // It doesn't make a difference whether the colon is parsed at the end
895// //         // // of `next_key_seed` or at the beginning of `next_value_seed`. In this
896// //         // // case the code is a bit simpler having it here.
897// //         // if self.de.next_char()? != ':' {
898// //         //     return Err(Error::ExpectedMapColon);
899// //         // }
900// //         // // Deserialize a map value.
901// //         // seed.deserialize(&mut *self.de)
902// //         unimplemented!()
903// //     }
904// // }
905
906#[cfg(test)]
907mod tests {
908
909    // use super::*;
910    use super::from_bytes;
911
912    // use crate::serde::{cbor_serialize, cbor_serialize2, cbor_deserialize};
913    // use crate::serde::{cbor_serialize, cbor_serialize_old, cbor_deserialize};
914    use crate::{cbor_deserialize, cbor_serialize};
915
916    #[test]
917    fn de_bool() {
918        let mut buf = [0u8; 64];
919
920        for boolean in [true, false].iter() {
921            let _n = cbor_serialize(boolean, &mut buf).unwrap();
922            let de: bool = from_bytes(&buf).unwrap();
923            assert_eq!(de, *boolean);
924        }
925    }
926
927    #[test]
928    fn de_u8() {
929        let mut buf = [0u8; 64];
930
931        for number in 0..=255 {
932            println!("testing {}", number);
933            let _n = cbor_serialize(&number, &mut buf).unwrap();
934            let de: u8 = from_bytes(&buf).unwrap();
935            assert_eq!(de, number);
936        }
937    }
938
939    #[test]
940    fn de_i8() {
941        let mut buf = [0u8; 64];
942
943        for number in -128i8..=127 {
944            println!("testing {}", number);
945            let ser = cbor_serialize(&number, &mut buf).unwrap();
946            println!("serialized: {:?}", ser);
947            let de: i8 = cbor_deserialize(ser).unwrap();
948            assert_eq!(de, number);
949        }
950    }
951
952    #[test]
953    fn de_u16() {
954        let mut buf = [0u8; 64];
955
956        for number in 0..=65535 {
957            println!("testing {}", number);
958            let _n = cbor_serialize(&number, &mut buf).unwrap();
959            let de: u16 = from_bytes(&buf).unwrap();
960            assert_eq!(de, number);
961        }
962    }
963
964    #[test]
965    fn de_i16() {
966        let mut buf = [0u8; 64];
967
968        for number in i16::min_value()..=i16::MAX {
969            println!("testing {}", number);
970            let _n = cbor_serialize(&number, &mut buf).unwrap();
971            let de: i16 = from_bytes(&buf).unwrap();
972            assert_eq!(de, number);
973        }
974    }
975
976    #[test]
977    fn de_u32() {
978        let mut buf = [0u8; 64];
979
980        for number in 0..=3 * (u16::MAX as u32) {
981            println!("testing {}", number);
982            let _n = cbor_serialize(&number, &mut buf).unwrap();
983            let de: u32 = from_bytes(&buf).unwrap();
984            assert_eq!(de, number);
985        }
986
987        for number in (u32::MAX - u16::MAX as u32)..=u32::MAX {
988            println!("testing {}", number);
989            let _n = cbor_serialize(&number, &mut buf).unwrap();
990            let de: u32 = from_bytes(&buf).unwrap();
991            assert_eq!(de, number);
992        }
993    }
994
995    #[test]
996    fn de_u64() {
997        let mut buf = [0u8; 64];
998
999        let numbers = [
1000            0,
1001            1,
1002            2,
1003            3,
1004            u16::MAX as u64,
1005            u16::MAX as u64 + 1,
1006            u32::MAX as u64,
1007            u32::MAX as u64 + 1,
1008            u64::MAX - 1,
1009            u64::MAX,
1010        ];
1011
1012        for number in numbers {
1013            println!("testing {}", number);
1014            let _n = cbor_serialize(&number, &mut buf).unwrap();
1015            let de: u64 = from_bytes(&buf).unwrap();
1016            assert_eq!(de, number);
1017        }
1018    }
1019
1020    #[test]
1021    fn de_i32() {
1022        let mut buf = [0u8; 64];
1023
1024        let number: i32 = -98304;
1025        let ser = cbor_serialize(&number, &mut buf).unwrap();
1026        println!("serialized number: {:?} of {}", ser, i16::min_value());
1027        let de: i32 = from_bytes(ser).unwrap();
1028        assert_eq!(de, number);
1029
1030        for number in (3 * i16::min_value() as i32)..=3 * (i16::MAX as i32) {
1031            println!("testing {}", number);
1032            let ser = cbor_serialize(&number, &mut buf).unwrap();
1033            let de: i32 = from_bytes(ser).unwrap();
1034            assert_eq!(de, number);
1035        }
1036
1037        for number in (i32::MAX - i16::MAX as i32)..=i32::MAX {
1038            println!("testing {}", number);
1039            let ser = cbor_serialize(&number, &mut buf).unwrap();
1040            let de: i32 = from_bytes(ser).unwrap();
1041            assert_eq!(de, number);
1042        }
1043
1044        for number in i32::min_value()..=(i32::min_value() - i16::min_value() as i32) {
1045            println!("testing {}", number);
1046            let ser = cbor_serialize(&number, &mut buf).unwrap();
1047            let de: i32 = from_bytes(ser).unwrap();
1048            assert_eq!(de, number);
1049        }
1050    }
1051
1052    #[cfg_attr(
1053        not(feature = "heapless-bytes-v0-5"),
1054        ignore = "Enable heapless-bytes-v0-5 feature"
1055    )]
1056    #[test]
1057    fn de_bytes() {
1058        #[cfg(feature = "heapless-bytes-v0-5")]
1059        {
1060            let mut buf = [0u8; 64];
1061
1062            let slice = b"thank you postcard!";
1063            let bytes = heapless_bytes_v0_5::Bytes::<64>::try_from(slice).unwrap();
1064            let ser = cbor_serialize(&bytes, &mut buf).unwrap();
1065            println!("serialized bytes = {:?}", ser);
1066            let de: heapless_bytes_v0_5::Bytes<64> = from_bytes(&buf).unwrap();
1067            println!("deserialized bytes = {:?}", &de);
1068            assert_eq!(&de, slice);
1069        }
1070        #[cfg(not(feature = "heapless-bytes-v0-5"))]
1071        {
1072            panic!("This test must be run with the heapless-v0-5 feature")
1073        }
1074    }
1075
1076    #[test]
1077    fn de_str() {
1078        let mut buf = [0u8; 64];
1079
1080        let string_slice = "thank you postcard, for blazing the path 🐝";
1081        let mut string = heapless_v0_9::String::<64>::new();
1082        string.push_str(string_slice).unwrap();
1083        let _n = cbor_serialize(&string, &mut buf);
1084        let de: heapless_v0_9::String<64> = from_bytes(&buf).unwrap();
1085        assert_eq!(de, string_slice);
1086    }
1087
1088    // #[test]
1089    // fn de_struct() {
1090    //     use crate::ctap2::get_info::CtapOptions;
1091    //     // rk: bool,
1092    //     // up: bool,
1093    //     // #[serde(skip_serializing_if = "Option::is_none")]
1094    //     // uv: Option<bool>,
1095    //     // plat: bool,
1096    //     // #[serde(skip_serializing_if = "Option::is_none")]
1097    //     // client_pin: Option<bool>,
1098    //     // #[serde(skip_serializing_if = "Option::is_none")]
1099    //     // cred_protect: Option<bool>,
1100
1101    //     let options = CtapOptions {
1102    //         rk: false,
1103    //         up: true,
1104    //         uv: None,
1105    //         plat: Some(false),
1106    //         client_pin: Some(true),
1107    //     };
1108
1109    //     let mut buf = [0u8; 64];
1110
1111    //     let _n = cbor_serialize(&options, &mut buf);
1112    //     let de: CtapOptions = from_bytes(&buf).unwrap();
1113    //     assert_eq!(de, options);
1114    // }
1115
1116    // #[test]
1117    // fn de_credential_id() {
1118    //     use crate::{Bytes, consts::{U32, U64}};
1119    //     use serde_indexed::{DeserializeIndexed, SerializeIndexed};
1120    //     #[derive(Clone,Debug,Eq,PartialEq,SerializeIndexed,DeserializeIndexed)]
1121    //     pub struct CredentialInner {
1122    //         pub user_id: Bytes<U64>,
1123    //         pub alg: i8,
1124    //         pub seed: Bytes<U32>,
1125    //     }
1126
1127    //     let input = b"\xa3\x00Gnickray\x01&\x02X @7\xbf\xa6\x98j\xb9\x0e8nB\x92\xd8\xf2\x1bK\xef\x92\xe87\xfe2`\x92%\xff\x98jR\xd1\xc8\xc1";
1128
1129    //     let _credential_inner: CredentialInner = from_bytes(input).unwrap();
1130    // }
1131
1132    #[test]
1133    fn de_enum() {
1134        let mut buf = [0u8; 64];
1135        let e = Some(3);
1136        let ser = cbor_serialize(&e, &mut buf).unwrap();
1137        println!("ser(Some(3)) = {:?}", ser);
1138        let de: Option<u8> = cbor_deserialize(ser).unwrap();
1139        assert_eq!(de, e);
1140        let e: Option<u8> = None;
1141        println!(
1142            "ser({:?}) = {:x?}",
1143            &e,
1144            cbor_serialize(&e, &mut buf).unwrap()
1145        );
1146
1147        // let mut buf = [0u8; 64];
1148        // let _n = cbor_serialize(&None, &mut buf).unwrap();
1149        // println!("ser(e) = {:?}", &buf[.._n]);
1150
1151        // use serde_indexed::{DeserializeIndexed, SerializeIndexed};
1152        use serde::{Deserialize, Serialize};
1153        #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1154        pub enum Enum {
1155            Alpha(u8),
1156            Beta((i32, u32)),
1157            Gamma { a: i32, b: u32 },
1158        }
1159
1160        let mut buf = [0u8; 64];
1161
1162        let e = Enum::Beta((-42, 7));
1163        let ser = cbor_serialize(&e, &mut buf).unwrap();
1164        println!("ser({:?}) = {:?}", &e, ser);
1165        let de: Enum = cbor_deserialize(ser).unwrap();
1166        assert_eq!(de, e);
1167
1168        let e = Enum::Gamma { a: -42, b: 7 };
1169        let ser = cbor_serialize(&e, &mut buf).unwrap();
1170        println!("ser({:?}) = {:?}", &e, ser);
1171        let de: Enum = cbor_deserialize(ser).unwrap();
1172        assert_eq!(de, e);
1173
1174        #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1175        pub enum SimpleEnum {
1176            Alpha(u8),
1177            Beta,
1178        }
1179
1180        let e = SimpleEnum::Alpha(7);
1181        let ser = cbor_serialize(&e, &mut buf).unwrap();
1182        println!("ser({:?}) = {:?}", &e, ser);
1183        let de: SimpleEnum = cbor_deserialize(ser).unwrap();
1184        assert_eq!(de, e);
1185
1186        let e = SimpleEnum::Beta;
1187        let ser = cbor_serialize(&e, &mut buf).unwrap();
1188        println!("ser({:?}) = {:?}", &e, ser);
1189        let de: SimpleEnum = cbor_deserialize(ser).unwrap();
1190        assert_eq!(de, e);
1191    }
1192
1193    #[test]
1194    fn de_ignored_any() {
1195        use serde::de::IgnoredAny;
1196        use serde::{Deserialize, Serialize};
1197
1198        #[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1199        pub struct ValOuter<'a> {
1200            inner: Outer<'a>,
1201            val: &'a str,
1202        }
1203        #[derive(Deserialize)]
1204        pub struct ValIgnored<'a> {
1205            #[allow(unused)]
1206            inner: IgnoredAny,
1207            val: &'a str,
1208        }
1209
1210        #[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1211        pub struct Inner<'a> {
1212            u8: u8,
1213            u16: u16,
1214            u32: u32,
1215            u64: u64,
1216            i8: i8,
1217            i16: i16,
1218            i32: i32,
1219            i64: i64,
1220            str: &'a str,
1221            option: Option<&'a str>,
1222            #[serde(with = "serde_bytes")]
1223            bytes: &'a [u8],
1224            unit: (),
1225        }
1226        #[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1227        pub struct Outer<'a> {
1228            u8: u8,
1229            u16: u16,
1230            u32: u32,
1231            u64: u64,
1232            i8: i8,
1233            i16: i16,
1234            i32: i32,
1235            i64: i64,
1236            str: &'a str,
1237            #[serde(with = "serde_bytes")]
1238            bytes: &'a [u8],
1239            unit: (),
1240            option: Option<&'a str>,
1241            nested: Inner<'a>,
1242        }
1243
1244        let mut buf = [0; 1024];
1245        let val = Outer {
1246            u8: u8::MAX,
1247            u16: u16::MAX,
1248            u32: u32::MAX,
1249            u64: u64::MAX,
1250            i8: i8::MIN,
1251            i16: i16::MIN,
1252            i32: i32::MIN,
1253            i64: i64::MIN,
1254            str: "string",
1255            bytes: b"bytes",
1256            unit: (),
1257            option: Some("option"),
1258            nested: Inner {
1259                u8: 0,
1260                u16: 0,
1261                u32: 0,
1262                u64: 0,
1263                i8: i8::MIN,
1264                i16: i16::MIN,
1265                i32: i32::MIN,
1266                i64: i64::MIN,
1267                str: "",
1268                option: None,
1269                bytes: b"",
1270                unit: (),
1271            },
1272        };
1273        let ser = cbor_serialize(&val, &mut buf).unwrap();
1274        let _: IgnoredAny = cbor_deserialize(ser).unwrap();
1275
1276        let val = ValOuter {
1277            inner: val,
1278            val: "value",
1279        };
1280        let ser = cbor_serialize(&val, &mut buf).unwrap();
1281        let de: ValOuter = cbor_deserialize(ser).unwrap();
1282        assert_eq!(val, de);
1283        let de: ValIgnored = cbor_deserialize(ser).unwrap();
1284        assert_eq!(de.val, "value");
1285    }
1286
1287    // #[test]
1288    // fn fuzzer_things() {
1289    //     let data: [u8; 2] = [160, 96];
1290    //     type T = crate::webauthn::PublicKeyCredentialUserEntity;
1291    //     cbor_deserialize::<T>(&data).ok();
1292    // }
1293
1294    // #[test]
1295    // fn piv_persistent_state() {
1296    //     let data = b"\xa6dkeys\xa2rauthentication_keyP<\xc1\xaa\x8c\xc3\xfav4\x88\xbc\xdb\x9fe\x81\xa7nnmanagement_keyP\x8c\x16\"\xed\x0f\xce\x9c\xac^\xf1;\xd0r\xea\xc9\xcbx\x1aconsecutive_pin_mismatches\x00x\x1aconsecutive_puk_mismatches\x00cpin\xa1jpadded_pin\x88\x181\x182\x183\x181\x182\x183\x18\xff\x18\xffcpuk\xa1jpadded_pin\x88\x181\x182\x183\x181\x182\x183\x18\xff\x18\xffitimestamp\x00";
1297
1298    //     cbor_deserialize::<T>(&data).ok();
1299    // }
1300}
cbor_smol/de.rs

cbor_smol/
de.rs
