fix Prevent command-line panics on malformed user input

src/rust/src/parser.rs

@@ -41,7 +41,9 @@ cfg_if! {
 
 fn set_usercolor_rgb(color: &str) {
     let mut rgb: [i32; 8] = [0; 8];
-    for (i, item) in color.chars().enumerate() {
+    // We only have room for 7 characters before the null terminator.
+    // Malformed input shouldn't cause a buffer overflow here.
+    for (i, item) in color.chars().take(7).enumerate() {
         rgb[i] = item as i32;
     }
     rgb[7] = 0;
@@ -57,13 +59,15 @@ fn set_mpeg_clock_freq(freq: i32) {
 }
 
 fn atol(bufsize: &str) -> i32 {
-    let mut val = bufsize[0..bufsize.len() - 1].parse::<i32>().unwrap();
-    let size = bufsize
-        .to_string()
-        .to_uppercase()
-        .chars()
-        .nth(bufsize.len() - 1)
-        .unwrap();
+    if bufsize.is_empty() {
+        panic!("empty buffer size (validated by clap)");
+    }
+    // We expect at least one digit and a suffix (K, M, etc.)
+    let val_str = &bufsize[0..bufsize.len().saturating_sub(1)];
+    let mut val = val_str
+        .parse::<i32>()
+        .expect("invalid buffer size number (should be validated by clap)");
+    let size = bufsize.to_uppercase().chars().last().unwrap_or(' ');
     if size == 'M' {
         val *= 1024 * 1024;
     } else if size == 'K' {
@@ -91,12 +95,7 @@ where
 {
     match atoi_hex(s) {
         Ok(val) => val,
-        Err(_) => {
-            fatal!(
-                cause = ExitCause::MalformedParameter;
-                "Malformed parameter: {}",s
-            );
-        }
+        Err(_) => panic!("malformed parameter: {} (should be validated by clap)", s),
     }
 }
 
@@ -400,11 +399,13 @@ impl OptionsExt for Options {
             DtvccServiceCharset::Unique(Box::new([ARRAY_REPEAT_VALUE; DTVCC_MAX_SERVICES]));
 
         for (i, service) in services.iter().enumerate() {
-            let svc = service.parse::<usize>().unwrap();
+            let svc = service.parse::<usize>().expect(
+                "[CEA-708] Malformed parameter: Invalid service number (validated by clap)",
+            );
             if !(1..=DTVCC_MAX_SERVICES).contains(&svc) {
-                fatal!(
-                    cause = ExitCause::MalformedParameter;
-                  "[CEA-708] Malformed parameter: Invalid service number ({}), valid range is 1-{}.\n", svc, DTVCC_MAX_SERVICES
+                panic!(
+                    "[CEA-708] Malformed parameter: Invalid service number ({}), valid range is 1-{}. (validated by clap)",
+                    svc, DTVCC_MAX_SERVICES
                 );
             }
             self.settings_dtvcc.services_enabled[svc - 1] = true;
@@ -421,10 +422,7 @@ impl OptionsExt for Options {
         }
 
         if self.settings_dtvcc.active_services_count == 0 {
-            fatal!(
-                cause = ExitCause::MalformedParameter;
-               "[CEA-708] Malformed parameter: no services\n"
-            );
+            panic!("[CEA-708] Malformed parameter: no services (validated by clap)");
         }
     }
 
@@ -759,10 +757,7 @@ impl OptionsExt for Options {
 
         if let Some(ref quant) = args.quant {
             if !(0..=2).contains(quant) {
-                fatal!(
-                    cause = ExitCause::MalformedParameter;
-                   "Invalid quant value"
-                );
+                panic!("Invalid quant value (validated by clap)");
             }
             self.ocr_quantmode = *quant;
         }
@@ -773,20 +768,14 @@ impl OptionsExt for Options {
 
         if let Some(ref oem) = args.oem {
             if !(0..=2).contains(oem) {
-                fatal!(
-                    cause = ExitCause::MalformedParameter;
-                   "oem value should be between 0 and 2"
-                );
+                panic!("oem value should be between 0 and 2 (validated by clap)");
             }
             self.ocr_oem = *oem as _;
         }
 
         if let Some(ref psm) = args.psm {
             if !(0..=13).contains(psm) {
-                fatal!(
-                    cause = ExitCause::MalformedParameter;
-                   "--psm must be between 0 and 13"
-                );
+                panic!("--psm must be between 0 and 13 (validated by clap)");
             }
             self.psm = *psm as _;
         }
@@ -823,36 +812,38 @@ impl OptionsExt for Options {
         }
 
         if let Some(ref startcreditsnotbefore) = args.startcreditsnotbefore {
-            self.enc_cfg.startcreditsnotbefore =
-                stringztoms(startcreditsnotbefore.clone().as_str()).unwrap();
+            self.enc_cfg.startcreditsnotbefore = stringztoms(startcreditsnotbefore.as_str())
+                .expect("Malformed parameter: --startcreditsnotbefore invalid (validated by clap)");
         }
 
         if let Some(ref startcreditsnotafter) = args.startcreditsnotafter {
-            self.enc_cfg.startcreditsnotafter =
-                stringztoms(startcreditsnotafter.clone().as_str()).unwrap();
+            self.enc_cfg.startcreditsnotafter = stringztoms(startcreditsnotafter.as_str())
+                .expect("Malformed parameter: --startcreditsnotafter invalid (validated by clap)");
         }
 
         if let Some(ref startcreditsforatleast) = args.startcreditsforatleast {
-            self.enc_cfg.startcreditsforatleast =
-                stringztoms(startcreditsforatleast.clone().as_str()).unwrap();
+            self.enc_cfg.startcreditsforatleast = stringztoms(startcreditsforatleast.as_str())
+                .expect(
+                    "Malformed parameter: --startcreditsforatleast invalid (validated by clap)",
+                );
         }
         if let Some(ref startcreditsforatmost) = args.startcreditsforatmost {
-            self.enc_cfg.startcreditsforatmost =
-                stringztoms(startcreditsforatmost.clone().as_str()).unwrap();
+            self.enc_cfg.startcreditsforatmost = stringztoms(startcreditsforatmost.as_str())
+                .expect("Malformed parameter: --startcreditsforatmost invalid (validated by clap)");
         }
 
         if let Some(ref endcreditstext) = args.endcreditstext {
             self.enc_cfg.end_credits_text.clone_from(endcreditstext);
         }
 
         if let Some(ref endcreditsforatleast) = args.endcreditsforatleast {
-            self.enc_cfg.endcreditsforatleast =
-                stringztoms(endcreditsforatleast.clone().as_str()).unwrap();
+            self.enc_cfg.endcreditsforatleast = stringztoms(endcreditsforatleast.as_str())
+                .expect("Malformed parameter: --endcreditsforatleast invalid (validated by clap)");
         }
 
         if let Some(ref endcreditsforatmost) = args.endcreditsforatmost {
-            self.enc_cfg.endcreditsforatmost =
-                stringztoms(endcreditsforatmost.clone().as_str()).unwrap();
+            self.enc_cfg.endcreditsforatmost = stringztoms(endcreditsforatmost.as_str())
+                .expect("Malformed parameter: --endcreditsforatmost invalid (validated by clap)");
         }
 
         /* More stuff */
@@ -986,10 +977,7 @@ impl OptionsExt for Options {
 
         if let Some(ref defaultcolor) = args.defaultcolor {
             if defaultcolor.len() != 7 || !defaultcolor.starts_with('#') {
-                fatal!(
-                    cause = ExitCause::MalformedParameter;
-                   "Invalid default color"
-                );
+                panic!("Invalid default color (validated by clap)");
             }
             set_usercolor_rgb(defaultcolor);
             self.settings_608.default_color = Decoder608ColorCode::Userdefined;
@@ -1004,10 +992,16 @@ impl OptionsExt for Options {
         }
 
         if let Some(ref startat) = args.startat {
-            self.extraction_start = Some(stringztoms(startat.clone().as_str()).unwrap());
+            self.extraction_start = Some(
+                stringztoms(startat.as_str())
+                    .expect("Malformed parameter: --startat invalid (validated by clap)"),
+            );
         }
         if let Some(ref endat) = args.endat {
-            self.extraction_end = Some(stringztoms(endat.clone().as_str()).unwrap());
+            self.extraction_end = Some(
+                stringztoms(endat.as_str())
+                    .expect("Malformed parameter: --endat invalid (validated by clap)"),
+            );
         }
 
         if args.cc2 {
@@ -1020,10 +1014,7 @@ impl OptionsExt for Options {
             } else if *extract == "both" {
                 self.extract = 12;
             } else {
-                fatal!(
-                    cause = ExitCause::MalformedParameter;
-                   "Invalid output field"
-                );
+                panic!("Invalid output field (validated by clap)");
             }
             self.is_608_enabled = true;
         }