** Description changed:

  [ Impact ]
  
   * On 26.04, with use_pty (the default) and sudo's stdout piped, a
  command that the terminal stops a second time by SIGTTOU or SIGTTIN is
  never resumed. Instead sudo stops itself and its whole job: an
  interactive shell prints "Stopped" and gives its prompt back, and a
  script or a program that runs sudo with a pipe, as in the report, waits
  forever.
  
   * Cause: in suspend_pty() (src/exec/use_pty/parent.rs), sudo returns
- SIGCONT_FG only while the user's terminal is not yet in raw mode. The
- first stop puts the terminal in raw mode and resumes the command. On the
- second stop the terminal is already raw, so sudo skips the resume, takes
- the suspend path and sends the stop signal to its own process group.
- Nothing resumes it.
+ SIGCONT_FG only while the user's terminal is not yet in raw mode. With
+ stdout piped, the first stop puts the terminal in raw mode and resumes
+ the command. On the second stop the terminal is already raw, so sudo
+ skips the resume, takes the suspend path and sends the stop signal to
+ its own process group. Nothing resumes it. With no pipe the terminal is
+ raw from the start, so already the first such stop takes the suspend
+ path (test 3).
  
   * Fix: upstream PR 1601 (commit 59e764c7, in 0.2.14 and later) moves
  the resume out of the "if !term_raw" block, so sudo returns SIGCONT_FG
  whenever it is in the foreground of the user's terminal, as sudo.ws
  does.
  
  [ Test Plan ]
  
- Run this on a clean Ubuntu 26.04 install, where /usr/bin/sudo is sudo-rs
- (the default). Use a real terminal (the local console, a desktop
- terminal or "ssh -t") and a user that may run sudo. Open two terminals,
- A and B, as that user.
+ Run this on a test machine or VM with a clean Ubuntu 26.04 install,
+ where /usr/bin/sudo is sudo-rs (the default). Use a real terminal (the
+ local console, a desktop terminal or "ssh -t") and a user that may run
+ sudo. Open two terminals, A and B, as that user.
  
  Steps:
  
-  a. Do the setup below in terminal A.
-  b. Run tests 1 to 3 with 0.2.13-0ubuntu1.2 to see the bug.
+  a. Do the setup below in terminals A and B.
+  b. Run tests 1 to 4 with 0.2.13-0ubuntu1.2 to see the bug.
   c. Install the update from -proposed (below).
-  d. Run tests 1 to 3 again in the same terminals.
+  d. Run tests 1 to 4 again in the same terminals.
  
  Setup, in terminal A. First run this line on its own. It may ask for
  your password:
  
      sudo -v
  
- sudo-rs keeps the password for 15 minutes. If the tests take longer, run
- "sudo -v" again before the next test, so that no password prompt lands
- inside a test. Then paste this block as it is, with no spaces in front
- of the lines:
+ sudo-rs keeps the password for 15 minutes, per terminal. If the tests
+ take longer, run "sudo -v" again before the next test, so that no
+ password prompt lands inside a test. Then paste this block as it is,
+ with no spaces in front of the lines:
  
  cat > ~/inner.sh <<'EOF'
  for _ in 1 2 3 4; do
      kill -TTOU $$
  done
  echo did-not-deadlock
  EOF
  sudo --version
  
  inner.sh is the script of upstream's regression test for this bug
- (upstream PR 1647): the command stops itself with SIGTTOU four times.
- "sudo --version" prints sudo-rs 0.2.13-0ubuntu1.2 before the update.
- 
- To look for a stopped process, run this in terminal B:
+ (upstream PR 1647, sigttou_in_foreground_does_not_deadlock): the command
+ stops itself with SIGTTOU four times. "sudo --version" prints sudo-rs
+ 0.2.13-0ubuntu1.2 before the update.
+ 
+ Setup, in terminal B. Run "sudo -v" there too. To look for a stopped
+ process, run this in terminal B:
  
      ps -eo pid,ppid,stat,wchan:32,args | awk '$3 ~ /^T/'
  
  Bug tests, in terminal A:
  
