Allow job control without controlling terminal

When job control is enabled and the shell does not have a controlling
terminal, the shell now proceeds without managing foreground-ness of
process groups. Jobs are still assigned to their own process groups.
Previously, the shell would abort command execution in this case.

Closes #480

Author: magicant

yash-builtin/CHANGELOG.md

@@ -83,6 +83,8 @@ The `wait` built-in no longer treats suspended jobs as terminated jobs.
   enabled.
 - The `fg::main` function now returns with `Divert::Interrupt` when the resumed
   job is suspended.
+- The `fg::main` function no longer errors out if `yash_env::Env::get_tty`
+  fails.
 - The `kill::print::print` function now shows signals in the ascending order of
   their numbers when given no signals.
 - The `read::syntax::parse` function now accepts the `-d` (`--delimiter`) option.

yash-builtin/src/fg.rs

@@ -115,7 +115,7 @@ use yash_env::system::SystemEx as _;
 ///
 /// This function panics if there is no job at the specified index.
 async fn resume_job_by_index(env: &mut Env, index: usize) -> Result<ProcessResult, ResumeError> {
-    let tty = env.get_tty()?;
+    let tty = env.get_tty().ok();
 
     let job = &env.jobs[index];
     if !job.is_owned {
@@ -141,7 +141,9 @@ async fn resume_job_by_index(env: &mut Env, index: usize) -> Result<ProcessResul
 
             // Make sure to put the target job in the foreground before sending the
             // SIGCONT signal, or the job may be immediately re-suspended.
-            env.system.tcsetpgrp_without_block(tty, job.pid)?;
+            if let Some(tty) = tty {
+                env.system.tcsetpgrp_without_block(tty, job.pid)?;
+            }
 
             let pgid = -job.pid;
             let sigcont = env.system.signal_number_from_name(signal::Name::Cont);
@@ -152,7 +154,9 @@ async fn resume_job_by_index(env: &mut Env, index: usize) -> Result<ProcessResul
             let result = env.wait_for_subshell_to_halt(job.pid).await?.1;
 
             // Move the shell back to the foreground.
-            env.system.tcsetpgrp_with_block(tty, env.main_pgid)?;
+            if let Some(tty) = tty {
+                env.system.tcsetpgrp_with_block(tty, env.main_pgid)?;
+            }
 
             result
         }
@@ -265,10 +269,35 @@ mod tests {
         })
     }
 
