Support unlimit stack depth

rmp-serde/Cargo.toml

@@ -23,6 +23,7 @@ rmp = { version = "0.8.14", path = "../rmp" }
 rmpv = { path = "../rmpv" }
 serde_bytes = "0.11.5"
 serde = { version = "1.0.197", features = ["derive"] }
+serde_stacker = "0.1.12"
 
 [badges]
 maintenance = { status = "looking-for-maintainer" }

rmp-serde/src/decode.rs

@@ -53,12 +53,16 @@ pub enum Error {
 macro_rules! depth_count(
     ( $counter:expr, $expr:expr ) => {
         {
-            $counter -= 1;
-            if $counter == 0 {
-                return Err(Error::DepthLimitExceeded)
+            if let Some(counter) = &mut $counter {
+                *counter -= 1;
+                if *counter == 0 {
+                    return Err(Error::DepthLimitExceeded)
+                }
             }
             let res = $expr;
-            $counter += 1;
+            if let Some(counter) = &mut $counter {
+                *counter += 1;
+            }
             res
         }
     }
@@ -181,7 +185,7 @@ pub struct Deserializer<R, C = DefaultConfig> {
     _config: PhantomData<C>,
     is_human_readable: bool,
     marker: Option<Marker>,
-    depth: u16,
+    depth: Option<u16>,
 }
 
 impl<R: Read, C> Deserializer<R, C> {
@@ -213,7 +217,7 @@ impl<R: Read> Deserializer<ReadReader<R>, DefaultConfig> {
             is_human_readable: DefaultConfig.is_human_readable(),
             // Cached marker in case of deserializing optional values.
             marker: None,
-            depth: 1024,
+            depth: Some(1024),
         }
     }
 }
@@ -294,7 +298,7 @@ where
             is_human_readable: DefaultConfig.is_human_readable(),
             _config: PhantomData,
             marker: None,
-            depth: 1024,
+            depth: Some(1024),
         }
     }
 
@@ -310,7 +314,12 @@ impl<'de, R: ReadSlice<'de>, C: SerializerConfig> Deserializer<R, C> {
     /// Changes the maximum nesting depth that is allowed
     #[inline(always)]
     pub fn set_max_depth(&mut self, depth: usize) {
-        self.depth = depth.min(u16::MAX as _) as u16;
+        self.depth = Some(depth.min(u16::MAX as _) as u16);
+    }
+    /// disable stack depth check
+    #[inline(always)]
+    pub fn set_depth_unlimit(&mut self) {
+        self.depth = None;
     }
 }
 

rmp-serde/tests/decode.rs

@@ -567,3 +567,32 @@ fn fail_depth_limit() {
         other => panic!("unexpected result: {other:?}"),
     }
 }
+
+
+
+#[test]
+fn depth_unlimit() {
+    #[allow(dead_code)]
+    struct Nested {
+        sub: Vec<Nested>,
+    }
+
+    impl<'de> de::Deserialize<'de> for Nested {
+        fn deserialize<D>(de: D) -> Result<Self, D::Error>
+            where D: de::Deserializer<'de>
+        {
+            let nested = Vec::deserialize(de)?;
+            Ok(Nested { sub: nested })
+        }
+    }
+    let mut data = Vec::new();
+    for _ in 0..(u16::MAX as u32 + 1) {
+        data.push(0x91u8);
+    }
+
+    let mut reader = rmp_serde::Deserializer::new(Cursor::new(data));
+    reader.set_depth_unlimit();
+    let deserializer = serde_stacker::Deserializer::new(&mut reader);
+    let res = Nested::deserialize(deserializer);
+    if let decode::Error::DepthLimitExceeded = res.err().unwrap() { panic!("unexpected DepthLimitExceeded") }
+}