Merge branch 'main' into columns_env_support

sylvestre · web-flow · commit 2addcfe56480 · 2025-11-26T11:41:39.000+01:00
diff --git a/src/uu/stty/src/stty.rs b/src/uu/stty/src/stty.rs
@@ -10,7 +10,7 @@
 // spell-checker:ignore isig icanon iexten echoe crterase echok echonl noflsh xcase tostop echoprt prterase echoctl ctlecho echoke crtkill flusho extproc
 // spell-checker:ignore lnext rprnt susp swtch vdiscard veof veol verase vintr vkill vlnext vquit vreprint vstart vstop vsusp vswtc vwerase werase
 // spell-checker:ignore sigquit sigtstp
-// spell-checker:ignore cbreak decctlq evenp litout oddp tcsadrain exta extb
+// spell-checker:ignore cbreak decctlq evenp litout oddp tcsadrain exta extb NCCS
 
 mod flags;
 
@@ -30,7 +30,7 @@ use std::num::IntErrorKind;
 use std::os::fd::{AsFd, BorrowedFd};
 use std::os::unix::fs::OpenOptionsExt;
 use std::os::unix::io::{AsRawFd, RawFd};
-use uucore::error::{UError, UResult, USimpleError};
+use uucore::error::{UError, UResult, USimpleError, UUsageError};
 use uucore::format_usage;
 use uucore::translate;
 
@@ -150,6 +150,7 @@ enum ArgOptions<'a> {
     Mapping((S, u8)),
     Special(SpecialSetting),
     Print(PrintSetting),
+    SavedState(Vec<u32>),
 }
 
 impl<'a> From<AllFlags<'a>> for ArgOptions<'a> {
