Prevent SIGINT from interrupting current task while still passing information about SIGINT (and preserve the exit code)

Question

I have a quite long shell script and I'm trying to add signal handling to it.

The main task of the script is to run various programs and then clean up their temporary files.

I want to trap SIGINT. When the signal is caught, the script should wait for the current program to finish execution, then do the cleanup and exit.

Here is an MCVE:

#!/bin/sh

stop_this=0
trap 'stop_this=1' 2

while true ; do
    result="$(sleep 2 ; echo success)" # run some program
    echo "result: '$result'"
    echo "Cleaning up..." # clean up temporary files
    if [ $stop_this -ne 0 ] ; then
        echo 'OK, time to stop this.'
        break
    fi
done

exit 0

The expected result:

Cleaning up...
result: 'success'
Cleaning up...
^Cresult: 'success'
Cleaning up...
OK, time to stop this.

The actual result:

Cleaning up...
result: 'success'
Cleaning up...
^Cresult: ''
Cleaning up...
OK, time to stop this.

The problem is that the currently running instruction (result="$(sleep 2 ; echo success)" in this case) is interrupted. What can I do so it would behave more like I was set trap '' 2?

I'm looking for either a POSIX solution or one that is supported by most of shell interpreters (BusyBox, dash, Cygwin...)

I already saw answers for Prevent SIGINT from closing child process in bash script but this isn't really working for me. All of these solutions require to modify each line which shouldn't be interrupted. My real script is quite long and much more complicated than the example. I would have to modify hundreds of lines.

Answer 1

For disallowing interrupting the program:

trap "" ERR HUP INT QUIT TERM TSTP TTIN TTOU

But if a sub-command handles traps by itself, and that command must really complete, you need to prevent passing signals to it.

For people on Linux that don't mind installing extra commands, you can just use:

waitFor [command]

Alternatively you can adapt the latest source code of waitFor into your program as needed, or use the code from Gilles' answer. Although that has the disadvantage of not benefiting from updates upstream.

Just mind that other terminals and the service manager can still terminate "command". If you want the service manager to be unable to close "command", it shall be run as a service with the appropriate kill mode and kill signal set.

Answer 2

You may want to adapt the following:

#!/bin/sh

tmpfile=".tmpfile"
rm -f $tmpfile

trap : INT

# put the action that should not be interrupted in the innermost brackets
#         |                                 |
( set -m; (sleep 10; echo success > $tmpfile) & wait ) &
wait # wait will be interrupted by Ctrl+c

while [ ! -r $tmpfile ]; do
    echo "waiting for $tmpfile"
    sleep 1
done
result=`cat $tmpfile`
echo "result: '$result'"

This seems also to work with programs that install their own SIGINT handler like mpirun and mpiexec and so on.

Answer 3

Both answers from @PSkocik and @WilliamPursell have helped me to get on the right track.

I have a fully working solution. It ain't pretty because it needs to use an external file to indicate that the signal didn't occurred but beside that it should work reliably.

#!/bin/sh

touch ./continue
trap 'rm -f ./continue' 2

( # the whole main body of the script is in a separate background process
trap '' 2 # ignore SIGINT
while true ; do
    result="$(sleep 2 ; echo success)" # run some program
    echo "result: '$result'"
    echo "Cleaning up..." # clean up temporary files
    if [ ! -e ./continue ] ; then # exit the loop if file "./continue" is deleted
        echo 'OK, time to stop this.'
        break
    fi
done
) & # end of the main body of the script
while ! wait ; do : ; done # wait for the background process to end (ignore signals)
wait $! # wait again to get the exit code
result=$? # exit code of the background process

rm -f ./continue # clean up if the background process ended without a signal

exit $result

---

EDIT: There are some problems with this code in Cygwin.

The main functionality regarding signals work. However, it seems like the finished background process doesn't stay in the system as a zombie. This makes the wait $! to not work. The exit code of the script has incorrect value of 127.

Solution to that would be removing lines wait $!, result=$? and result=$? so the script always returns 0. It should be also possible to keep the proper error code by using another layer of subshell and temporarily store the exit code in a file.

Answer 4

Sighandling in shell scripts can get clumsy. It's pretty much impossible to do it "right" without the support of C.

The problem with:

result="$(sleep 2 ; echo success)" # run some program

is that $() creates a subshell and in subshells, non-ignored (trap '' SIGNAL is how you ignore SIGNAL) signals are reset to their default dispositions which for SIGINT is to terminate the process ($( ) gets its own process, thought it will receive the signal too because the terminal-generated SIGINT is process-group targeted)

To prevent this, you could do something like:

result="$(
trap '' INT #ignore; could get killed right before the trap command
sleep 2; echo success)"

or

result="$( trap : INT; #no-op handler; same problem
sleep 2; while ! echo success; do :; done)" 

but as noted, there will be a small race-condition window between the start of the subshell and the registration of the signal handler during which the subshell could get killed by the reset-to-default SIGINT signal.

Answer 5

You need to prevent the SIGINT from going to the echo in the first place (or rewrite the cmd that you are running in the variable assignment to ignore SIGINT). Also, you need to allow the variable assignment to happen, and it appears that the shell is aborting the assignment when it receives the SIGINT. If you're only worried about user generated SIGINT from the tty, you need to disassociate that command from the tty (eg, get it out of the foreground process group) and prevent the SIGINT from aborting the assignment. You can (almost) accomplish both of those with:

#!/bin/sh

stop_this=0

while true ; do
    trap 'stop_this=1' INT
    { sleep 1; echo success > tmpfile; } & # run some program
    while ! wait; do : ; done
    trap : INT
    result=$(cat tmpfile& wait)
    echo "result: '$result'"
    echo "Cleaning up..." # clean up temporary files
    if [ $stop_this -ne 0 ] ; then
        echo 'OK, time to stop this.'
        break
    fi
done

exit 0

If you're worried about SIGINT from another source, you'll have to re-implement sleep (or whatever command I presume sleep is a proxy for) to handle SIGINT the way you want. The key here is to run the command in the background and wait for it to prevent the SIGINT from going to it and terminating it early. Note that we've opened at least 2 new cans of worms here. By waiting in a loop, we're effectively ignoring the any errors that the subcommand might raise (we're doing this to try and implement a SIGRESTART), so may potentially hang. Also, if the SIGINT arrives during the cat, we have attempted to prevent the cat from aborting by running it in the background, but now the variable assignment will be terminated and you'll get your original behavior. Signal handling is not clean in the shell! But this gets you closer to your desired goal.