Sequence and Map deserialize now check for unconsumed items

Author: Lucretiel

rmp-serde/src/decode.rs

@@ -1,8 +1,10 @@
 //! Generic MessagePack deserialization.
 
+use std::convert::TryInto;
 use std::error;
 use std::fmt::{self, Display, Formatter};
 use std::io::{self, Cursor, ErrorKind, Read};
+use std::num::TryFromIntError;
 use std::str::{self, Utf8Error};
 
 use byteorder::{self, ReadBytesExt};
@@ -157,6 +159,13 @@ impl<'a> From<DecodeStringError<'a>> for Error {
     }
 }
 
+impl From<TryFromIntError> for Error {
+    #[cold]
+    fn from(_: TryFromIntError) -> Self {
+        Error::OutOfRange
+    }
+}
+
 /// A Deserializer that reads bytes from a buffer.
 ///
 /// # Note
@@ -327,8 +336,6 @@ impl<'de, R: ReadSlice<'de>, C: SerializerConfig> Deserializer<R, C> {
     }
 
     fn read_128(&mut self) -> Result<[u8; 16], Error> {
-        use std::convert::TryInto;
-
         let marker = self.take_or_read_marker()?;
 
         if marker != Marker::Bin8 {
@@ -508,35 +515,55 @@ impl<'de, 'a, R: ReadSlice<'de>, C: SerializerConfig> serde::Deserializer<'de> f
                     Marker::FixStr(len) => Ok(len.into()),
                     Marker::Str8 => read_u8(&mut self.rd).map(u32::from),
                     Marker::Str16 => read_u16(&mut self.rd).map(u32::from),
-                    Marker::Str32 | _ => read_u32(&mut self.rd).map(u32::from),
+                    Marker::Str32 => read_u32(&mut self.rd).map(u32::from),
+                    _ => unreachable!()
                 }?;
                 self.read_str_data(len, visitor)
             }
             Marker::FixArray(_) |
             Marker::Array16 |
             Marker::Array32 => {
                 let len = match marker {
-                    Marker::FixArray(len) => Ok(len.into()),
-                    Marker::Array16 => read_u16(&mut self.rd).map(u32::from),
-                    Marker::Array32 | _ => read_u32(&mut self.rd).map(u32::from),
-                }?;
-                depth_count!(self.depth, visitor.visit_seq(SeqAccess::new(self, len as usize)))
+                    Marker::FixArray(len) => len.into(),
+                    Marker::Array16 => read_u16(&mut self.rd)?.into(),
+                    Marker::Array32 => read_u32(&mut self.rd)?,
+                    _ => unreachable!(),
+                };
+
+                depth_count!(self.depth, {
+                    let mut seq = SeqAccess::new(self, len);
+                    let res = visitor.visit_seq(&mut seq)?;
+                    match seq.left {
+                        0 => Ok(res),
+                        excess => Err(Error::LengthMismatch(len - excess)),
+                    }
+                })
             }
             Marker::FixMap(_) |
             Marker::Map16 |
             Marker::Map32 => {
                 let len = match marker {
-                    Marker::FixMap(len) => Ok(len.into()),
-                    Marker::Map16 => read_u16(&mut self.rd).map(u32::from),
-                    Marker::Map32 | _ => read_u32(&mut self.rd).map(u32::from),
-                }?;
-                depth_count!(self.depth, visitor.visit_map(MapAccess::new(self, len as usize)))
+                    Marker::FixMap(len) => len.into(),
+                    Marker::Map16 => read_u16(&mut self.rd)?.into(),
+                    Marker::Map32 => read_u32(&mut self.rd)?,
+                    _ => unreachable!()
+                };
+
+                depth_count!(self.depth, {
+                    let mut seq = MapAccess::new(self, len);
+                    let res = visitor.visit_map(&mut seq)?;
+                    match seq.left {
+                        0 => Ok(res),
+                        excess => Err(Error::LengthMismatch(len - excess)),
+                    }
+                })
             }
-            Marker::Bin8 | Marker::Bin16| Marker::Bin32 => {
+            Marker::Bin8 | Marker::Bin16 | Marker::Bin32 => {
                 let len = match marker {
                     Marker::Bin8 => read_u8(&mut self.rd).map(u32::from),
                     Marker::Bin16 => read_u16(&mut self.rd).map(u32::from),
-                    Marker::Bin32 | _ => read_u32(&mut self.rd).map(u32::from),
+                    Marker::Bin32 => read_u32(&mut self.rd).map(u32::from),
+                    _ => unreachable!()
                 }?;
                 match read_bin_data(&mut self.rd, len)? {
                     Reference::Borrowed(buf) => visitor.visit_borrowed_bytes(buf),
@@ -706,12 +733,12 @@ impl<'de, 'a, R: ReadSlice<'de>, C: SerializerConfig> serde::Deserializer<'de> f
 
 struct SeqAccess<'a, R, C> {
     de: &'a mut Deserializer<R, C>,
-    left: usize,
+    left: u32,
 }
 
 impl<'a, R: 'a, C> SeqAccess<'a, R, C> {
     #[inline]
-    fn new(de: &'a mut Deserializer<R, C>, len: usize) -> Self {
+    fn new(de: &'a mut Deserializer<R, C>, len: u32) -> Self {
         SeqAccess {
             de,
             left: len,
@@ -736,17 +763,17 @@ impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> de::SeqAccess<'de> fo
 
     #[inline(always)]
     fn size_hint(&self) -> Option<usize> {
-        Some(self.left)
+        self.left.try_into().ok()
     }
 }
 
 struct MapAccess<'a, R, C> {
     de: &'a mut Deserializer<R, C>,
-    left: usize,
+    left: u32,
 }
 
 impl<'a, R: 'a, C> MapAccess<'a, R, C> {
-    fn new(de: &'a mut Deserializer<R, C>, len: usize) -> Self {
+    fn new(de: &'a mut Deserializer<R, C>, len: u32) -> Self {
         MapAccess {
             de,
             left: len,
@@ -763,7 +790,7 @@ impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> de::MapAccess<'de> fo
     {
         if self.left > 0 {
             self.left -= 1;
-            Ok(Some(seed.deserialize(&mut *self.de)?))
+            seed.deserialize(&mut *self.de).map(Some)
         } else {
             Ok(None)
         }
@@ -773,12 +800,12 @@ impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> de::MapAccess<'de> fo
     fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
         where V: DeserializeSeed<'de>
     {
-        Ok(seed.deserialize(&mut *self.de)?)
+        seed.deserialize(&mut *self.de)
     }
 
     #[inline(always)]
     fn size_hint(&self) -> Option<usize> {
-        Some(self.left)
+        self.left.try_into().ok()
     }
 }