Merge branch 'master' into checked-access-len

Author: kornelski

rmp-serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rmp-serde"
-version = "1.0.0"
+version = "1.1.0"
 authors = ["Evgeny Safronov <division494@gmail.com>"]
 license = "MIT"
 description = "Serde bindings for RMP"
@@ -13,13 +13,13 @@ edition = "2018"
 
 [dependencies]
 byteorder = "1.4.3"
-serde = "1.0.133"
+serde = "1.0.136"
 rmp = { version = "0.8.11", path = "../rmp" }
 
 [dev-dependencies]
 rmpv = { path = "../rmpv" }
 serde_bytes = "0.11.5"
-serde_derive = "1.0.133"
+serde_derive = "1.0.136"
 
 [badges]
 maintenance = { status = "passively-maintained" }

rmp-serde/benches/buf.rs

@@ -2,7 +2,7 @@
 
 extern crate test;
 
-use rmp_serde;
+
 
 use serde::{Deserialize, Serialize};
 

rmp-serde/src/decode.rs

@@ -293,7 +293,7 @@ where
     /// Gets a reference to the underlying reader in this decoder.
     #[inline(always)]
     pub fn get_ref(&self) -> &R {
-        self.rd.rd
+        self.rd.whole_slice
     }
 }
 
@@ -399,7 +399,7 @@ enum ExtDeserializerState {
 #[derive(Debug)]
 struct ExtDeserializer<'a, R, C> {
     rd: &'a mut R,
-    config: C,
+    _config: C,
     len: u32,
     state: ExtDeserializerState,
 }
@@ -408,7 +408,7 @@ impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> ExtDeserializer<'a, R
     fn new(d: &'a mut Deserializer<R, C>, len: u32) -> Self {
         ExtDeserializer {
             rd: &mut d.rd,
-            config: d.config,
+            _config: d.config,
             len,
             state: ExtDeserializerState::New,
         }
@@ -925,8 +925,11 @@ impl<R: Read> ReadReader<R> {
 impl<'de, R: Read> ReadSlice<'de> for ReadReader<R> {
     #[inline]
     fn read_slice<'a>(&'a mut self, len: usize) -> Result<Reference<'de, 'a, [u8]>, io::Error> {
-        self.buf.resize(len, 0u8);
-        self.rd.read_exact(&mut self.buf[..])?;
+        self.buf.clear();
+        let read = self.rd.by_ref().take(len as u64).read_to_end(&mut self.buf)?;
+        if read != len {
+            return Err(io::ErrorKind::UnexpectedEof.into());
+        }
 
         Ok(Reference::Copied(&self.buf[..]))
     }
@@ -947,15 +950,22 @@ impl<R: Read> Read for ReadReader<R> {
 /// Borrowed reader wrapper.
 #[derive(Debug)]
 pub struct ReadRefReader<'a, R: ?Sized> {
-    rd: &'a R,
+    whole_slice: &'a R,
     buf: &'a [u8],
 }
 
+impl<'a, T> ReadRefReader<'a, T> {
+    /// Returns the part that hasn't been consumed yet
+    pub fn remaining_slice(&self) -> &'a [u8] {
+        self.buf
+    }
+}
+
 impl<'a, T: AsRef<[u8]> + ?Sized> ReadRefReader<'a, T> {
     #[inline]
     fn new(rd: &'a T) -> Self {
         Self {
-            rd,
+            whole_slice: rd,
             buf: rd.as_ref(),
         }
     }
@@ -1011,21 +1021,10 @@ where R: Read,
     Deserialize::deserialize(&mut Deserializer::new(rd))
 }
 
-/// Deserializes a byte slice into the desired type.
-///
-/// It just calls the more generic `from_read_ref`.
-#[inline(always)]
-pub fn from_slice<'a, T>(input: &'a [u8]) -> Result<T, Error>
-where
-    T: Deserialize<'a>
-{
-    from_read_ref(input)
-}
-
-/// Deserialize an instance of type `T` from a reference I/O reader of MessagePack.
+/// Deserialize a temporary scope-bound instance of type `T` from a slice, with zero-copy if possible.
 ///
 /// Deserialization will be performed in zero-copy manner whenever it is possible, borrowing the
-/// data from the reader itself. For example, strings and byte-arrays won't be not copied.
+/// data from the slice itself. For example, strings and byte-arrays won't copied.
 ///
 /// # Errors
 ///
@@ -1047,9 +1046,20 @@ where
 ///    age: u8,
 /// }
 ///
-/// assert_eq!(Dog { name: "Bobby", age: 8 }, rmp_serde::from_read_ref(&buf).unwrap());
+/// assert_eq!(Dog { name: "Bobby", age: 8 }, rmp_serde::from_slice(&buf).unwrap());
 /// ```
+#[inline(always)]
+#[allow(deprecated)]
+pub fn from_slice<'a, T>(input: &'a [u8]) -> Result<T, Error>
+where
+    T: Deserialize<'a>
+{
+    from_read_ref(input)
+}
+
 #[inline]
