fix: replace silent narrowing casts and eliminate per-byte allocation

- AMQPValue::try_from: replace `as` truncation casts with try_from().ok()
  for all integer types narrower than i64/u64, returning None on out-of-range
  values instead of wrapping silently
- AMQPFlags::from_bytes: replace per-byte Vec<bool> allocation with an
  allocation-free range iterator
- gen_short_string / gen_long_string / gen_byte_array / gen_content_body_frame:
  add debug_assert! guards for length-prefix overflow

Author: Keruspe

protocol/src/frame/generation.rs

@@ -85,6 +85,10 @@ fn gen_content_body_frame<'a, W: Write + 'a>(
     channel_id: ChannelId,
     content: &'a [u8],
 ) -> impl SerializeFn<W> + 'a {
+    debug_assert!(
+        content.len() <= ChunkSize::MAX as usize,
+        "content body exceeds frame size limit"
+    );
     tuple((
         gen_short_short_uint(constants::FRAME_BODY),
         gen_id(channel_id),

types/src/flags.rs

@@ -37,13 +37,11 @@ impl AMQPFlags {
         let flags = names
             .iter()
             .map(ToString::to_string)
-            .zip(bytes.iter_elements().flat_map(|b| {
-                let mut v = Vec::new();
-                for s in 0..8 {
-                    v.push(((b & (1 << s)) >> s) == 1)
-                }
-                v
-            }))
+            .zip(
+                bytes
+                    .iter_elements()
+                    .flat_map(|b| (0..8u8).map(move |s| ((b >> s) & 1) == 1)),
+            )
             .collect();
 
         AMQPFlags { flags }

types/src/generation.rs

@@ -129,6 +129,10 @@ pub fn gen_decimal_value<W: Write>(d: DecimalValue) -> impl SerializeFn<W> {
 
 /// Generate the [ShortString](../type.ShortString.html) in the given buffer (x)
 pub fn gen_short_string<'a, W: Write + 'a>(s: &'a str) -> impl SerializeFn<W> + 'a {
+    debug_assert!(
+        s.len() <= ShortShortUInt::MAX as usize,
+        "short string exceeds 255 bytes"
+    );
     pair(
         gen_short_short_uint(s.len() as ShortShortUInt),
         slice(s.as_bytes()),
@@ -137,6 +141,10 @@ pub fn gen_short_string<'a, W: Write + 'a>(s: &'a str) -> impl SerializeFn<W> +
 
 /// Generate the [LongString](../type.LongString.html) in the given buffer (x)
 pub fn gen_long_string<'a, W: Write + 'a>(s: &'a [u8]) -> impl SerializeFn<W> + 'a {
+    debug_assert!(
+        s.len() <= LongUInt::MAX as usize,
+        "long string exceeds 4 GiB"
+    );
     pair(gen_long_uint(s.len() as LongUInt), slice(s))
 }
 
@@ -167,6 +175,10 @@ fn gen_field_entry<'a, W: Write + BackToTheBuffer + 'a>(
 
 /// Generate the [ByteArray](../type.ByteArray.html) in the given buffer (x)
 pub fn gen_byte_array<'a, W: Write + 'a>(a: &'a ByteArray) -> impl SerializeFn<W> + 'a {
+    debug_assert!(
+        a.len() <= LongUInt::MAX as usize,
+        "byte array exceeds 4 GiB"
+    );
     pair(gen_long_uint(a.len() as LongUInt), slice(a.as_slice()))
 }
 

types/src/value.rs

@@ -75,14 +75,28 @@ impl AMQPValue {
             AMQPType::Boolean => value.as_bool().map(AMQPValue::Boolean),
             AMQPType::ShortShortInt => value
                 .as_i64()
-                .map(|i| AMQPValue::ShortShortInt(i as ShortShortInt)),
+                .and_then(|i| ShortShortInt::try_from(i).ok())
+                .map(AMQPValue::ShortShortInt),
             AMQPType::ShortShortUInt => value
                 .as_u64()
-                .map(|u| AMQPValue::ShortShortUInt(u as ShortShortUInt)),
-            AMQPType::ShortInt => value.as_i64().map(|i| AMQPValue::ShortInt(i as ShortInt)),
-            AMQPType::ShortUInt => value.as_u64().map(|u| AMQPValue::ShortUInt(u as ShortUInt)),
-            AMQPType::LongInt => value.as_i64().map(|i| AMQPValue::LongInt(i as LongInt)),
-            AMQPType::LongUInt => value.as_u64().map(|u| AMQPValue::LongUInt(u as LongUInt)),
+                .and_then(|u| ShortShortUInt::try_from(u).ok())
+                .map(AMQPValue::ShortShortUInt),
+            AMQPType::ShortInt => value
+                .as_i64()
+                .and_then(|i| ShortInt::try_from(i).ok())
+                .map(AMQPValue::ShortInt),
+            AMQPType::ShortUInt => value
+                .as_u64()
+                .and_then(|u| ShortUInt::try_from(u).ok())
+                .map(AMQPValue::ShortUInt),
+            AMQPType::LongInt => value
+                .as_i64()
+                .and_then(|i| LongInt::try_from(i).ok())
+                .map(AMQPValue::LongInt),
+            AMQPType::LongUInt => value
+                .as_u64()
+                .and_then(|u| LongUInt::try_from(u).ok())
+                .map(AMQPValue::LongUInt),
             AMQPType::LongLongInt => value
                 .as_i64()
                 .map(|i| AMQPValue::LongLongInt(i as LongLongInt)),