+    #[test]
+    fn resume_job_by_index_resume_job_even_without_tty() {
+        in_virtual_system(async |mut env, _| {
+            env.options.set(Monitor, On);
+            let reached = Rc::new(Cell::new(false));
+            let reached2 = Rc::clone(&reached);
+            let subshell = Subshell::new(|env, _| {
+                Box::pin(async move {
+                    suspend(env).await;
+                    reached2.set(true);
+                })
+            })
+            .job_control(JobControl::Foreground);
+            let (pid, subshell_result) = subshell.start_and_wait(&mut env).await.unwrap();
+            assert_eq!(subshell_result, ProcessResult::Stopped(SIGSTOP));
+            let mut job = Job::new(pid);
+            job.job_controlled = true;
+            job.state = subshell_result.into();
+            let index = env.jobs.add(job);
+
+            resume_job_by_index(&mut env, index).await.unwrap();
+
+            assert!(reached.get());
+        })
+    }
+
     #[test]
     fn resume_job_by_index_prints_job_name() {
         in_virtual_system(|mut env, state| async move {
-            stub_tty(&state);
             env.options.set(Monitor, On);
             let subshell =
                 Subshell::new(|env, _| Box::pin(suspend(env))).job_control(JobControl::Foreground);
@@ -289,7 +318,6 @@ mod tests {
     #[test]
     fn resume_job_by_index_returns_after_job_exits() {
         in_virtual_system(|mut env, state| async move {
-            stub_tty(&state);
             env.options.set(Monitor, On);
             let subshell = Subshell::new(|env, _| {
                 Box::pin(async move {
@@ -318,7 +346,6 @@ mod tests {
     #[test]
     fn resume_job_by_index_returns_after_job_suspends() {
         in_virtual_system(|mut env, state| async move {
-            stub_tty(&state);
             env.options.set(Monitor, On);
             let subshell = Subshell::new(|env, _| {
                 Box::pin(async move {
@@ -369,7 +396,6 @@ mod tests {
     #[test]
     fn resume_job_by_index_sends_no_sigcont_to_dead_process() {
         let system = VirtualSystem::new();
-        stub_tty(&system.state);
         let mut env = Env::with_system(Box::new(system.clone()));
         env.options.set(Monitor, On);
         let pid = Pid(123);
@@ -402,7 +428,6 @@ mod tests {
     #[test]
     fn resume_job_by_index_rejects_unowned_job() {
         let system = VirtualSystem::new();
-        stub_tty(&system.state);
         let mut env = Env::with_system(Box::new(system));
         env.options.set(Monitor, On);
         let mut job = Job::new(Pid(123));
@@ -417,7 +442,6 @@ mod tests {
     #[test]
     fn resume_job_by_index_rejects_unmonitored_job() {
         let system = VirtualSystem::new();
-        stub_tty(&system.state);
         let mut env = Env::with_system(Box::new(system));
         env.options.set(Monitor, On);
         let index = env.jobs.add(Job::new(Pid(123)));
@@ -484,7 +508,6 @@ mod tests {
     #[test]
     fn main_with_operand_resumes_specified_job() {
         in_virtual_system(|mut env, state| async move {
-            stub_tty(&state);
             env.options.set(Monitor, On);
             // previous job
             let subshell =
@@ -545,8 +568,7 @@ mod tests {
 
     #[test]
     fn main_returns_exit_status_if_job_suspends_if_not_interactive() {
-        in_virtual_system(|mut env, state| async move {
-            stub_tty(&state);
+        in_virtual_system(|mut env, _| async move {
             env.options.set(Monitor, On);
             env.exit_status = ExitStatus(42);
             let subshell = Subshell::new(|env, _| {
@@ -572,8 +594,7 @@ mod tests {
 
     #[test]
     fn main_returns_interrupt_if_job_suspends_if_interactive() {
-        in_virtual_system(|mut env, state| async move {
-            stub_tty(&state);
+        in_virtual_system(|mut env, _| async move {
             env.options.set(Interactive, On);
             env.options.set(Monitor, On);
             env.exit_status = ExitStatus(42);

yash-cli/CHANGELOG.md

@@ -29,6 +29,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   the next command line. This behavior basically conforms to POSIX.1-2024, but
   differs in that the shell does not resume with the remaining commands
   following the next asynchronous and-or list.
+- If job control is enabled and the shell does not have a controlling terminal,
+  the shell now proceeds without managing foreground-ness of process groups.
+  Jobs are still assigned to their own process groups. Previously, the shell
+  would abort command execution in this case.
 - The `cd` built-in now errors out when a given operand is an empty string.
 - The `cd` built-in now returns different exit statuses for different errors.
 - The `fg` and `bg` built-ins now error out if job control is not enabled.

yash-env/CHANGELOG.md

@@ -45,6 +45,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   device file.
 - `System::getpwnam_dir` now takes a `&CStr` parameter instead of a `&str`.
 - The `builtin::Builtin` struct is now `non_exhaustive`.
+- The `subshell::Subshell::start` method no longer fails if `Env::get_tty` fails.
 - The `origin` field of the `trap::TrapState` struct is now `trap::Origin`.
 - The `TrapSet::get_state` method now returns a `TrapState` reference even if
   the current action was not set by the user.

yash-env/src/subshell.rs

@@ -152,7 +152,7 @@ where
         let tty = match job_control {
             None | Some(JobControl::Background) => None,
             // Open the tty in the parent process so we can reuse the FD for other jobs
-            Some(JobControl::Foreground) => Some(env.get_tty()?),
+            Some(JobControl::Foreground) => env.get_tty().ok(),
         };
         // Block SIGINT and SIGQUIT before forking the child process to prevent
         // the child from being killed by those signals until the child starts
@@ -518,6 +518,34 @@ mod tests {
         });
     }
 
+    #[test]
+    fn job_control_without_tty() {
+        // When /dev/tty is not available, the shell cannot bring the subshell to
+        // the foreground. The subshell should still be in a new process group.
+        // This is the behavior required by POSIX.
+        in_virtual_system(async |mut parent_env, state| {
+            parent_env.options.set(Monitor, On);
+
+            let state_2 = Rc::clone(&state);
+            let (child_pid, job_control) = Subshell::new(move |child_env, job_control| {
+                Box::pin(async move {
+                    let child_pid = child_env.system.getpid();
+                    assert_eq!(state_2.borrow().processes[&child_pid].pgid, child_pid);
+                    assert_eq!(job_control, Some(JobControl::Foreground));
+                })
+            })
+            .job_control(JobControl::Foreground)
+            .start(&mut parent_env)
+            .await
+            .unwrap();
+            assert_eq!(job_control, Some(JobControl::Foreground));
+            assert_eq!(state.borrow().processes[&child_pid].pgid, child_pid);
+
+            parent_env.wait_for_subshell(child_pid).await.unwrap();
+            assert_eq!(state.borrow().processes[&child_pid].pgid, child_pid);
+        })
+    }
+
     #[test]
     fn no_job_control_with_option_disabled() {
         in_virtual_system(|mut parent_env, state| async move {