+#[doc(hidden)]
+#[deprecated(note = "use from_slice")]
 pub fn from_read_ref<'a, R, T>(rd: &'a R) -> Result<T, Error>
 where
     R: AsRef<[u8]> + ?Sized,

rmp-serde/src/lib.rs

@@ -68,7 +68,9 @@ use std::str::{self, Utf8Error};
 use serde::de;
 use serde::{Deserialize, Serialize};
 
-pub use crate::decode::{from_read, from_read_ref, Deserializer};
+pub use crate::decode::{from_read, Deserializer};
+#[allow(deprecated)]
+pub use crate::decode::from_read_ref;
 pub use crate::encode::{to_vec, to_vec_named, Serializer};
 
 pub use crate::decode::from_slice;
@@ -108,7 +110,8 @@ impl Raw {
         Self { s: Ok(v) }
     }
 
-    /// Converts a vector of bytes to a `Raw`.
+    /// DO NOT USE. See <https://github.com/3Hren/msgpack-rust/issues/305>
+    #[deprecated(note = "This implementation is unsound and dangerous. See https://github.com/3Hren/msgpack-rust/issues/305")]
     pub fn from_utf8(v: Vec<u8>) -> Self {
         match String::from_utf8(v) {
             Ok(v) => Raw::new(v),
@@ -184,6 +187,8 @@ impl Serialize for Raw {
     {
         let s = match self.s {
             Ok(ref s) => s.as_str(),
+            // FIXME: this is invalid. It should use a newtype hack instead.
+            // https://github.com/3Hren/msgpack-rust/issues/305
             Err((ref b, ..)) => unsafe { mem::transmute(&b[..]) },
         };
 
@@ -266,7 +271,8 @@ impl<'a> RawRef<'a> {
         Self { s: Ok(v) }
     }
 
-    /// Converts a vector of bytes to a `RawRef`.
+    /// DO NOT USE. See <https://github.com/3Hren/msgpack-rust/issues/305>
+    #[deprecated(note = "This implementation is unsound and dangerous. See https://github.com/3Hren/msgpack-rust/issues/305")]
     pub fn from_utf8(v: &'a [u8]) -> Self {
         match str::from_utf8(v) {
             Ok(v) => RawRef::new(v),
@@ -326,6 +332,8 @@ impl<'a> Serialize for RawRef<'a> {
     {
         let s = match self.s {
             Ok(ref s) => s,
+            // FIXME: this is invalid. It should use a newtype hack instead.
+            // https://github.com/3Hren/msgpack-rust/issues/305
             Err((ref b, ..)) => unsafe { mem::transmute(b) },
         };
 

rmp-serde/tests/decode_derive.rs

@@ -523,6 +523,7 @@ fn pass_from_slice() {
 }
 
 #[test]
+#[allow(deprecated)]
 fn pass_from_ref() {
     let buf = [0x92, 0xa5, 0x42, 0x6f, 0x62, 0x62, 0x79, 0x8];
 

rmp-serde/tests/encode.rs

@@ -328,6 +328,7 @@ fn pass_raw_valid_utf8() {
 }
 
 #[test]
+#[allow(deprecated)]
 fn pass_raw_invalid_utf8() {
     // >>> msgpack.dumps(msgpack.dumps([200, []]))
     // '\xa4\x92\xcc\xc8\x90'
@@ -350,6 +351,7 @@ fn pass_raw_ref_valid_utf8() {
 }
 
 #[test]
+#[allow(deprecated)]
 fn pass_raw_ref_invalid_utf8() {
     // >>> msgpack.dumps(msgpack.dumps([200, []]))
     // '\xa4\x92\xcc\xc8\x90'

rmp/src/decode/bytes.rs

@@ -63,7 +63,7 @@ impl<'a> Bytes<'a> {
     /// Get a reference to the remaining bytes in the buffer.
     #[inline]
     pub fn remaining_slice(&self) -> &'a [u8] {
-        &self.bytes
+        self.bytes
     }
     /// Return the position of the input buffer.
     ///

rmp/src/decode/str.rs

@@ -137,7 +137,7 @@ pub fn read_str_data<'r, R>(rd: &mut R,
             Ok(decoded) => Ok(decoded),
             Err(err) => Err(DecodeStringError::InvalidUtf8(buf, err)),
         },
-        Err(err) => Err(DecodeStringError::InvalidDataRead(From::from(err))),
+        Err(err) => Err(DecodeStringError::InvalidDataRead(err)),
     }
 }
 

rmp/tests/func/decode/bool.rs

@@ -16,6 +16,6 @@ fn from_bool_true() {
     let buf = [0xc3];
     let mut cur = Cursor::new(&buf[..]);
 
-    assert_eq!(true, read_bool(&mut cur).unwrap());
+    assert!(read_bool(&mut cur).unwrap());
     assert_eq!(1, cur.position());
 }

rmp/tests/func/decode/null.rs

@@ -49,7 +49,7 @@ fn interrupt_safe() {
                 self.state_ = 1;
                 Err(Error::new(ErrorKind::Interrupted, "interrupted"))
             } else {
-                assert!(buf.len() > 0);
+                assert!(!buf.is_empty());
 
                 buf[0] = 0xc0;
                 Ok(1)