more overflows

Author: lovasoa

sqlx-core/src/postgres/message/bind.rs

@@ -52,10 +52,11 @@ impl Encode<'_> for Bind<'_> {
 
             buf.extend(self.params);
 
-            buf.extend(&(self.result_formats.len() as i16).to_be_bytes());
-
-            for &format in self.result_formats {
-                buf.extend(&(format as i16).to_be_bytes());
+            if let Ok(len) = i16::try_from(self.result_formats.len()) {
+                buf.extend(&len.to_be_bytes());
+                for &format in self.result_formats {
+                    buf.extend(&(format as i16).to_be_bytes());
+                }
             }
         });
     }

sqlx-core/src/postgres/message/copy.rs

@@ -43,7 +43,7 @@ impl Decode<'_> for CopyData<Bytes> {
 impl<B: Deref<Target = [u8]>> Encode<'_> for CopyData<B> {
     fn encode_with(&self, buf: &mut Vec<u8>, _context: ()) {
         buf.push(b'd');
-        buf.put_u32(self.0.len() as u32 + 4);
+        buf.put_u32(u32::try_from(self.0.len() + 4).expect("copydata too large"));
         buf.extend_from_slice(&self.0);
     }
 }
@@ -61,7 +61,7 @@ impl Encode<'_> for CopyFail {
         let len = 4 + self.message.len() + 1;
 
         buf.push(b'f'); // to pay respects
-        buf.put_u32(len as u32);
+        buf.put_u32(u32::try_from(len).expect("copyfail too large"));
         buf.put_str_nul(&self.message);
     }
 }

sqlx-core/src/postgres/message/data_row.rs

@@ -40,11 +40,11 @@ impl Decode<'_> for DataRow {
             let length = BigEndian::read_i32(&buf[(offset as usize)..]);
             offset += 4;
 
-            if length < 0 {
-                values.push(None);
-            } else {
-                values.push(Some(offset..(offset + length as u32)));
+            if let Ok(length) = u32::try_from(length) {
+                values.push(Some(offset..(offset + length)));
                 offset += length as u32;
+            } else {
+                values.push(None);
             }
         }
 

sqlx-core/src/postgres/message/parse.rs

@@ -28,12 +28,12 @@ impl Encode<'_> for Parse<'_> {
             buf.put_str_nul(self.query);
 
             // TODO: Return an error here instead
-            assert!(self.param_types.len() <= (u16::MAX as usize));
+            let param_len = i16::try_from(self.param_types.len()).expect("too many params");
 
-            buf.extend(&(self.param_types.len() as i16).to_be_bytes());
+            buf.extend_from_slice(&param_len.to_be_bytes());
 
             for &oid in self.param_types {
-                buf.extend(&oid.0.to_be_bytes());
+                buf.extend_from_slice(&oid.0.to_be_bytes());
             }
         })
     }

sqlx-core/src/postgres/message/query.rs

@@ -6,10 +6,10 @@ pub struct Query<'a>(pub &'a str);
 impl Encode<'_> for Query<'_> {
     fn encode_with(&self, buf: &mut Vec<u8>, _: ()) {
         let len = 4 + self.0.len() + 1;
-
+        let len_i32 = i32::try_from(len).expect("buffer too large");
         buf.reserve(len + 1);
         buf.push(b'Q');
-        buf.extend(&(len as i32).to_be_bytes());
+        buf.extend_from_slice(&len_i32.to_be_bytes());
         buf.put_str_nul(self.0);
     }
 }

sqlx-core/src/postgres/message/response.rs

@@ -192,7 +192,8 @@ impl<'a> Iterator for Fields<'a> {
             return None;
         }
 
-        let nul = memchr(b'\0', &self.storage[(self.offset + 1) as usize..])? as u16;
+        let nul =
+            u16::try_from(memchr(b'\0', &self.storage[(self.offset + 1) as usize..])?).ok()?;
         let offset = self.offset;
 
         self.offset += nul + 2;

sqlx-core/src/postgres/message/sasl.rs

@@ -16,9 +16,10 @@ impl Encode<'_> for SaslInitialResponse<'_> {
             } else {
                 "SCRAM-SHA-256"
             });
-
-            buf.extend(&(self.response.as_bytes().len() as i32).to_be_bytes());
-            buf.extend(self.response.as_bytes());
+            let bytes = self.response.as_bytes();
+            let len_i32 = i32::try_from(bytes.len()).expect("buffer too large");
+            buf.extend_from_slice(&len_i32.to_be_bytes());
+            buf.extend_from_slice(bytes);
         });
     }
 }

sqlx-core/src/postgres/options/pgpass.rs

@@ -178,7 +178,7 @@ fn find_next_field<'a>(line: &mut &'a str) -> Option<Cow<'a, str>> {
         }
     }
 
-    return None;
+    None
 }
 
 #[cfg(test)]

sqlx-core/src/postgres/types/array.rs

@@ -189,7 +189,7 @@ where
                     return Err(format!("encountered an array with a lower bound of {} in the first dimension; only arrays starting at one are supported", lower).into());
                 }
 
-                let mut elements = Vec::with_capacity(len as usize);
+                let mut elements = Vec::with_capacity(usize::try_from(len).unwrap_or_default());
 
                 for _ in 0..len {
                     elements.push(T::decode(PgValueRef::get(

sqlx-core/src/postgres/types/bigdecimal.rs

@@ -52,7 +52,7 @@ impl TryFrom<PgNumeric> for BigDecimal {
         };
 
         // weight is 0 if the decimal point falls after the first base-10000 digit
-        let scale = (digits.len() as i64 - weight as i64 - 1) * 4;
+        let scale = (i64::try_from(digits.len())? - i64::from(weight) - 1) * 4;
 
         // no optimized algorithm for base-10 so use base-100 for faster processing
         let mut cents = Vec::with_capacity(digits.len() * 2);