rmp_serde/
decode.rs

1//! Generic MessagePack deserialization.
2
3use crate::config::sealed::SerializerConfig as _;
4use std::convert::TryInto;
5use std::error;
6use std::fmt::{self, Display, Formatter};
7use std::io::{self, Cursor, ErrorKind, Read};
8use std::marker::PhantomData;
9use std::num::TryFromIntError;
10use std::str::{self, Utf8Error};
11
12use serde;
13use serde::de::value::SeqDeserializer;
14use serde::de::{self, Deserialize, DeserializeOwned, DeserializeSeed, Unexpected, Visitor};
15use serde::forward_to_deserialize_any;
16
17use rmp;
18use rmp::decode::{self, DecodeStringError, MarkerReadError, NumValueReadError, RmpRead, ValueReadError};
19use rmp::Marker;
20
21use crate::config::{BinaryConfig, DefaultConfig, HumanReadableConfig, SerializerConfig};
22use crate::MSGPACK_EXT_STRUCT_NAME;
23
24/// Enum representing errors that can occur while decoding MessagePack data.
25#[derive(Debug)]
26pub enum Error {
27    /// The enclosed I/O error occurred while trying to read a MessagePack
28    /// marker.
29    InvalidMarkerRead(io::Error),
30    /// The enclosed I/O error occurred while trying to read the encoded
31    /// MessagePack data.
32    InvalidDataRead(io::Error),
33    /// A mismatch occurred between the decoded and expected value types.
34    TypeMismatch(Marker),
35    /// A numeric cast failed due to an out-of-range error.
36    OutOfRange,
37    /// A decoded array did not have the enclosed expected length.
38    LengthMismatch(u32),
39    /// An otherwise uncategorized error occurred. See the enclosed `String` for
40    /// details.
41    Uncategorized(String),
42    /// A general error occurred while deserializing the expected type. See the
43    /// enclosed `String` for details.
44    Syntax(String),
45    /// An encoded string could not be parsed as UTF-8.
46    Utf8Error(Utf8Error),
47    /// The depth limit was exceeded.
48    DepthLimitExceeded,
49}
50
51macro_rules! depth_count(
52    ( $counter:expr, $expr:expr ) => {
53        {
54            $counter -= 1;
55            if $counter == 0 {
56                return Err(Error::DepthLimitExceeded)
57            }
58            let res = $expr;
59            $counter += 1;
60            res
61        }
62    }
63);
64
65impl error::Error for Error {
66    #[cold]
67    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
68        match *self {
69            Self::TypeMismatch(..) => None,
70            Self::InvalidMarkerRead(ref err) => Some(err),
71            Self::InvalidDataRead(ref err) => Some(err),
72            Self::LengthMismatch(..) => None,
73            Self::OutOfRange => None,
74            Self::Uncategorized(..) => None,
75            Self::Syntax(..) => None,
76            Self::Utf8Error(ref err) => Some(err),
77            Self::DepthLimitExceeded => None,
78        }
79    }
80}
81
82impl de::Error for Error {
83    #[cold]
84    fn custom<T: Display>(msg: T) -> Self {
85        Self::Syntax(msg.to_string())
86    }
87}
88
89impl Display for Error {
90    #[cold]
91    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), fmt::Error> {
92        match *self {
93            Self::InvalidMarkerRead(ref err) => write!(fmt, "IO error while reading marker: {err}"),
94            Self::InvalidDataRead(ref err) => write!(fmt, "IO error while reading data: {err}"),
95            Self::TypeMismatch(ref actual_marker) => {
96                write!(fmt, "wrong msgpack marker {actual_marker:?}")
97            },
98            Self::OutOfRange => fmt.write_str("numeric cast found out of range"),
99            Self::LengthMismatch(expected_length) => {
100                write!(fmt, "array had incorrect length, expected {expected_length}")
101            },
102            Self::Uncategorized(ref msg) => write!(fmt, "uncategorized error: {msg}"),
103            Self::Syntax(ref msg) => fmt.write_str(msg),
104            Self::Utf8Error(ref err) => write!(fmt, "string found to be invalid utf8: {err}"),
105            Self::DepthLimitExceeded => fmt.write_str("depth limit exceeded"),
106        }
107    }
108}
109
110impl From<MarkerReadError> for Error {
111    #[cold]
112    fn from(err: MarkerReadError) -> Self {
113        match err {
114            MarkerReadError(err) => Self::InvalidMarkerRead(err),
115        }
116    }
117}
118
119impl From<Utf8Error> for Error {
120    #[cold]
121    fn from(err: Utf8Error) -> Self {
122        Self::Utf8Error(err)
123    }
124}
125
126impl From<ValueReadError> for Error {
127    #[cold]
128    fn from(err: ValueReadError) -> Self {
129        match err {
130            ValueReadError::TypeMismatch(marker) => Self::TypeMismatch(marker),
131            ValueReadError::InvalidMarkerRead(err) => Self::InvalidMarkerRead(err),
132            ValueReadError::InvalidDataRead(err) => Self::InvalidDataRead(err),
133        }
134    }
135}
136
137impl From<NumValueReadError> for Error {
138    #[cold]
139    fn from(err: NumValueReadError) -> Self {
140        match err {
141            NumValueReadError::TypeMismatch(marker) => Self::TypeMismatch(marker),
142            NumValueReadError::InvalidMarkerRead(err) => Self::InvalidMarkerRead(err),
143            NumValueReadError::InvalidDataRead(err) => Self::InvalidDataRead(err),
144            NumValueReadError::OutOfRange => Self::OutOfRange,
145        }
146    }
147}
148
149impl From<DecodeStringError<'_>> for Error {
150    #[cold]
151    fn from(err: DecodeStringError<'_>) -> Self {
152        match err {
153            DecodeStringError::InvalidMarkerRead(err) => Self::InvalidMarkerRead(err),
154            DecodeStringError::InvalidDataRead(err) => Self::InvalidDataRead(err),
155            DecodeStringError::TypeMismatch(marker) => Self::TypeMismatch(marker),
156            DecodeStringError::BufferSizeTooSmall(..) => Self::Uncategorized("BufferSizeTooSmall".to_string()),
157            DecodeStringError::InvalidUtf8(..) => Self::Uncategorized("InvalidUtf8".to_string()),
158        }
159    }
160}
161
162impl From<TryFromIntError> for Error {
163    #[cold]
164    fn from(_: TryFromIntError) -> Self {
165        Self::OutOfRange
166    }
167}
168
169/// A Deserializer that reads bytes from a buffer.
170///
171/// # Note
172///
173/// All instances of `ErrorKind::Interrupted` are handled by this function and the underlying
174/// operation is retried.
175#[derive(Debug)]
176pub struct Deserializer<R, C = DefaultConfig> {
177    rd: R,
178    _config: PhantomData<C>,
179    is_human_readable: bool,
180    marker: Option<Marker>,
181    depth: u16,
182}
183
184impl<R: Read, C> Deserializer<R, C> {
185    #[inline]
186    fn take_or_read_marker(&mut self) -> Result<Marker, MarkerReadError> {
187        self.marker
188            .take()
189            .map_or_else(|| rmp::decode::read_marker(&mut self.rd), Ok)
190    }
191
192    #[inline]
193    fn peek_or_read_marker(&mut self) -> Result<Marker, MarkerReadError> {
194        if let Some(m) = self.marker {
195            Ok(m)
196        } else {
197            let m = rmp::decode::read_marker(&mut self.rd)?;
198            Ok(self.marker.insert(m).to_owned())
199        }
200    }
201}
202
203impl<R: Read> Deserializer<ReadReader<R>, DefaultConfig> {
204    /// Constructs a new `Deserializer` by consuming the given reader.
205    #[inline]
206    pub fn new(rd: R) -> Self {
207        Self {
208            rd: ReadReader::new(rd),
209            _config: PhantomData,
210            is_human_readable: DefaultConfig.is_human_readable(),
211            // Cached marker in case of deserializing optional values.
212            marker: None,
213            depth: 1024,
214        }
215    }
216}
217
218impl<R: Read, C> Deserializer<ReadReader<R>, C> {
219    /// Gets a reference to the underlying reader in this decoder.
220    #[inline(always)]
221    pub fn get_ref(&self) -> &R {
222        &self.rd.rd
223    }
224
225    /// Gets a mutable reference to the underlying reader in this decoder.
226    #[inline(always)]
227    pub fn get_mut(&mut self) -> &mut R {
228        &mut self.rd.rd
229    }
230
231    /// Consumes this deserializer returning the underlying reader.
232    #[inline]
233    pub fn into_inner(self) -> R {
234        self.rd.rd
235    }
236}
237
238impl<R: Read, C: SerializerConfig> Deserializer<R, C> {
239    /// Consumes this deserializer and returns a new one, which will deserialize types with
240    /// human-readable representations (`Deserializer::is_human_readable` will return `true`).
241    ///
242    /// This is primarily useful if you need to interoperate with serializations produced by older
243    /// versions of `rmp-serde`.
244    #[inline]
245    pub fn with_human_readable(self) -> Deserializer<R, HumanReadableConfig<C>> {
246        let Self { rd, _config: _, is_human_readable: _, marker, depth } = self;
247        Deserializer {
248            rd,
249            is_human_readable: true,
250            _config: PhantomData,
251            marker,
252            depth,
253        }
254    }
255
256    /// Consumes this deserializer and returns a new one, which will deserialize types with
257    /// binary representations (`Deserializer::is_human_readable` will return `false`).
258    ///
259    /// This is the default MessagePack deserialization mechanism, consuming the most compact
260    /// representation.
261    #[inline]
262    pub fn with_binary(self) -> Deserializer<R, BinaryConfig<C>> {
263        let Self { rd, _config: _, is_human_readable: _, marker, depth } = self;
264        Deserializer {
265            rd,
266            is_human_readable: false,
267            _config: PhantomData,
268            marker,
269            depth,
270        }
271    }
272}
273
274impl<R: AsRef<[u8]>> Deserializer<ReadReader<Cursor<R>>> {
275    /// Returns the current position of this deserializer, i.e. how many bytes were read.
276    #[inline(always)]
277    pub fn position(&self) -> u64 {
278        self.rd.rd.position()
279    }
280}
281
282impl<'de, R> Deserializer<ReadRefReader<'de, R>>
283where
284    R: AsRef<[u8]> + ?Sized,
285{
286    /// Constructs a new `Deserializer` from the given byte slice.
287    #[inline(always)]
288    pub fn from_read_ref(rd: &'de R) -> Self {
289        Deserializer {
290            rd: ReadRefReader::new(rd),
291            is_human_readable: DefaultConfig.is_human_readable(),
292            _config: PhantomData,
293            marker: None,
294            depth: 1024,
295        }
296    }
297
298    /// Gets a reference to the underlying reader in this decoder.
299    #[inline(always)]
300    #[must_use]
301    pub fn get_ref(&self) -> &R {
302        self.rd.whole_slice
303    }
304}
305
306impl<'de, R: ReadSlice<'de>, C: SerializerConfig> Deserializer<R, C> {
307    /// Changes the maximum nesting depth that is allowed
308    #[inline(always)]
309    pub fn set_max_depth(&mut self, depth: usize) {
310        self.depth = depth.min(u16::MAX as _) as u16;
311    }
312}
313
314#[inline(never)]
315fn read_i128_marker<'de, R: ReadSlice<'de>>(marker: Marker, rd: &mut R) -> Result<i128, Error> {
316    Ok(match marker {
317        Marker::FixPos(val) => val.into(),
318        Marker::FixNeg(val) => val.into(),
319        Marker::U8 => rd.read_data_u8()?.into(),
320        Marker::U16 => rd.read_data_u16()?.into(),
321        Marker::U32 => rd.read_data_u32()?.into(),
322        Marker::U64 => rd.read_data_u64()?.into(),
323        Marker::I8 => rd.read_data_i8()?.into(),
324        Marker::I16 => rd.read_data_i16()?.into(),
325        Marker::I32 => rd.read_data_i32()?.into(),
326        Marker::I64 => rd.read_data_i64()?.into(),
327        Marker::Bin8 => {
328            let len = read_u8(&mut *rd)?;
329            read_128_buf(rd, len)?
330        },
331        Marker::FixArray(len) => read_128_buf(rd, len)?,
332        marker => return Err(Error::TypeMismatch(marker)),
333    })
334}
335
336fn read_128_buf<'de, R: ReadSlice<'de>>(rd: &mut R, len: u8) -> Result<i128, Error> {
337    if len != 16 {
338        return Err(Error::LengthMismatch(16));
339    }
340    let buf = match read_bin_data(rd, 16)? {
341        Reference::Borrowed(buf) => buf,
342        Reference::Copied(buf) => buf,
343    };
344    Ok(i128::from_be_bytes(buf.try_into().map_err(|_| Error::LengthMismatch(16))?))
345}
346
347fn read_str_data<'de, V, R>(rd: &mut R, len: u32, visitor: V) -> Result<V::Value, Error>
348    where V: Visitor<'de>, R: ReadSlice<'de>
349{
350    match read_bin_data(rd, len)? {
351        Reference::Borrowed(buf) => {
352            match str::from_utf8(buf) {
353                Ok(s) => visitor.visit_borrowed_str(s),
354                Err(err) => {
355                    // Allow to unpack invalid UTF-8 bytes into a byte array.
356                    match visitor.visit_borrowed_bytes::<Error>(buf) {
357                        Ok(buf) => Ok(buf),
358                        Err(..) => Err(Error::Utf8Error(err)),
359                    }
360                },
361            }
362        },
363        Reference::Copied(buf) => {
364            match str::from_utf8(buf) {
365                Ok(s) => visitor.visit_str(s),
366                Err(err) => {
367                    // Allow to unpack invalid UTF-8 bytes into a byte array.
368                    match visitor.visit_bytes::<Error>(buf) {
369                        Ok(buf) => Ok(buf),
370                        Err(..) => Err(Error::Utf8Error(err)),
371                    }
372                },
373            }
374        },
375    }
376}
377
378fn read_bin_data<'a, 'de, R: ReadSlice<'de>>(rd: &'a mut R, len: u32) -> Result<Reference<'de, 'a, [u8]>, Error> {
379    rd.read_slice(len as usize).map_err(Error::InvalidDataRead)
380}
381
382fn read_u8<R: Read>(rd: &mut R) -> Result<u8, Error> {
383    let mut buf = [0; 1];
384    rd.read_exact(&mut buf).map_err(Error::InvalidDataRead)?;
385    Ok(buf[0])
386}
387
388fn read_u16<R: Read>(rd: &mut R) -> Result<u16, Error> {
389    let mut buf = [0; 2];
390    rd.read_exact(&mut buf).map_err(Error::InvalidDataRead)?;
391    Ok(u16::from_be_bytes(buf))
392}
393
394fn read_u32<R: Read>(rd: &mut R) -> Result<u32, Error> {
395    let mut buf = [0; 4];
396    rd.read_exact(&mut buf).map_err(Error::InvalidDataRead)?;
397    Ok(u32::from_be_bytes(buf))
398}
399
400fn ext_len<R: Read>(rd: &mut R, marker: Marker) -> Result<u32, Error> {
401    Ok(match marker {
402        Marker::FixExt1 => 1,
403        Marker::FixExt2 => 2,
404        Marker::FixExt4 => 4,
405        Marker::FixExt8 => 8,
406        Marker::FixExt16 => 16,
407        Marker::Ext8 => u32::from(read_u8(rd)?),
408        Marker::Ext16 => u32::from(read_u16(rd)?),
409        Marker::Ext32 => read_u32(rd)?,
410        _ => return Err(Error::TypeMismatch(marker)),
411    })
412}
413
414#[derive(Debug)]
415enum ExtDeserializerState {
416    New,
417    ReadTag,
418    ReadBinary,
419}
420
421#[derive(Debug)]
422struct ExtDeserializer<'a, R, C> {
423    rd: &'a mut R,
424    _config: PhantomData<C>,
425    len: u32,
426    state: ExtDeserializerState,
427}
428
429impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> ExtDeserializer<'a, R, C> {
430    const fn new(d: &'a mut Deserializer<R, C>, len: u32) -> Self {
431        ExtDeserializer {
432            rd: &mut d.rd,
433            _config: d._config,
434            len,
435            state: ExtDeserializerState::New,
436        }
437    }
438}
439
440impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> de::Deserializer<'de> for ExtDeserializer<'a, R, C> {
441    type Error = Error;
442
443    #[inline(always)]
444    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
445        where V: Visitor<'de>
446    {
447        visitor.visit_seq(self)
448    }
449
450    forward_to_deserialize_any! {
451        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
452        seq bytes byte_buf map unit_struct newtype_struct
453        struct identifier tuple enum ignored_any tuple_struct
454    }
455}
456
457impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> de::SeqAccess<'de> for ExtDeserializer<'a, R, C> {
458    type Error = Error;
459
460    #[inline]
461    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
462    where
463        T: DeserializeSeed<'de>,
464    {
465        match self.state {
466            ExtDeserializerState::New | ExtDeserializerState::ReadTag => Ok(Some(seed.deserialize(self)?)),
467            ExtDeserializerState::ReadBinary => Ok(None),
468        }
469    }
470}
471
472/// Deserializer for Ext `SeqAccess`
473impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> de::Deserializer<'de> for &mut ExtDeserializer<'a, R, C> {
474    type Error = Error;
475
476    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
477        where V: Visitor<'de>
478    {
479        match self.state {
480            ExtDeserializerState::New => {
481                let tag = self.rd.read_data_i8()?;
482                self.state = ExtDeserializerState::ReadTag;
483                visitor.visit_i8(tag)
484            },
485            ExtDeserializerState::ReadTag => {
486                let data = self.rd.read_slice(self.len as usize).map_err(Error::InvalidDataRead)?;
487                self.state = ExtDeserializerState::ReadBinary;
488                match data {
489                    Reference::Borrowed(bytes) => visitor.visit_borrowed_bytes(bytes),
490                    Reference::Copied(bytes) => visitor.visit_bytes(bytes),
491                }
492            },
493            ExtDeserializerState::ReadBinary => {
494                debug_assert!(false);
495                Err(Error::TypeMismatch(Marker::Reserved))
496            },
497        }
498    }
499
500    forward_to_deserialize_any! {
501        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
502        seq bytes byte_buf map unit_struct newtype_struct
503        tuple_struct struct identifier tuple enum ignored_any
504    }
505}
506
507#[inline(never)]
508fn any_num<'de, R: ReadSlice<'de>, V: Visitor<'de>>(rd: &mut R, visitor: V, marker: Marker) -> Result<V::Value, Error> {
509    match marker {
510        Marker::Null => visitor.visit_unit(),
511        Marker::True |
512        Marker::False => visitor.visit_bool(marker == Marker::True),
513        Marker::FixPos(val) => visitor.visit_u8(val),
514        Marker::FixNeg(val) => visitor.visit_i8(val),
515        Marker::U8 => visitor.visit_u8(rd.read_data_u8()?),
516        Marker::U16 => visitor.visit_u16(rd.read_data_u16()?),
517        Marker::U32 => visitor.visit_u32(rd.read_data_u32()?),
518        Marker::U64 => visitor.visit_u64(rd.read_data_u64()?),
519        Marker::I8 => visitor.visit_i8(rd.read_data_i8()?),
520        Marker::I16 => visitor.visit_i16(rd.read_data_i16()?),
521        Marker::I32 => visitor.visit_i32(rd.read_data_i32()?),
522        Marker::I64 => visitor.visit_i64(rd.read_data_i64()?),
523        Marker::F32 => visitor.visit_f32(rd.read_data_f32()?),
524        Marker::F64 => visitor.visit_f64(rd.read_data_f64()?),
525        other_marker => Err(Error::TypeMismatch(other_marker)),
526    }
527}
528
529impl<'de, R: ReadSlice<'de>, C: SerializerConfig> Deserializer<R, C> {
530    fn any_inner<V: Visitor<'de>>(&mut self, visitor: V, allow_bytes: bool) -> Result<V::Value, Error> {
531        let marker = self.take_or_read_marker()?;
532        match marker {
533            Marker::Null |
534            Marker::True |
535            Marker::False |
536            Marker::FixPos(_) |
537            Marker::FixNeg(_) |
538            Marker::U8 |
539            Marker::U16 |
540            Marker::U32 |
541            Marker::U64 |
542            Marker::I8 |
543            Marker::I16 |
544            Marker::I32 |
545            Marker::I64 |
546            Marker::F32 |
547            Marker::F64 => any_num(&mut self.rd, visitor, marker),
548            Marker::FixStr(_) | Marker::Str8 | Marker::Str16 | Marker::Str32 => {
549                let len = match marker {
550                    Marker::FixStr(len) => Ok(len.into()),
551                    Marker::Str8 => read_u8(&mut self.rd).map(u32::from),
552                    Marker::Str16 => read_u16(&mut self.rd).map(u32::from),
553                    Marker::Str32 => read_u32(&mut self.rd),
554                    _ => return Err(Error::TypeMismatch(Marker::Reserved)),
555                }?;
556                read_str_data(&mut self.rd, len, visitor)
557            },
558            Marker::FixArray(_) | Marker::Array16 | Marker::Array32 => {
559                let len = match marker {
560                    Marker::FixArray(len) => len.into(),
561                    Marker::Array16 => read_u16(&mut self.rd)?.into(),
562                    Marker::Array32 => read_u32(&mut self.rd)?,
563                    _ => return Err(Error::TypeMismatch(Marker::Reserved)),
564                };
565
566                depth_count!(self.depth, {
567                    let mut seq = SeqAccess::new(self, len);
568                    let res = visitor.visit_seq(&mut seq)?;
569                    match seq.left {
570                        0 => Ok(res),
571                        excess => Err(Error::LengthMismatch(len - excess)),
572                    }
573                })
574            },
575            Marker::FixMap(_) | Marker::Map16 | Marker::Map32 => {
576                let len = match marker {
577                    Marker::FixMap(len) => len.into(),
578                    Marker::Map16 => read_u16(&mut self.rd)?.into(),
579                    Marker::Map32 => read_u32(&mut self.rd)?,
580                    _ => return Err(Error::TypeMismatch(Marker::Reserved)),
581                };
582
583                depth_count!(self.depth, {
584                    let mut seq = MapAccess::new(self, len);
585                    let res = visitor.visit_map(&mut seq)?;
586                    match seq.left {
587                        0 => Ok(res),
588                        excess => Err(Error::LengthMismatch(len - excess)),
589                    }
590                })
591            },
592            Marker::Bin8 | Marker::Bin16 | Marker::Bin32 => {
593                let len = match marker {
594                    Marker::Bin8 => read_u8(&mut self.rd).map(u32::from),
595                    Marker::Bin16 => read_u16(&mut self.rd).map(u32::from),
596                    Marker::Bin32 => read_u32(&mut self.rd),
597                    _ => return Err(Error::TypeMismatch(Marker::Reserved)),
598                }?;
599                match read_bin_data(&mut self.rd, len)? {
600                    Reference::Borrowed(buf) if allow_bytes => visitor.visit_borrowed_bytes(buf),
601                    Reference::Copied(buf) if allow_bytes => visitor.visit_bytes(buf),
602                    Reference::Borrowed(buf) | Reference::Copied(buf) => {
603                        visitor.visit_seq(SeqDeserializer::new(buf.iter().copied()))
604                    },
605                }
606            },
607            Marker::FixExt1 |
608            Marker::FixExt2 |
609            Marker::FixExt4 |
610            Marker::FixExt8 |
611            Marker::FixExt16 |
612            Marker::Ext8 |
613            Marker::Ext16 |
614            Marker::Ext32 => {
615                let len = ext_len(&mut self.rd, marker)?;
616                depth_count!(self.depth, visitor.visit_newtype_struct(ExtDeserializer::new(self, len)))
617            },
618            Marker::Reserved => Err(Error::TypeMismatch(Marker::Reserved)),
619        }
620    }
621}
622
623impl<'de, R: ReadSlice<'de>, C: SerializerConfig> serde::Deserializer<'de> for &mut Deserializer<R, C> {
624    type Error = Error;
625
626    #[inline(always)]
627    fn is_human_readable(&self) -> bool {
628        self.is_human_readable
629    }
630
631    #[inline(always)]
632    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
633        where V: Visitor<'de>
634    {
635        self.any_inner(visitor, true)
636    }
637
638    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
639        where V: Visitor<'de>
640    {
641        // # Important
642        //
643        // If a nested Option `o ∈ { Option<Opion<t>>, Option<Option<Option<t>>>, ..., Option<Option<...Option<t>...> }`
644        // is visited for the first time, the marker (read from the underlying Reader) will determine
645        // `o`'s innermost type `t`.
646        // For subsequent visits of `o` the marker will not be re-read again but kept until type `t`
647        // is visited.
648        //
649        // # Note
650        //
651        // Round trips of Options where `Option<t> = None` such as `Some(None)` will fail because
652        // they are just seriialized as `nil`. The serialization format has probably to be changed
653        // to solve this. But as serde_json behaves the same, I think it's not worth doing this.
654        let marker = self.take_or_read_marker()?;
655
656        if marker == Marker::Null {
657            visitor.visit_none()
658        } else {
659            // Keep the marker until `o`'s innermost type `t` is visited.
660            self.marker = Some(marker);
661            visitor.visit_some(self)
662        }
663    }
664
665    fn deserialize_enum<V>(self, _name: &str, _variants: &[&str], visitor: V) -> Result<V::Value, Error>
666        where V: Visitor<'de>
667    {
668        let marker = self.peek_or_read_marker()?;
669        match rmp::decode::marker_to_len(&mut self.rd, marker) {
670            Ok(len) => match len {
671                // Enums are either encoded as maps with a single K/V pair
672                // where the K = the variant & V = associated data
673                // or as just the variant
674                1 => {
675                    self.marker = None;
676                    visitor.visit_enum(VariantAccess::new(self))
677                },
678                n => Err(Error::LengthMismatch(n)),
679            },
680            // TODO: Check this is a string
681            Err(_) => visitor.visit_enum(UnitVariantAccess::new(self)),
682        }
683    }
684
685    fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value, Error>
686        where V: Visitor<'de>
687    {
688        if name == MSGPACK_EXT_STRUCT_NAME {
689            let marker = self.take_or_read_marker()?;
690
691            let len = ext_len(&mut self.rd, marker)?;
692            let ext_de = ExtDeserializer::new(self, len);
693            return visitor.visit_newtype_struct(ext_de);
694        }
695
696        visitor.visit_newtype_struct(self)
697    }
698
699    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
700        where V: Visitor<'de>
701    {
702        // We need to special case this so that [] is treated as a unit struct when asked for,
703        // but as a sequence otherwise. This is because we serialize unit structs as [] rather
704        // than as 'nil'.
705        match self.take_or_read_marker()? {
706            Marker::Null | Marker::FixArray(0) => visitor.visit_unit(),
707            marker => {
708                self.marker = Some(marker);
709                self.deserialize_any(visitor)
710            },
711        }
712    }
713
714    #[inline]
715    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
716    where
717        V: Visitor<'de>,
718    {
719        visitor.visit_i128(read_i128_marker(self.take_or_read_marker()?, &mut self.rd)?)
720    }
721
722    #[inline]
723    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
724    where
725        V: Visitor<'de>,
726    {
727        visitor.visit_u128(read_i128_marker(self.take_or_read_marker()?, &mut self.rd)? as u128)
728    }
729
730    #[inline]
731    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
732        self.any_inner(visitor, false)
733    }
734
735    #[inline]
736    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
737        self.any_inner(visitor, false)
738    }
739
740    #[inline]
741    fn deserialize_struct<V>(self, _: &'static str, _: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
742        self.any_inner(visitor, false)
743    }
744
745    #[inline]
746    fn deserialize_tuple_struct<V>(self, _: &'static str, _: usize, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
747        self.any_inner(visitor, false)
748    }
749
750    forward_to_deserialize_any! {
751        bytes byte_buf unit
752        map identifier str string char
753        ignored_any
754    }
755
756    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
757        let marker = self.take_or_read_marker()?;
758        any_num(&mut self.rd, visitor, marker)
759    }
760
761    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
762        let marker = self.take_or_read_marker()?;
763        any_num(&mut self.rd, visitor, marker)
764    }
765
766    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
767        let marker = self.take_or_read_marker()?;
768        any_num(&mut self.rd, visitor, marker)
769    }
770
771    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
772        let marker = self.take_or_read_marker()?;
773        any_num(&mut self.rd, visitor, marker)
774    }
775
776    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
777        let marker = self.take_or_read_marker()?;
778        any_num(&mut self.rd, visitor, marker)
779    }
780
781    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
782        let marker = self.take_or_read_marker()?;
783        any_num(&mut self.rd, visitor, marker)
784    }
785
786    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
787        let marker = self.take_or_read_marker()?;
788        any_num(&mut self.rd, visitor, marker)
789    }
790
791    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
792        let marker = self.take_or_read_marker()?;
793        any_num(&mut self.rd, visitor, marker)
794    }
795
796    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
797        let marker = self.take_or_read_marker()?;
798        any_num(&mut self.rd, visitor, marker)
799    }
800
801    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
802        let marker = self.take_or_read_marker()?;
803        any_num(&mut self.rd, visitor, marker)
804    }
805
806    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
807        let marker = self.take_or_read_marker()?;
808        any_num(&mut self.rd, visitor, marker)
809    }
810}
811
812struct SeqAccess<'a, R, C> {
813    de: &'a mut Deserializer<R, C>,
814    left: u32,
815}
816
817impl<'a, R: 'a, C> SeqAccess<'a, R, C> {
818    #[inline]
819    const fn new(de: &'a mut Deserializer<R, C>, len: u32) -> Self {
820        SeqAccess { de, left: len }
821    }
822}
823
824impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> de::SeqAccess<'de> for SeqAccess<'a, R, C> {
825    type Error = Error;
826
827    #[inline]
828    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
829        where T: DeserializeSeed<'de>
830    {
831        if self.left > 0 {
832            self.left -= 1;
833            Ok(Some(seed.deserialize(&mut *self.de)?))
834        } else {
835            Ok(None)
836        }
837    }
838
839    #[inline(always)]
840    fn size_hint(&self) -> Option<usize> {
841        self.left.try_into().ok()
842    }
843}
844
845struct MapAccess<'a, R, C> {
846    de: &'a mut Deserializer<R, C>,
847    left: u32,
848}
849
850impl<'a, R: 'a, C> MapAccess<'a, R, C> {
851    #[inline]
852    const fn new(de: &'a mut Deserializer<R, C>, len: u32) -> Self {
853        MapAccess { de, left: len }
854    }
855}
856
857impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> de::MapAccess<'de> for MapAccess<'a, R, C> {
858    type Error = Error;
859
860    #[inline]
861    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
862        where K: DeserializeSeed<'de>
863    {
864        if self.left > 0 {
865            self.left -= 1;
866            seed.deserialize(&mut *self.de).map(Some)
867        } else {
868            Ok(None)
869        }
870    }
871
872    #[inline]
873    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
874        where V: DeserializeSeed<'de>
875    {
876        seed.deserialize(&mut *self.de)
877    }
878
879    #[inline(always)]
880    fn size_hint(&self) -> Option<usize> {
881        self.left.try_into().ok()
882    }
883}
884
885struct UnitVariantAccess<'a, R: 'a, C> {
886    de: &'a mut Deserializer<R, C>,
887}
888
889impl<'a, R: 'a, C> UnitVariantAccess<'a, R, C> {
890    pub const fn new(de: &'a mut Deserializer<R, C>) -> Self {
891        UnitVariantAccess { de }
892    }
893}
894
895impl<'de, R: ReadSlice<'de>, C: SerializerConfig> de::EnumAccess<'de>
896    for UnitVariantAccess<'_, R, C>
897{
898    type Error = Error;
899    type Variant = Self;
900
901    #[inline]
902    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self), Error>
903    where
904        V: de::DeserializeSeed<'de>,
905    {
906        let variant = seed.deserialize(&mut *self.de)?;
907        Ok((variant, self))
908    }
909}
910
911impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> de::VariantAccess<'de>
912    for UnitVariantAccess<'a, R, C>
913{
914    type Error = Error;
915
916    fn unit_variant(self) -> Result<(), Error> {
917        Ok(())
918    }
919
920    fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Error>
921    where
922        T: de::DeserializeSeed<'de>,
923    {
924        Err(de::Error::invalid_type(
925            Unexpected::UnitVariant,
926            &"newtype variant",
927        ))
928    }
929
930    fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Error>
931    where
932        V: de::Visitor<'de>,
933    {
934        Err(de::Error::invalid_type(
935            Unexpected::UnitVariant,
936            &"tuple variant",
937        ))
938    }
939
940    fn struct_variant<V>(
941        self,
942        _fields: &'static [&'static str],
943        _visitor: V,
944    ) -> Result<V::Value, Error>
945    where
946        V: de::Visitor<'de>,
947    {
948        Err(de::Error::invalid_type(
949            Unexpected::UnitVariant,
950            &"struct variant",
951        ))
952    }
953}
954
955struct VariantAccess<'a, R, C> {
956    de: &'a mut Deserializer<R, C>,
957}
958
959impl<'a, R: 'a, C> VariantAccess<'a, R, C> {
960    pub const fn new(de: &'a mut Deserializer<R, C>) -> Self {
961        VariantAccess { de }
962    }
963}
964
965impl<'de, R: ReadSlice<'de>, C: SerializerConfig> de::EnumAccess<'de> for VariantAccess<'_, R, C> {
966    type Error = Error;
967    type Variant = Self;
968
969    #[inline]
970    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self), Error>
971        where V: de::DeserializeSeed<'de>,
972    {
973        Ok((seed.deserialize(&mut *self.de)?, self))
974    }
975}
976
977impl<'de, R: ReadSlice<'de>, C: SerializerConfig> de::VariantAccess<'de> for VariantAccess<'_, R, C> {
978    type Error = Error;
979
980    #[inline]
981    fn unit_variant(self) -> Result<(), Error> {
982        decode::read_nil(&mut self.de.rd)?;
983        Ok(())
984    }
985
986    #[inline]
987    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
988        where T: DeserializeSeed<'de>
989    {
990        seed.deserialize(self.de)
991    }
992
993    #[inline]
994    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Error>
995        where V: Visitor<'de>
996    {
997        de::Deserializer::deserialize_tuple(self.de, len, visitor)
998    }
999
1000    #[inline]
1001    fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value, Error>
1002        where V: Visitor<'de>
1003    {
1004        de::Deserializer::deserialize_tuple(self.de, fields.len(), visitor)
1005    }
1006}
1007
1008/// Unification of both borrowed and non-borrowed reference types.
1009#[derive(Clone, Copy, Debug, PartialEq)]
1010pub enum Reference<'b, 'c, T: ?Sized + 'static> {
1011    /// The reference is pointed at data that was borrowed.
1012    Borrowed(&'b T),
1013    /// The reference is pointed at data that was copied.
1014    Copied(&'c T),
1015}
1016
1017/// Extends the `Read` trait by allowing to read slices directly by borrowing bytes.
1018///
1019/// Used to allow zero-copy reading.
1020pub trait ReadSlice<'de>: Read {
1021    /// Reads the exact number of bytes from the underlying byte-array.
1022    fn read_slice<'a>(&'a mut self, len: usize) -> Result<Reference<'de, 'a, [u8]>, io::Error>;
1023}
1024
1025/// Owned reader wrapper.
1026#[derive(Debug)]
1027pub struct ReadReader<R: Read> {
1028    rd: R,
1029    buf: Vec<u8>,
1030}
1031
1032impl<R: Read> ReadReader<R> {
1033    #[inline]
1034    fn new(rd: R) -> Self {
1035        Self {
1036            rd,
1037            buf: Vec::with_capacity(128),
1038        }
1039    }
1040}
1041
1042impl<'de, R: Read> ReadSlice<'de> for ReadReader<R> {
1043    #[inline]
1044    fn read_slice<'a>(&'a mut self, len: usize) -> Result<Reference<'de, 'a, [u8]>, io::Error> {
1045        self.buf.clear();
1046        let read = self.rd.by_ref().take(len as u64).read_to_end(&mut self.buf)?;
1047        if read != len {
1048            return Err(io::ErrorKind::UnexpectedEof.into());
1049        }
1050
1051        Ok(Reference::Copied(&self.buf[..]))
1052    }
1053}
1054
1055impl<R: Read> Read for ReadReader<R> {
1056    #[inline]
1057    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
1058        self.rd.read(buf)
1059    }
1060
1061    #[inline]
1062    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
1063        self.rd.read_exact(buf)
1064    }
1065}
1066
1067/// Borrowed reader wrapper.
1068#[derive(Debug)]
1069pub struct ReadRefReader<'a, R: ?Sized> {
1070    whole_slice: &'a R,
1071    buf: &'a [u8],
1072}
1073
1074impl<'a, T> ReadRefReader<'a, T> {
1075    /// Returns the part that hasn't been consumed yet
1076    #[must_use]
1077    pub const fn remaining_slice(&self) -> &'a [u8] {
1078        self.buf
1079    }
1080}
1081
1082impl<'a, T: AsRef<[u8]> + ?Sized> ReadRefReader<'a, T> {
1083    #[inline]
1084    fn new(rd: &'a T) -> Self {
1085        Self {
1086            whole_slice: rd,
1087            buf: rd.as_ref(),
1088        }
1089    }
1090}
1091
1092impl<T: AsRef<[u8]> + ?Sized> Read for ReadRefReader<'_, T> {
1093    #[inline]
1094    fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
1095        self.buf.read(buf)
1096    }
1097
1098    #[inline]
1099    fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), io::Error> {
1100        self.buf.read_exact(buf)
1101    }
1102}
1103
1104impl<'de, T: AsRef<[u8]> + ?Sized> ReadSlice<'de> for ReadRefReader<'de, T> {
1105    #[inline]
1106    fn read_slice<'a>(&'a mut self, len: usize) -> Result<Reference<'de, 'a, [u8]>, io::Error> {
1107        if len > self.buf.len() {
1108            return Err(ErrorKind::UnexpectedEof.into());
1109        }
1110        let (a, b) = self.buf.split_at(len);
1111        self.buf = b;
1112        Ok(Reference::Borrowed(a))
1113    }
1114}
1115
1116#[test]
1117fn test_as_ref_reader() {
1118    let buf = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1119    let mut rd = ReadRefReader::new(&buf);
1120
1121    assert_eq!(rd.read_slice(1).unwrap(), Reference::Borrowed(&[0][..]));
1122    assert_eq!(rd.read_slice(6).unwrap(), Reference::Borrowed(&[1, 2, 3, 4, 5, 6][..]));
1123    assert!(rd.read_slice(5).is_err());
1124    assert_eq!(rd.read_slice(4).unwrap(), Reference::Borrowed(&[7, 8, 9, 10][..]));
1125}
1126
1127/// Deserialize an instance of type `T` from an I/O stream of MessagePack.
1128///
1129/// # Errors
1130///
1131/// This conversion can fail if the structure of the Value does not match the structure expected
1132/// by `T`. It can also fail if the structure is correct but `T`'s implementation of `Deserialize`
1133/// decides that something is wrong with the data, for example required struct fields are missing.
1134#[inline]
1135pub fn from_read<R, T>(rd: R) -> Result<T, Error>
1136where R: Read,
1137      T: DeserializeOwned
1138{
1139    Deserialize::deserialize(&mut Deserializer::new(rd))
1140}
1141
1142/// Deserialize a temporary scope-bound instance of type `T` from a slice, with zero-copy if possible.
1143///
1144/// Deserialization will be performed in zero-copy manner whenever it is possible, borrowing the
1145/// data from the slice itself. For example, strings and byte-arrays won't copied.
1146///
1147/// # Errors
1148///
1149/// This conversion can fail if the structure of the Value does not match the structure expected
1150/// by `T`. It can also fail if the structure is correct but `T`'s implementation of `Deserialize`
1151/// decides that something is wrong with the data, for example required struct fields are missing.
1152///
1153/// # Examples
1154///
1155/// ```
1156/// use serde::Deserialize;
1157///
1158/// // Encoded `["Bobby", 8]`.
1159/// let buf = [0x92, 0xa5, 0x42, 0x6f, 0x62, 0x62, 0x79, 0x8];
1160///
1161/// #[derive(Debug, Deserialize, PartialEq)]
1162/// struct Dog<'a> {
1163///     name: &'a str,
1164///     age: u8,
1165/// }
1166///
1167/// assert_eq!(Dog { name: "Bobby", age: 8 }, rmp_serde::from_slice(&buf).unwrap());
1168/// ```
1169#[inline(always)]
1170#[allow(deprecated)]
1171pub fn from_slice<'a, T>(input: &'a [u8]) -> Result<T, Error>
1172where
1173    T: Deserialize<'a>,
1174{
1175    from_read_ref(input)
1176}
1177
1178#[inline]
1179#[doc(hidden)]
1180#[deprecated(note = "use from_slice")]
1181pub fn from_read_ref<'a, R, T>(rd: &'a R) -> Result<T, Error>
1182where
1183    R: AsRef<[u8]> + ?Sized,
1184    T: Deserialize<'a>,
1185{
1186    let mut de = Deserializer::from_read_ref(rd);
1187    Deserialize::deserialize(&mut de)
1188}
rmp_serde/decode.rs

rmp_serde/
decode.rs
