always use parse_time::from_str first. Only if it fails AND the value is a huge overflow case, then cap it

Author: quantum-encoding

src/uu/timeout/src/timeout.rs

@@ -63,45 +63,50 @@ struct Config {
 /// Parse a duration string with overflow protection
 /// Caps extremely large values at a safe maximum that works on all platforms
 fn parse_duration_with_overflow_protection(duration_str: &str) -> UResult<Duration> {
-    // Pre-check for extremely large values that would overflow
-    // Only intercept if it's a simple integer + unit suffix pattern
-    let numeric_end = duration_str
-        .find(|c: char| !c.is_ascii_digit())
-        .unwrap_or(duration_str.len());
-
-    // Only apply overflow protection if we have a simple pattern: all digits followed by optional unit
-    if numeric_end > 0
-        && (numeric_end == duration_str.len()
-            || matches!(
-                duration_str.chars().nth(numeric_end),
-                Some('s') | Some('m') | Some('h') | Some('d')
-            ))
-    {
-        let numeric_part = &duration_str[..numeric_end];
-        let unit_suffix = &duration_str[numeric_end..];
-
-        if let Ok(num) = numeric_part.parse::<u128>() {
-            // Check if this would cause overflow
-            let (_multiplier, max_safe) = match unit_suffix {
-                "" | "s" => (1u64, u64::MAX),
-                "m" => (60, u64::MAX / 60),
-                "h" => (3600, u64::MAX / 3600),
-                "d" => (86400, u64::MAX / 86400),
-                _ => (1u64, u64::MAX), // Shouldn't reach here
-            };
-
-            if num > max_safe as u128 {
-                // Cap at a safe maximum (~34 years) that works on all platforms
-                // This matches the cap in process.rs for kqueue/sigtimedwait
-                const MAX_SAFE_TIMEOUT_SECS: u64 = (i32::MAX / 2) as u64;
-                return Ok(Duration::from_secs(MAX_SAFE_TIMEOUT_SECS));
+    // Try standard parsing first
+    match parse_time::from_str(duration_str, true) {
+        Ok(duration) => Ok(duration),
+        Err(_) => {
+            // If parsing fails, check if it's due to overflow with huge values
+            // Only try to handle simple numeric patterns: digits + optional unit suffix
+            let numeric_end = duration_str
+                .find(|c: char| !c.is_ascii_digit())
+                .unwrap_or(duration_str.len());
+
+            if numeric_end > 0 {
+                let numeric_part = &duration_str[..numeric_end];
+                let unit_suffix = &duration_str[numeric_end..];
+
+                if let Ok(num) = numeric_part.parse::<u128>() {
+                    // Check if this looks like a huge value that would overflow
+                    let max_safe = match unit_suffix {
+                        "" | "s" => u64::MAX,
+                        "m" => u64::MAX / 60,
+                        "h" => u64::MAX / 3600,
+                        "d" => u64::MAX / 86400,
+                        _ => {
+                            return Err(UUsageError::new(
+                                ExitStatus::TimeoutFailed.into(),
+                                format!("invalid time interval {duration_str}"),
+                            ));
+                        }
+                    };
+
+                    if num > max_safe as u128 {
+                        // Cap at a safe maximum (~34 years) that works on all platforms
+                        const MAX_SAFE_TIMEOUT_SECS: u64 = (i32::MAX / 2) as u64;
+                        return Ok(Duration::from_secs(MAX_SAFE_TIMEOUT_SECS));
+                    }
+                }
             }
+
+            // If it wasn't an overflow case, return the original error
+            Err(UUsageError::new(
+                ExitStatus::TimeoutFailed.into(),
+                format!("invalid time interval {duration_str}"),
+            ))
         }
     }
-
-    // For all other cases (including normal values), use the standard parser
-    parse_time::from_str(duration_str, true)
-        .map_err(|err| UUsageError::new(ExitStatus::TimeoutFailed.into(), err))
 }
 
 impl Config {