@@ -352,8 +353,12 @@ fn stty(opts: &Options) -> UResult<()> {
                     valid_args.push(ArgOptions::Print(PrintSetting::Size));
                 }
                 _ => {
+                    // Try to parse saved format (hex string like "6d02:5:4bf:8a3b:...")
+                    if let Some(state) = parse_saved_state(arg) {
+                        valid_args.push(ArgOptions::SavedState(state));
+                    }
                     // control char
-                    if let Some(char_index) = cc_to_index(arg) {
+                    else if let Some(char_index) = cc_to_index(arg) {
                         if let Some(mapping) = args_iter.next() {
                             let cc_mapping = string_to_control_char(mapping).map_err(|e| {
                                 let message = match e {
@@ -370,7 +375,7 @@ fn stty(opts: &Options) -> UResult<()> {
                                         )
                                     }
                                 };
-                                USimpleError::new(1, message)
+                                UUsageError::new(1, message)
                             })?;
                             valid_args.push(ArgOptions::Mapping((char_index, cc_mapping)));
                         } else {
@@ -418,6 +423,9 @@ fn stty(opts: &Options) -> UResult<()> {
                 ArgOptions::Print(setting) => {
                     print_special_setting(setting, opts.file.as_raw_fd())?;
                 }
+                ArgOptions::SavedState(state) => {
+                    apply_saved_state(&mut termios, state)?;
+                }
             }
         }
         tcsetattr(opts.file.as_fd(), set_arg, &termios)?;
@@ -429,8 +437,9 @@ fn stty(opts: &Options) -> UResult<()> {
     Ok(())
 }
 
+// The GNU implementation adds the --help message when the args are incorrectly formatted
 fn missing_arg<T>(arg: &str) -> Result<T, Box<dyn UError>> {
-    Err::<T, Box<dyn UError>>(USimpleError::new(
+    Err(UUsageError::new(
         1,
         translate!(
             "stty-error-missing-argument",
@@ -440,7 +449,7 @@ fn missing_arg<T>(arg: &str) -> Result<T, Box<dyn UError>> {
 }
 
 fn invalid_arg<T>(arg: &str) -> Result<T, Box<dyn UError>> {
-    Err::<T, Box<dyn UError>>(USimpleError::new(
+    Err(UUsageError::new(
         1,
         translate!(
             "stty-error-invalid-argument",
@@ -450,7 +459,7 @@ fn invalid_arg<T>(arg: &str) -> Result<T, Box<dyn UError>> {
 }
 
 fn invalid_integer_arg<T>(arg: &str) -> Result<T, Box<dyn UError>> {
-    Err::<T, Box<dyn UError>>(USimpleError::new(
+    Err(UUsageError::new(
         1,
         translate!(
             "stty-error-invalid-integer-argument",
@@ -478,6 +487,43 @@ fn parse_rows_cols(arg: &str) -> Option<u16> {
     None
 }
 
+/// Parse a saved terminal state string in stty format.
+///
+/// The format is colon-separated hexadecimal values:
+/// `input_flags:output_flags:control_flags:local_flags:cc0:cc1:cc2:...`
+///
+/// - Must have exactly 4 + NCCS parts (4 flags + platform-specific control characters)
+/// - All parts must be non-empty valid hex values
+/// - Control characters must fit in u8 (0-255)
+/// - Returns `None` if format is invalid
+fn parse_saved_state(arg: &str) -> Option<Vec<u32>> {
+    let parts: Vec<&str> = arg.split(':').collect();
+    let expected_parts = 4 + nix::libc::NCCS;
+
+    // GNU requires exactly the right number of parts for this platform
+    if parts.len() != expected_parts {
+        return None;
+    }
+
+    // Validate all parts are non-empty valid hex
+    let mut values = Vec::with_capacity(expected_parts);
+    for (i, part) in parts.iter().enumerate() {
+        if part.is_empty() {
+            return None; // GNU rejects empty hex values
+        }
+        let val = u32::from_str_radix(part, 16).ok()?;
+
+        // Control characters (indices 4+) must fit in u8
+        if i >= 4 && val > 255 {
+            return None;
+        }
+
+        values.push(val);
+    }
+
+    Some(values)
+}
+
 fn check_flag_group<T>(flag: &Flag<T>, remove: bool) -> bool {
     remove && flag.group.is_some()
 }
@@ -938,6 +984,39 @@ fn apply_char_mapping(termios: &mut Termios, mapping: &(S, u8)) {
     termios.control_chars[mapping.0 as usize] = mapping.1;
 }
 
+/// Apply a saved terminal state to the current termios.
+///
+/// The state array contains:
+/// - `state[0]`: input flags
+/// - `state[1]`: output flags  
+/// - `state[2]`: control flags
+/// - `state[3]`: local flags
+/// - `state[4..]`: control characters (optional)
+///
+/// If state has fewer than 4 elements, no changes are applied. This is a defensive
+/// check that should never trigger since `parse_saved_state` rejects such states.
+fn apply_saved_state(termios: &mut Termios, state: &[u32]) -> nix::Result<()> {
+    // Require at least 4 elements for the flags (defensive check)
+    if state.len() < 4 {
+        return Ok(()); // No-op for invalid state (already validated by parser)
+    }
+
+    // Apply the four flag groups, done (as _) for MacOS size compatibility
+    termios.input_flags = InputFlags::from_bits_truncate(state[0] as _);
+    termios.output_flags = OutputFlags::from_bits_truncate(state[1] as _);
+    termios.control_flags = ControlFlags::from_bits_truncate(state[2] as _);
+    termios.local_flags = LocalFlags::from_bits_truncate(state[3] as _);
+
+    // Apply control characters if present (stored as u32 but used as u8)
+    for (i, &cc_val) in state.iter().skip(4).enumerate() {
+        if i < termios.control_chars.len() {
+            termios.control_chars[i] = cc_val as u8;
+        }
+    }
+
+    Ok(())
+}
+
 fn apply_special_setting(
     _termios: &mut Termios,
     setting: &SpecialSetting,
diff --git a/tests/by-util/test_stty.rs b/tests/by-util/test_stty.rs
@@ -2,10 +2,18 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore parenb parmrk ixany iuclc onlcr icanon noflsh econl igpar ispeed ospeed
+// spell-checker:ignore parenb parmrk ixany iuclc onlcr icanon noflsh econl igpar ispeed ospeed NCCS nonhex gstty
 
-use uutests::new_ucmd;
-use uutests::util::pty_path;
+use uutests::util::{expected_result, pty_path};
+use uutests::{at_and_ts, new_ucmd, unwrap_or_return};
+
+/// Normalize stderr by replacing the full binary path with just the utility name
+/// This allows comparison between GNU (which shows "stty" or "gstty") and ours (which shows full path)
+fn normalize_stderr(stderr: &str) -> String {
+    // Replace patterns like "Try 'gstty --help'" or "Try '/path/to/stty --help'" with "Try 'stty --help'"
+    let re = regex::Regex::new(r"Try '[^']*(?:g)?stty --help'").unwrap();
+    re.replace_all(stderr, "Try 'stty --help'").to_string()
+}
 
 #[test]
 fn test_invalid_arg() {
@@ -406,3 +414,172 @@ fn test_columns_env_wrapping() {
         );
     }
 }
+
+// Tests for saved state parsing and restoration
+#[test]
+#[cfg(unix)]
+fn test_save_and_restore() {
+    let (path, _controller, _replica) = pty_path();
+    let saved = new_ucmd!()
+        .args(&["--save", "--file", &path])
+        .succeeds()
+        .stdout_move_str();
+
+    let saved = saved.trim();
+    assert!(saved.contains(':'));
+
+    new_ucmd!().args(&["--file", &path, saved]).succeeds();
+}
+
+#[test]
+#[cfg(unix)]
+fn test_save_with_g_flag() {
+    let (path, _controller, _replica) = pty_path();
+    let saved = new_ucmd!()
+        .args(&["-g", "--file", &path])
+        .succeeds()
+        .stdout_move_str();
+
+    let saved = saved.trim();
+    assert!(saved.contains(':'));
+
+    new_ucmd!().args(&["--file", &path, saved]).succeeds();
+}
+
+#[test]
+#[cfg(unix)]
+fn test_save_restore_after_change() {
+    let (path, _controller, _replica) = pty_path();
+    let saved = new_ucmd!()
+        .args(&["--save", "--file", &path])
+        .succeeds()
+        .stdout_move_str();
+
+    let saved = saved.trim();
+
+    new_ucmd!()
+        .args(&["--file", &path, "intr", "^A"])
+        .succeeds();
+
+    new_ucmd!().args(&["--file", &path, saved]).succeeds();
+
+    new_ucmd!()
+        .args(&["--file", &path])
+        .succeeds()
+        .stdout_str_check(|s| !s.contains("intr = ^A"));
+}
+
+// These tests both validate what we expect each input to return and their error codes
+// and also use the GNU coreutils results to validate our results match expectations
+#[test]
+#[cfg(unix)]
+fn test_saved_state_valid_formats() {
+    let (path, _controller, _replica) = pty_path();
+    let (_at, ts) = at_and_ts!();
+
+    // Generate valid saved state from the actual terminal
+    let saved = unwrap_or_return!(expected_result(&ts, &["-g", "--file", &path])).stdout_move_str();
+    let saved = saved.trim();
+
+    let result = ts.ucmd().args(&["--file", &path, saved]).run();
+
+    result.success().no_stderr();
+
+    let exp_result = unwrap_or_return!(expected_result(&ts, &["--file", &path, saved]));
+    let normalized_stderr = normalize_stderr(result.stderr_str());
+    result
+        .stdout_is(exp_result.stdout_str())
+        .code_is(exp_result.code());
+    assert_eq!(normalized_stderr, exp_result.stderr_str());
+}
+
+#[test]
+#[cfg(unix)]
+fn test_saved_state_invalid_formats() {
+    let (path, _controller, _replica) = pty_path();
+    let (_at, ts) = at_and_ts!();
+
+    let num_cc = nix::libc::NCCS;
+
+    // Build test strings with platform-specific counts
+    let cc_zeros = vec!["0"; num_cc].join(":");
+    let cc_with_invalid = if num_cc > 0 {
+        let mut parts = vec!["1c"; num_cc];
+        parts[0] = "100"; // First control char > 255
+        parts.join(":")
+    } else {
+        String::new()
+    };
+    let cc_with_space = if num_cc > 0 {
+        let mut parts = vec!["1c"; num_cc];
+        parts[0] = "1c "; // Space in hex
+        parts.join(":")
+    } else {
+        String::new()
+    };
+    let cc_with_nonhex = if num_cc > 0 {
+        let mut parts = vec!["1c"; num_cc];
+        parts[0] = "xyz"; // Non-hex
+        parts.join(":")
+    } else {
+        String::new()
+    };
+    let cc_with_empty = if num_cc > 0 {
+        let mut parts = vec!["1c"; num_cc];
+        parts[0] = ""; // Empty
+        parts.join(":")
+    } else {
+        String::new()
+    };
+
+    // Cannot test single value since it would be interpreted as baud rate
+    let invalid_states = vec![
+        "500:5:4bf".to_string(),                        // fewer than expected parts
+        "500:5:4bf:8a3b".to_string(),                   // only 4 parts
+        format!("500:5:{}:8a3b:{}", cc_zeros, "extra"), // too many parts
+        format!("500::4bf:8a3b:{}", cc_zeros),          // empty hex value in flags
+        format!("500:5:4bf:8a3b:{}", cc_with_empty),    // empty hex value in cc
+        format!("500:5:4bf:8a3b:{}", cc_with_nonhex),   // non-hex characters
+        format!("500:5:4bf:8a3b:{}", cc_with_space),    // space in hex value
+        format!("500:5:4bf:8a3b:{}", cc_with_invalid),  // control char > 255
+    ];
+
+    for state in &invalid_states {
+        let result = ts.ucmd().args(&["--file", &path, state]).run();
+
+        result.failure().stderr_contains("invalid argument");
+
+        let exp_result = unwrap_or_return!(expected_result(&ts, &["--file", &path, state]));
+        let normalized_stderr = normalize_stderr(result.stderr_str());
+        let exp_normalized_stderr = normalize_stderr(exp_result.stderr_str());
+        result
+            .stdout_is(exp_result.stdout_str())
+            .code_is(exp_result.code());
+        assert_eq!(normalized_stderr, exp_normalized_stderr);
+    }
+}
+
+#[test]
+#[cfg(unix)]
+#[ignore = "Fails because the implementation of print state is not correctly printing flags on certain platforms"]
+fn test_saved_state_with_control_chars() {
+    let (path, _controller, _replica) = pty_path();
+    let (_at, ts) = at_and_ts!();
+
+    // Build a valid saved state with platform-specific number of control characters
+    let num_cc = nix::libc::NCCS;
+    let cc_values: Vec<String> = (1..=num_cc).map(|_| format!("{:x}", 0)).collect();
+    let saved_state = format!("500:5:4bf:8a3b:{}", cc_values.join(":"));
+
+    ts.ucmd().args(&["--file", &path, &saved_state]).succeeds();
+
+    let result = ts.ucmd().args(&["-g", "--file", &path]).run();
+
+    result.success().stdout_contains(":");
+
+    let exp_result = unwrap_or_return!(expected_result(&ts, &["-g", "--file", &path]));
+    result
+        .stdout_is(exp_result.stdout_str())
+        .stderr_is(exp_result.stderr_str())
+        .code_is(exp_result.code());
+}
diff --git a/util/build-gnu.sh b/util/build-gnu.sh
@@ -4,7 +4,7 @@
 
 # spell-checker:ignore (paths) abmon deref discrim eacces getlimits getopt ginstall inacc infloop inotify reflink ; (misc) INT_OFLOW OFLOW
 # spell-checker:ignore baddecode submodules xstrtol distros ; (vars/env) SRCDIR vdir rcexp xpart dired OSTYPE ; (utils) gnproc greadlink gsed multihardlink texinfo CARGOFLAGS
-# spell-checker:ignore openat TOCTOU
+# spell-checker:ignore openat TOCTOU CFLAGS
 
 set -e
 
@@ -131,7 +131,8 @@ else
     # Disable useless checks
     "${SED}" -i 's|check-texinfo: $(syntax_checks)|check-texinfo:|' doc/local.mk
     ./bootstrap --skip-po
-    ./configure --quiet --disable-gcc-warnings --disable-nls --disable-dependency-tracking --disable-bold-man-page-references \
+    # Use CFLAGS for best build time since we discard GNU coreutils
+    CFLAGS="${CFLAGS} -pipe -O0 -s" ./configure --quiet --disable-gcc-warnings --disable-nls --disable-dependency-tracking --disable-bold-man-page-references \
       "$([ "${SELINUX_ENABLED}" = 1 ] && echo --with-selinux || echo --without-selinux)"
     #Add timeout to to protect against hangs
     "${SED}" -i 's|^"\$@|'"${SYSTEM_TIMEOUT}"' 600 "\$@|' build-aux/test-driver
