fix unpack of ix that doesn't fix in ix

Author: Vincent Rouillé

foundationdb/src/tuple/mod.rs

@@ -347,6 +347,57 @@ mod tests {
             b"\x0C\x80\x00\x00\x00\x00\x00\x00\x00",
         );
         test_serde(i64::min_value(), b"\x0C\x7f\xff\xff\xff\xff\xff\xff\xff");
+
+        test_serde(9252427359321063944i128, b"\x1c\x80g9\xa9np\x02\x08");
+        assert!(matches!(
+            unpack::<i64>(b"\x1c\x80g9\xa9np\x02\x08").unwrap_err(),
+            PackError::UnsupportedIntLength
+        ));
+
+        test_serde(
+            -9252427359321063944i128,
+            b"\x0c\x7f\x98\xc6V\x91\x8f\xfd\xf7",
+        );
+        assert!(matches!(
+            unpack::<i64>(b"\x0c\x7f\x98\xc6V\x91\x8f\xfd\xf7").unwrap_err(),
+            PackError::UnsupportedIntLength
+        ));
+
+        test_serde(
+            u64::max_value() as i128,
+            b"\x1c\xff\xff\xff\xff\xff\xff\xff\xff",
+        );
+        assert!(matches!(
+            unpack::<i64>(b"\x1c\xff\xff\xff\xff\xff\xff\xff\xff").unwrap_err(),
+            PackError::UnsupportedIntLength
+        ));
+
+        test_serde(
+            -(u64::max_value() as i128),
+            b"\x0c\x00\x00\x00\x00\x00\x00\x00\x00",
+        );
+        assert!(matches!(
+            unpack::<i64>(b"\x0c\x00\x00\x00\x00\x00\x00\x00\x00").unwrap_err(),
+            PackError::UnsupportedIntLength
+        ));
+
+        test_serde(
+            (i64::max_value() as i128) + 1,
+            b"\x1c\x80\x00\x00\x00\x00\x00\x00\x00",
+        );
+        assert!(matches!(
+            unpack::<i64>(b"\x1c\x80\x00\x00\x00\x00\x00\x00\x00").unwrap_err(),
+            PackError::UnsupportedIntLength
+        ));
+
+        test_serde(
+            (i64::min_value() as i128) - 1,
+            b"\x0c\x7f\xff\xff\xff\xff\xff\xff\xfe",
+        );
+        assert!(matches!(
+            unpack::<i64>(b"\x0c\x7f\xff\xff\xff\xff\xff\xff\xfe").unwrap_err(),
+            PackError::UnsupportedIntLength
+        ));
     }
 
     #[cfg(feature = "num-bigint")]
@@ -478,6 +529,15 @@ mod tests {
             BigInt::from(i64::min_value()),
             b"\x0C\x7f\xff\xff\xff\xff\xff\xff\xff",
         );
+
+        test_serde(
+            Element::BigInt(9252427359321063944i128.into()),
+            b"\x1c\x80g9\xa9np\x02\x08",
+        );
+        test_serde(
+            Element::BigInt((-9252427359321063944i128).into()),
+            b"\x0c\x7f\x98\xc6V\x91\x8f\xfd\xf7",
+        );
     }
 
     #[cfg(feature = "uuid")]

foundationdb/src/tuple/pack.rs

@@ -313,20 +313,39 @@ macro_rules! sign_bit {
     };
 }
 
