dd: parse big numbers and return u64::MAX

Change the behavior of `dd` so that it parses numbers that would be too
big and instead treats them as `u64::MAX`. This allows `dd` to run
without error on

    dd count=00x9999999999999999999999999999999999999999999999999999999999999

This matches the behavior of GNU `dd`.

Author: jfinkels

src/uu/dd/src/parseargs.rs

@@ -490,6 +490,8 @@ fn parse_bytes_only(s: &str) -> Result<u64, ParseError> {
 /// 512. You can also use standard block size suffixes like `'k'` for
 /// 1024.
 ///
+/// If the number would be too large, return [`std::u64::MAX`] instead.
+///
 /// # Errors
 ///
 /// If a number cannot be parsed or if the multiplication would cause
@@ -512,12 +514,10 @@ fn parse_bytes_no_x(full: &str, s: &str) -> Result<u64, ParseError> {
     let (num, multiplier) = match (s.find('c'), s.rfind('w'), s.rfind('b')) {
         (None, None, None) => match parser.parse_u64(s) {
             Ok(n) => (n, 1),
+            Err(ParseSizeError::SizeTooBig(_)) => (u64::MAX, 1),
             Err(ParseSizeError::InvalidSuffix(_) | ParseSizeError::ParseFailure(_)) => {
                 return Err(ParseError::InvalidNumber(full.to_string()))
             }
-            Err(ParseSizeError::SizeTooBig(_)) => {
-                return Err(ParseError::MultiplierStringOverflow(full.to_string()))
-            }
         },
         (Some(i), None, None) => (parse_bytes_only(&s[..i])?, 1),
         (None, Some(i), None) => (parse_bytes_only(&s[..i])?, 2),
@@ -632,6 +632,8 @@ mod tests {
 
     use crate::parseargs::parse_bytes_with_opt_multiplier;
 
+    const BIG: &str = "9999999999999999999999999999999999999999999999999999999999999";
+
     #[test]
     fn test_parse_bytes_with_opt_multiplier() {
         assert_eq!(parse_bytes_with_opt_multiplier("123").unwrap(), 123);
@@ -641,6 +643,7 @@ mod tests {
         assert_eq!(parse_bytes_with_opt_multiplier("123x3").unwrap(), 123 * 3);
         assert_eq!(parse_bytes_with_opt_multiplier("123k").unwrap(), 123 * 1024);
         assert_eq!(parse_bytes_with_opt_multiplier("1x2x3").unwrap(), 6); // 1 * 2 * 3
+        assert_eq!(parse_bytes_with_opt_multiplier(BIG).unwrap(), u64::MAX);
 
         assert_eq!(
             parse_bytes_with_opt_multiplier("1wx2cx3w").unwrap(),

src/uu/dd/src/parseargs/unit_tests.rs

@@ -506,14 +506,6 @@ mod test_64bit_arch {
     );
 }
 
-#[test]
-#[should_panic]
-fn test_overflow_panic() {
-    let bs_str = format!("{}KiB", u64::MAX);
-
-    parse_bytes_with_opt_multiplier(&bs_str).unwrap();
-}
-
 #[test]
 #[should_panic]
 fn test_neg_panic() {