-  1. The command is stopped twice, stdout piped:
+  1. The command is stopped again and again, stdout piped:
  
          sudo sh ~/inner.sh | cat
  
      Expected: did-not-deadlock, then the prompt.
  
-     With 0.2.13-0ubuntu1.2 the shell prints "[1]+  Stopped  sudo sh
- ~/inner.sh | cat" and the prompt instead. Terminal B lists sudo and cat
- in state T, and "sh .../inner.sh" in state T+. Run fg. It stops again.
- After the third fg, did-not-deadlock appears.
+     With 0.2.13-0ubuntu1.2 the shell prints a line like "[1]+ Stopped
+ sudo sh ~/inner.sh | cat" and the prompt instead. Terminal B lists sudo
+ and cat in state T, and "sh .../inner.sh" in state T+. Run fg. It stops
+ again. After the third fg, did-not-deadlock appears.
  
   2. The same, as upstream's test runs it, with job control in a non-
  interactive bash:
  
          bash -c "set -m; sudo sh ~/inner.sh | cat"; echo exit=$?
  
      Expected: did-not-deadlock, then exit=0.
  
      With 0.2.13-0ubuntu1.2 only exit=150 appears (128 plus 22, SIGTTOU):
  bash saw the pipeline stopped and quit, and sudo and its command were
- then killed.
+ gone afterwards.
  
  With 0.2.13-0ubuntu1.3 tests 1 and 2 pass and terminal B lists nothing.
  
+ Changed behaviour, in terminal A:
+ 
+  3. With no pipe, the command stops itself once:
+ 
+         bash -c "set -m; sudo sh -c 'kill -TTOU \$\$; echo resumed'";
+ echo exit=$?
+ 
+     Expected: resumed, then exit=0.
+ 
+     With 0.2.13-0ubuntu1.2 only exit=150 appears, already at the first
+ stop.
+ 
  Regression test, in terminal A:
  
-  3. Ctrl-Z and fg still suspend and resume sudo:
+  4. Ctrl-Z and fg still suspend and resume sudo:
  
          sudo sh -c 'read v && echo got-$v'
  
      Press Ctrl-Z. The shell prints "Stopped". Run fg, type hello and
  press Enter. Expected on both versions: got-hello.
  
  Install the update: enable -proposed as
  https://ubuntu.com/project/docs/SRU/reference/sru-verification/
  describes, then run:
  
      sudo apt install -t resolute-proposed sudo-rs
      apt policy sudo-rs
      sudo --version
  
- "sudo --version" must print sudo-rs 0.2.13-0ubuntu1.3.
+ "sudo --version" must print sudo-rs 0.2.13-0ubuntu1.3. Run "sudo -v"
+ again in both terminals before step d.
  
  [ Where problems could occur ]
  
   * The change is in the parent's handling of a command that the terminal
  stops with SIGTTOU or SIGTTIN, while sudo is in the foreground of the
  user's terminal. sudo now always resumes the command in the foreground
- there. Before, it did so only the first time, and after that it restored
- the user's terminal and stopped itself. If the change is wrong, it would
- show as a command under sudo that loops between stopped and running, or
- a terminal left in raw mode after sudo ends.
- 
-  * A command that keeps sending itself SIGTTOU or SIGTTIN is now resumed
- every time, as with sudo.ws, instead of stopping sudo after the first
- time.
- 
-  * Not changed: Ctrl-Z and other SIGTSTP stops (test 3), the case where
+ there. Before, it did so only while the user's terminal was not yet raw:
+ with stdout or stdin piped only at the first stop, and with no pipe
+ never. Otherwise it restored the user's terminal and stopped its own
+ job, or, when the leader of that job's process group had already exited
+ (for example "echo | sudo ..."), ended the command with SIGHUP, SIGTERM
+ and then SIGKILL. If the change is wrong, it would show as a command
+ under sudo that loops between stopped and running, or a terminal left in
+ raw mode after sudo ends.
+ 
+  * With no pipe, the first SIGTTOU or SIGTTIN stop used to stop sudo's
+ job (the shell printed Stopped and fg resumed it). Now sudo resumes the
+ command at once (test 3). A command that keeps sending itself SIGTTOU or
+ SIGTTIN is now resumed every time, as with sudo.ws.
+ 
+  * Not changed: Ctrl-Z and other SIGTSTP stops (test 4), the case where
  sudo itself is in the background of the user's terminal (it still
  suspends, as before), and the no_pty path (Defaults !use_pty, or no
  terminal).
  
   * The same change has shipped in upstream 0.2.14 and 0.2.15, and in
