Fix signal termination handling and add 255 byte limit for -I mode

- Add immediate exit on signal termination (POSIX compliance)
- Enforce 4096 byte limit for -I constructed arguments (POSIX requires ≥255)
- Add 7 new tests for POSIX compliance gaps:
  * Single quote handling
  * Mixed quotes
  * Empty input
  * Line continuation with -L
  * Multiple replstr in -I
  * Five arguments with replstr in -I
  * Combining -n and -s options

Co-authored-by: jgarzik <494411+jgarzik@users.noreply.github.com>

Author: Copilot

process/tests/xargs/mod.rs

@@ -211,3 +211,104 @@ fn xargs_escaped_chars() {
     // Test escaped characters
     xargs_test("hello\\ world\n", "hello world\n", vec!["echo"]);
 }
+
+#[test]
+fn xargs_single_quotes() {
+    // Test single quote (apostrophe) handling
+    xargs_test("'hello world'\n", "hello world\n", vec!["echo"]);
+}
+
+#[test]
+fn xargs_mixed_quotes() {
+    // Test mix of single and double quotes
+    xargs_test(
+        "'single' \"double\" plain\n",
+        "single double plain\n",
+        vec!["echo"],
+    );
+}
+
+#[test]
+fn xargs_empty_input() {
+    // Empty input should not execute the utility
+    run_test(TestPlan {
+        cmd: String::from("xargs"),
+        args: vec!["echo".to_string()],
+        stdin_data: String::from(""),
+        expected_out: String::from(""),
+        expected_err: String::from(""),
+        expected_exit_code: 0,
+    });
+}
+
+#[test]
+fn xargs_line_continuation() {
+    // -L with trailing blank should continue to next line
+    run_test(TestPlan {
+        cmd: String::from("xargs"),
+        args: vec!["-L".to_string(), "1".to_string(), "echo".to_string()],
+        stdin_data: String::from("one \ntwo\nthree\n"),
+        expected_out: String::from("one two\nthree\n"),
+        expected_err: String::from(""),
+        expected_exit_code: 0,
+    });
+}
+
+#[test]
+fn xargs_insert_multiple_replstr() {
+    // -I with multiple occurrences of replstr in same argument
+    run_test(TestPlan {
+        cmd: String::from("xargs"),
+        args: vec![
+            "-I".to_string(),
+            "{}".to_string(),
+            "echo".to_string(),
+            "{}-{}-{}".to_string(),
+        ],
+        stdin_data: String::from("test\n"),
+        expected_out: String::from("test-test-test\n"),
+        expected_err: String::from(""),
+        expected_exit_code: 0,
+    });
+}
+
+#[test]
+fn xargs_insert_five_args_with_replstr() {
+    // -I with replstr in 5 arguments (POSIX requires at least 5)
+    run_test(TestPlan {
+        cmd: String::from("xargs"),
+        args: vec![
+            "-I".to_string(),
+            "{}".to_string(),
+            "echo".to_string(),
+            "{}".to_string(),
+            "{}".to_string(),
+            "{}".to_string(),
+            "{}".to_string(),
+            "{}".to_string(),
+        ],
+        stdin_data: String::from("x\n"),
+        expected_out: String::from("x x x x x\n"),
+        expected_err: String::from(""),
+        expected_exit_code: 0,
+    });
+}
+
+#[test]
+fn xargs_combine_n_and_s() {
+    // Combining -n and -s should work together
+    run_test(TestPlan {
+        cmd: String::from("xargs"),
+        args: vec![
+            "-n".to_string(),
+            "2".to_string(),
+            "-s".to_string(),
+            "20".to_string(),
+            "echo".to_string(),
+        ],
+        stdin_data: String::from("a b c d e\n"),
+        expected_out: String::from("a b\nc d\ne\n"),
+        expected_err: String::from(""),
+        expected_exit_code: 0,
+    });
+}

process/xargs.rs

@@ -17,6 +17,9 @@ use gettextrs::{bind_textdomain_codeset, gettext, setlocale, textdomain, LocaleC
 use plib::BUFSZ;
 
 const FALLBACK_ARG_MAX: usize = 131072;
+// POSIX requires at least 255 bytes for -I constructed arguments
+// We use a higher limit for better usability
+const INSERT_ARG_MAX: usize = 4096;
 
 fn get_arg_max() -> usize {
     let result = unsafe { libc::sysconf(libc::_SC_ARG_MAX) };
@@ -536,6 +539,20 @@ fn exec_insert_mode(
         .map(|arg| arg.replace(replstr, input_arg))
         .collect();
 
+    // POSIX: Check that constructed arguments don't exceed the limit
+    // POSIX requires at least 255 bytes, we use INSERT_ARG_MAX (4096)
+    for arg in &util_args {
+        if arg.len() > INSERT_ARG_MAX {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                format!(
+                    "xargs: constructed argument exceeds {} byte limit in insert mode",
+                    INSERT_ARG_MAX
+                ),
+            ));
+        }
+    }
+
     exec_util(&args.util, util_args, trace, prompt)
 }
 
@@ -552,6 +569,11 @@ macro_rules! handle_exec_result {
             ExecResult::Exited(255) => {
                 return Ok(SpawnResult { exit_code: 1 });
             }
+            ExecResult::Exited(code) if code >= 128 => {
+                // POSIX: utility terminated by signal - exit immediately
+                eprintln!("xargs: command terminated by signal");
+                return Ok(SpawnResult { exit_code: 1 });
+            }
             ExecResult::Exited(code) if code != 0 => {
                 $any_failed = true;
             }
@@ -682,6 +704,11 @@ fn read_and_spawn(args: &Args) -> io::Result<SpawnResult> {
                 ExecResult::Exited(255) => {
                     return Ok(SpawnResult { exit_code: 1 });
                 }
+                ExecResult::Exited(code) if code >= 128 => {
+                    // POSIX: utility terminated by signal - exit immediately
+                    eprintln!("xargs: command terminated by signal");
+                    return Ok(SpawnResult { exit_code: 1 });
+                }
                 ExecResult::Exited(code) if code != 0 => {
                     any_failed = true;
                 }
@@ -703,6 +730,11 @@ fn read_and_spawn(args: &Args) -> io::Result<SpawnResult> {
             ExecResult::Exited(255) => {
                 return Ok(SpawnResult { exit_code: 1 });
             }
+            ExecResult::Exited(code) if code >= 128 => {
+                // POSIX: utility terminated by signal - exit immediately
+                eprintln!("xargs: command terminated by signal");
+                return Ok(SpawnResult { exit_code: 1 });
+            }
             ExecResult::Exited(code) if code != 0 => {
                 any_failed = true;
             }