-macro_rules! unpack_px {
+macro_rules! unpack_ux {
     ($ux: ident, $input: expr, $n: expr) => {{
         let (input, bytes) = parse_bytes($input, $n)?;
         let mut arr = [0u8; ::std::mem::size_of::<$ux>()];
         (&mut arr[(::std::mem::size_of::<$ux>() - $n)..]).copy_from_slice(bytes);
         (input, $ux::from_be_bytes(arr))
     }};
 }
+
+macro_rules! unpack_px {
+    ($ix: ident, $ux: ident, $input: expr, $n: expr) => {{
+        let (input, bytes) = parse_bytes($input, $n)?;
+        let mut arr = [0u8; ::std::mem::size_of::<$ux>()];
+        (&mut arr[(::std::mem::size_of::<$ux>() - $n)..]).copy_from_slice(bytes);
+        let x = $ix::from_be_bytes(arr);
+        if x < 0 {
+            Err(PackError::UnsupportedIntLength)
+        } else {
+            Ok((input, x))
+        }
+    }};
+}
 macro_rules! unpack_nx {
-    ($ix: ident, $input: expr, $n: expr) => {{
+    ($ix: ident, $ux: ident, $input: expr, $n: expr) => {{
         let (input, bytes) = parse_bytes($input, $n)?;
         let mut arr = [0xffu8; ::std::mem::size_of::<$ix>()];
         (&mut arr[(::std::mem::size_of::<$ix>() - $n)..]).copy_from_slice(bytes);
-        (input, $ix::from_be_bytes(arr).wrapping_add(1))
+        let x = $ix::from_be_bytes(arr).wrapping_add(1);
+        if x > 0 {
+            Err(PackError::UnsupportedIntLength)
+        } else {
+            Ok((input, x))
+        }
     }};
 }
 
@@ -363,14 +382,14 @@ macro_rules! impl_ux {
                 let (input, found) = parse_byte(input)?;
                 if INTZERO <= found && found <= INTZERO + $max_sz as u8 {
                     let n = (found - INTZERO) as usize;
-                    Ok(unpack_px!($ux, input, n))
+                    Ok(unpack_ux!($ux, input, n))
                 } else if found == POSINTEND {
                     let (input, raw_length) = parse_byte(input)?;
                     let n: usize = usize::from(raw_length);
                     if n > SZ {
                         return Err(PackError::UnsupportedIntLength);
                     }
-                    Ok(unpack_px!($ux, input, n))
+                    Ok(unpack_ux!($ux, input, n))
                 } else {
                     Err(PackError::BadCode {
                         found,
@@ -427,24 +446,24 @@ macro_rules! impl_ix {
                 let (input, found) = parse_byte(input)?;
                 if INTZERO <= found && found <= INTZERO + $max_sz as u8 {
                     let n = (found - INTZERO) as usize;
-                    Ok(unpack_px!($ix, input, n))
+                    unpack_px!($ix, $ux, input, n)
                 } else if INTZERO - $max_sz as u8 <= found && found < INTZERO {
                     let n = (INTZERO - found) as usize;
-                    Ok(unpack_nx!($ix, input, n))
+                    unpack_nx!($ix, $ux, input, n)
                 } else if found == NEGINTSTART {
                     let (input, raw_length) = parse_byte(input)?;
                     let n = usize::from(raw_length ^ 0xff);
                     if n > SZ {
                         return Err(PackError::UnsupportedIntLength);
                     }
-                    Ok(unpack_nx!($ix, input, n))
+                    unpack_nx!($ix, $ux, input, n)
                 } else if found == POSINTEND {
                     let (input, raw_length) = parse_byte(input)?;
                     let n: usize = usize::from(raw_length);
                     if n > SZ {
                         return Err(PackError::UnsupportedIntLength);
                     }
-                    Ok(unpack_px!($ix, input, n))
+                    unpack_px!($ix, $ux, input, n)
                 } else {
                     Err(PackError::BadCode {
                         found,
@@ -961,10 +980,15 @@ impl<'de> TupleUnpack<'de> for Element<'de> {
                 let (input, v) = Vec::<Self>::unpack(input, tuple_depth)?;
                 (input, Element::Tuple(v))
             }
-            INTMIN..=INTMAX => {
-                let (input, v) = i64::unpack(input, tuple_depth)?;
-                (input, Element::Int(v))
-            }
+            INTMIN..=INTMAX => match i64::unpack(input, tuple_depth) {
+                Ok((input, v)) => (input, Element::Int(v)),
+                #[cfg(feature = "num-bigint")]
+                Err(PackError::UnsupportedIntLength) => {
+                    let (input, v) = num_bigint::BigInt::unpack(input, tuple_depth)?;
+                    (input, Element::BigInt(v))
+                }
+                Err(err) => return Err(err),
+            },
             #[cfg(feature = "num-bigint")]
             NEGINTSTART => {
                 let (input, v) = num_bigint::BigInt::unpack(input, tuple_depth)?;