- 26.10 and 27.04. suspend_pty() in 0.2.14 and 0.2.15 is identical to the
- fix commit.
+ Ubuntu since 0.2.14-1ubuntu2 in 26.10. suspend_pty() in 0.2.14 and
+ 0.2.15 is identical to the fix commit.
  
  [ Other Info ]
  
   * Upstream: issue 1598, PR 1601, commit 
59e764c737aac6ea6ff7af36dbf36397c3916b46, merged 2026-05-26, first released in 
0.2.14. Regression test: upstream PR 1647 
(sigttou_in_foreground_does_not_deadlock), in test-framework/, which is not in 
the crates.io tarball.
     https://github.com/trifectatechfoundation/sudo-rs/pull/1601
  
-  * The patch is the upstream diff unchanged, with a DEP-3 header. It
- applies to 0.2.13-0ubuntu1.2 with no fuzz or offset, on top of the PR
- 1530 patch or without it. It touches src/exec/use_pty/parent.rs only.
- After it, parent.rs is identical to the one in upstream 0.2.14.
+  * The patch is the upstream diff unchanged from its "diff --git" line,
+ under a DEP-3 header with Applied-Upstream. It applies to
+ 0.2.13-0ubuntu1.2 with quilt at fuzz 0 and no offset, after the PR 1530
+ patch. It touches src/exec/use_pty/parent.rs only. After it, parent.rs
+ is identical to the one in upstream v0.2.14 and v0.2.15.
  
   * The same upload fixes LP: #2150073 and LP: #2160212 (upstream PR
- 1530). The debdiff and the full test record are on LP: #2150073.
- 
-  * Fixed in the development release: this bug was closed by
- 0.2.14-1ubuntu2 in 26.10 (stonking), and tenacious, the current
- development series, has 0.2.14-1ubuntu4.1. noble has rust-sudo-rs
- 0.2.2-1 in universe, which is not the default sudo there. It has the
- same nested return but was not tested, and no noble task is proposed.
+ 1530, in src/exec/use_pty/monitor.rs). The debdiff and the full test
+ record are on LP: #2150073. Upstream's ubuntu-raccoon-backport branch
+ for 26.04 is at 0.2.13-0ubuntu1.2 and does not have PR 1601.
+ 
+  * Fixed in later releases: this bug was closed by 0.2.14-1ubuntu2 in
+ 26.10 (stonking), which now has 0.2.14-1ubuntu4.1 in stonking-updates,
+ and tenacious, the current development series, has 0.2.14-1ubuntu4.1. So
+ no 26.10 task is needed. noble has rust-sudo-rs 0.2.2-1 in universe,
+ which is not the default sudo there. It has the same nested return, but
+ it was not tested and no noble task is proposed.
  
   * The report's Python reproducer (apt-get -y full-upgrade with a
- failing postinst) was also run. On 26.04 /bin/sh does not exec apt-get,
- so apt-get is a child of the command, and it stops after the dpkg error
- for the reason of LP: #2150073. It hangs on 0.2.13-0ubuntu1.2 and passes
- on 0.2.13-0ubuntu1.3, and also on a build with only the PR 1530 patch.
- The second stop that this bug is about is what tests 1 and 2 show.
+ failing postinst) was also run, as written, with a local package whose
+ new version fails in postinst. On 26.04 /bin/sh does not exec apt-get,
+ so apt-get is a child of the command, and it stops right after "E: Sub-
+ process /usr/bin/dpkg returned an error code (1)" for the reason of LP:
+ #2150073. It hangs on 0.2.13-0ubuntu1.2 and passes on 0.2.13-0ubuntu1.3,
+ and also on a build with only the PR 1530 patch. The second stop that
+ this bug is about is what tests 1 and 2 show.
  
   * Testing done: tests 1 and 2 ran in fresh ubuntu:26.04 containers on a
