diff options
Diffstat (limited to '')
| -rw-r--r-- | debian/patches/bash52-014.diff | 106 |
1 files changed, 106 insertions, 0 deletions
diff --git a/debian/patches/bash52-014.diff b/debian/patches/bash52-014.diff new file mode 100644 index 0000000..5d402e7 --- /dev/null +++ b/debian/patches/bash52-014.diff @@ -0,0 +1,106 @@ + BASH PATCH REPORT + ================= + +Bash-Release: 5.2 +Patch-ID: bash52-014 + +Bug-Reported-by: Andreas Schwab <schwab@suse.de> +Bug-Reference-ID: <mvmv8opcbha.fsf@suse.de> +Bug-Reference-URL: https://lists.gnu.org/archive/html/bug-bash/2022-10/msg00076.html + +Bug-Description: + +Bash defers processing additional terminating signals when running the +EXIT trap while exiting due to a terminating signal. This patch allows the +new terminating signal to kill the shell immediately. + +--- a/execute_cmd.c ++++ b/execute_cmd.c +@@ -3624,6 +3624,7 @@ execute_case_command (case_command) + free (pattern); + + dispose_words (es); ++ QUIT; + + if (match) + { +--- a/patchlevel.h ++++ b/patchlevel.h +@@ -25,6 +25,6 @@ + regexp `^#define[ ]*PATCHLEVEL', since that's what support/mkversion.sh + looks for to find the patch level (for the sccs version string). */ + +-#define PATCHLEVEL 13 ++#define PATCHLEVEL 14 + + #endif /* _PATCHLEVEL_H_ */ +--- a/sig.c ++++ b/sig.c +@@ -94,6 +94,7 @@ static SigHandler *old_winch = (SigHandl + #endif + + static void initialize_shell_signals PARAMS((void)); ++static void kill_shell PARAMS((int)); + + void + initialize_signals (reinit) +@@ -486,6 +487,8 @@ restore_sigmask () + #endif + } + ++static int handling_termsig = 0; ++ + sighandler + termsig_sighandler (sig) + int sig; +@@ -532,6 +535,14 @@ termsig_sighandler (sig) + sig == terminating_signal) + terminate_immediately = 1; + ++ /* If we are currently handling a terminating signal, we have a couple of ++ choices here. We can ignore this second terminating signal and let the ++ shell exit from the first one, or we can exit immediately by killing ++ the shell with this signal. This code implements the latter; to implement ++ the former, replace the kill_shell(sig) with return. */ ++ if (handling_termsig) ++ kill_shell (sig); /* just short-circuit now */ ++ + terminating_signal = sig; + + if (terminate_immediately) +@@ -564,16 +575,13 @@ void + termsig_handler (sig) + int sig; + { +- static int handling_termsig = 0; +- int i, core; +- sigset_t mask; +- + /* Simple semaphore to keep this function from being executed multiple + times. Since we no longer are running as a signal handler, we don't + block multiple occurrences of the terminating signals while running. */ + if (handling_termsig) + return; +- handling_termsig = 1; ++ ++ handling_termsig = terminating_signal; /* for termsig_sighandler */ + terminating_signal = 0; /* keep macro from re-testing true. */ + + /* I don't believe this condition ever tests true. */ +@@ -613,6 +621,16 @@ termsig_handler (sig) + + run_exit_trap (); /* XXX - run exit trap possibly in signal context? */ + ++ kill_shell (sig); ++} ++ ++static void ++kill_shell (sig) ++ int sig; ++{ ++ int i, core; ++ sigset_t mask; ++ + /* We don't change the set of blocked signals. If a user starts the shell + with a terminating signal blocked, we won't get here (and if by some + magic chance we do, we'll exit below). What we do is to restore the |