- real pty, as root and as a NOPASSWD user, on three .deb builds: the
- archive 0.2.13-0ubuntu1.2, a local build with only the PR 1530 patch,
- and 0.2.13-0ubuntu1.3 with both patches. Tests 1 and 2 stop on the first
- two and pass on 0.2.13-0ubuntu1.3. In test 1 sudo and cat were in state
- T and the command in T+, and three fg runs were needed. Test 2 printed
+ pty, as root and as a NOPASSWD user, on three .deb builds: the archive
+ 0.2.13-0ubuntu1.2, a build with only the PR 1530 patch, and
+ 0.2.13-0ubuntu1.3 with both patches. Tests 1 and 2 stop on the first two
+ and pass on 0.2.13-0ubuntu1.3. In test 1 sudo and cat were in state T
+ and the command in T+, and three fg runs were needed. Test 2 printed
  exit=150. Upstream's test as its framework runs it (bash -c as the top
  process of a tty) gave the same: exit status 150 on the first two
- builds, did-not-deadlock and 0 on 0.2.13-0ubuntu1.3. Test 3 passes on
- all three. The containers ran on a 6.18 kernel, not a 26.04 VM with its
- 7.0 kernel.
+ builds, did-not-deadlock and 0 on 0.2.13-0ubuntu1.3. Test 3 printed only
+ exit=150 on the first two builds (exit=149 with kill -TTIN in place of
+ kill -TTOU), and resumed with exit=0 on 0.2.13-0ubuntu1.3, for both
+ signals. Typed as "sudo sh -c 'kill -TTOU $$; echo resumed'" in an
+ interactive bash, 0.2.13-0ubuntu1.2 printed Stopped and one fg let it
+ finish, and 0.2.13-0ubuntu1.3 printed resumed at once. Test 4 passes on
+ all three. All of it ran once more on .deb packages built from the
+ attached debdiff: test 1 and test 3 on the final build, and the rest on
+ a build whose debdiff differed only in changelog and DEP-3 text and
+ whose sudo, su and visudo binaries are byte identical. The results were
+ the same. Every run used .deb packages. The containers ran on a 6.18
+ kernel, not on a 26.04 install with its 7.0 kernel.
+ 
+  * The autopkgtest (debian/tests/run-cargo-tests.sh) runs cargo test, so
+ unit tests only, and upstream's PR 1647 test is not in the tarball the
+ package builds from. No autopkgtest is added.
  
  [ Original Description ]
  
  ## Summary
  
  When a command running under `sudo` with `use_pty` receives SIGTTOU
  twice in succession, the parent process fails to send SIGCONT_FG on the
  second occurrence. This causes the command to remain permanently stopped
  (T state), deadlocking the entire process tree.
  
  The bug is a misplaced `return` in `suspend_pty()` in
  `src/exec/use_pty/parent.rs`. The `return Some(SIGCONT_FG)` is nested
  inside `if !self.term_raw`, so when `term_raw` is already `true` (set
  during the first SIGTTOU handling), the early return is skipped and the
  code falls through to the suspend path, which sends SIGTTOU to the
  parent process group via `killpg()`.
  
  Original sudo (sudo.ws) does not have this issue — its equivalent `ret =
  SIGCONT_FG; break;` is at the `if (ec->foreground)` level, always
  executing when the parent is the foreground process.
  
  ## Environment
  
  - sudo-rs 0.2.13-0ubuntu1
  - `Defaults use_pty` in `/etc/sudoers`
  - Linux (tested on 6.x kernel, riscv64)
  
  ## Steps to Reproduce
  
  Prerequisites:
  - `Defaults use_pty` enabled in `/etc/sudoers`
  - A command that triggers SIGTTOU twice (e.g., a dpkg post-install script 
failure during `apt-get full-upgrade`)
  
  Minimal reproduction using Python:
  
  ```python
  import subprocess, threading
  
  proc = subprocess.Popen(
-     ["sudo", "/bin/sh", "-c", "LC_ALL=C apt-get -y full-upgrade"],
-     stdin=None,              # inherit terminal
-     stdout=subprocess.PIPE,  # pipe stdout
-     stderr=subprocess.STDOUT,
-     text=True,
+     ["sudo", "/bin/sh", "-c", "LC_ALL=C apt-get -y full-upgrade"],
+     stdin=None,              # inherit terminal
+     stdout=subprocess.PIPE,  # pipe stdout
+     stderr=subprocess.STDOUT,
+     text=True,
  )
  
  def drain():
-     for line in proc.stdout:
-         print(line, end="")
+     for line in proc.stdout:
+         print(line, end="")
  
  threading.Thread(target=drain, daemon=True).start()
  proc.wait(timeout=120)  # hangs here
  ```
  
  When a dpkg trigger/script fails, `sh` receives SIGTTOU from the kernel
  and stops. The monitor sends SIGCONT (via SIGCONT_FG from parent). `sh`
  resumes but receives SIGTTOU again. This time, no SIGCONT is sent — the
  command stays stopped permanently.
  
  Workaround: use `stdin=subprocess.DEVNULL` to prevent sudo from
  detecting a terminal on stdin.
  
  Switching to original sudo (sudo.ws) via `update-alternatives`
  eliminates the issue entirely.
  
  ## Root Cause
  
  In `src/exec/use_pty/parent.rs`, the `suspend_pty()` function handles
  SIGTTOU/SIGTTIN at lines 576-603:
  
  ```rust
  if let SIGTTOU | SIGTTIN = signal {
-     if !self.foreground && self.check_foreground().is_err() {
-         return None;
-     }
- 
-     if self.foreground {
-         dev_info!(...);
-         if !self.term_raw {
-             if self.tty_pipe
-                 .left_mut()
-                 .set_raw_mode(false, self.preserve_oflag)
-                 .is_ok()
-             {
-                 self.term_raw = true;
-             }
-             // Resume command in the foreground
-             self.tty_pipe.enable_input(registry);
-             return Some(SIGCONT_FG);  // BUG: only reached when term_raw was 
false
-         }
-         // When term_raw is already true, falls through!
-     }
+     if !self.foreground && self.check_foreground().is_err() {
+         return None;
+     }
+ 
+     if self.foreground {
+         dev_info!(...);
+         if !self.term_raw {
+             if self.tty_pipe
+                 .left_mut()
+                 .set_raw_mode(false, self.preserve_oflag)
+                 .is_ok()
+             {
+                 self.term_raw = true;
+             }
+             // Resume command in the foreground
+             self.tty_pipe.enable_input(registry);
+             return Some(SIGCONT_FG);  // BUG: only reached when term_raw was 
false
+         }
+         // When term_raw is already true, falls through!
+     }
  }
  
  // Falls through to suspend path:
  // ...
  // killpg(self.parent_pgrp, signal)  ← deadlocks the process tree
  ```
  
  The equivalent code in original sudo (`src/exec_pty.c:236-246`) does not
  have this problem:
  
  ```c
  if (ec->foreground) {
-     if (!ec->term_raw) {
-         if (sudo_term_raw(io_fds[SFD_USERTTY], term_raw_flags))
-             ec->term_raw = true;
-     }
-     ret = SIGCONT_FG;   /* always reached when foreground is true */
-     break;
+     if (!ec->term_raw) {
+         if (sudo_term_raw(io_fds[SFD_USERTTY], term_raw_flags))
+             ec->term_raw = true;
+     }
+     ret = SIGCONT_FG;   /* always reached when foreground is true */
+     break;
  }
  ```
  
  The `ret = SIGCONT_FG; break;` is at the `if (ec->foreground)` scope, so
  it executes regardless of `term_raw` state.
  
  ## Sequence of Events
  
  ```
  stdout=PIPE → foreground=false, term_raw=false at startup
  
  1st SIGTTOU:
-   command stops (SIGTTOU from kernel)
-   → monitor: on_stop() → sends Stop(SIGTTOU) to parent
-   → parent: suspend_pty(SIGTTOU)
-     → check_foreground() → foreground=true (sudo IS fg process on user tty)
-     → term_raw=false → enters if(!term_raw) block
-     → set_raw_mode() → term_raw=true
-     → returns SIGCONT_FG ✓
-   → monitor: tcsetpgrp(command_pgrp) + kill(SIGCONT)
-   → command resumes
+   command stops (SIGTTOU from kernel)
+   → monitor: on_stop() → sends Stop(SIGTTOU) to parent
+   → parent: suspend_pty(SIGTTOU)
+     → check_foreground() → foreground=true (sudo IS fg process on user tty)
+     → term_raw=false → enters if(!term_raw) block
+     → set_raw_mode() → term_raw=true
+     → returns SIGCONT_FG ✓
+   → monitor: tcsetpgrp(command_pgrp) + kill(SIGCONT)
+   → command resumes
  
  2nd SIGTTOU:
-   command stops again (SIGTTOU from kernel)
-   → monitor: on_stop() → sends Stop(SIGTTOU) to parent
-   → parent: suspend_pty(SIGTTOU)
-     → foreground=true, term_raw=true
-     → if(!term_raw) is FALSE → skips the block with return SIGCONT_FG
-     → falls through to suspend path
-     → killpg(parent_pgrp, SIGTTOU) → stops entire parent process group
-     → DEADLOCK: nobody sends SIGCONT to resume ✗
+   command stops again (SIGTTOU from kernel)
+   → monitor: on_stop() → sends Stop(SIGTTOU) to parent
+   → parent: suspend_pty(SIGTTOU)
+     → foreground=true, term_raw=true
+     → if(!term_raw) is FALSE → skips the block with return SIGCONT_FG
+     → falls through to suspend path
+     → killpg(parent_pgrp, SIGTTOU) → stops entire parent process group
+     → DEADLOCK: nobody sends SIGCONT to resume ✗
  ```
  
  ## Suggested Fix
  
  Move `return Some(SIGCONT_FG)` and `enable_input()` outside the `if
  !self.term_raw` block to match sudo.ws behavior:
  
  ```rust
  if self.foreground {
-     dev_info!(...);
-     if !self.term_raw {
-         if self.tty_pipe
-             .left_mut()
-             .set_raw_mode(false, self.preserve_oflag)
-             .is_ok()
-         {
-             self.term_raw = true;
-         }
-     }
-     // Resume command in the foreground (always, regardless of term_raw)
-     self.tty_pipe.enable_input(registry);
-     return Some(SIGCONT_FG);
+     dev_info!(...);
+     if !self.term_raw {
+         if self.tty_pipe
+             .left_mut()
+             .set_raw_mode(false, self.preserve_oflag)
+             .is_ok()
+         {
+             self.term_raw = true;
+         }
+     }
+     // Resume command in the foreground (always, regardless of term_raw)
+     self.tty_pipe.enable_input(registry);
+     return Some(SIGCONT_FG);
  }
  ```

-- 
You received this bug notification because you are a member of Ubuntu
Bugs, which is subscribed to Ubuntu.
https://bugs.launchpad.net/bugs/2146860

Title:
  command permanently stop

To manage notifications about this bug go to:
https://bugs.launchpad.net/ubuntu/+source/rust-sudo-rs/+bug/2146860/+subscriptions


-- 
ubuntu-bugs mailing list
[email protected]
https://lists.ubuntu.com/mailman/listinfo/ubuntu-bugs

Reply via email to