How do I automatically close the process left behind by a misbehaving application after it exits?

Question

There are applications that do not exit cleanly leaving behind their process. One example I've found is Foxit Reader. Of course, the ideal would be to report a bug and have the application fixed, but sometimes that is not possible. For example, with Foxit Reader, the developers indicated they are not working on any fixes to the current version any more as they are doing a complete rewrite.

I would like to have it such that when I exit the application, the process that it leaves behind is automatically closed (without creating more processes that are left behind of course). How do I do that?

Answer 1

I believe the simplest way is to start the program via a script and establish a trap to kill the whole process group:

#!/bin/bash
trap "kill -9 -- -$$" ERR EXIT
/path/to/gui-programm

---

How does it work?

A trap is a shell builtin that execute a certain command if the script receives one (or more) signals. In this case EXIT stands for a graceful exit (i.e. closing the GUI programm) and ERR for any error (e.g. CTRL+C, or if foxit got killed by another reason). Ref: man signal and man bash

The command in use is kill, where -9 sends a SIGKILL. kill may terminate a single process via kill <pid> will act on a whole process group (i.e. process and all its children and forks) by adding a minus to the PID. -- is needed so that the following argument is not interpreted as a flag. I.e. kill -9 -- -$pid will kill a while process group.

$$ is simply the PID of the current shell script. The GUI-program is a child of the script and also child processes of the GUI-program itself are part of the process group linked to the script as the origin.

If you want to test it, I suggest using many sleeps:

 #!/bin/bash
 #test script for kill via trap
 trap "kill -9 -- -$$" ERR EXIT
 for (( i=1 ; i<=100 ; i++ )) ; do
   sleep 120
 done
 /path/to/gui-command

Now if you exit the GUI command, all sleeps will disappear. If you comment the trap part out, they will remain.

---

In order to ensure that the trap is also executed on failures of child processes, it needs to be inherited via set -E.

#!/bin/bash
set -E
trap "kill -9 -- -$$" ERR EXIT
/path/to/gui-programm

Answer 2

One way to do this is to launch the application from a script instead of directly. The application is run with its output piped to a temporary file. Then tail is run against that file piping to a fifo. Next grep runs against the fifo. When certain text is found, the tail process is killed, the fifo closed, the application process is force killed and the temporary file deleted.

The text should be chosen such that it is the last text output by the application on exit (which you can see if you launch the application from the command line). For example, the last text FoxitReader outputs when I close it is "CJS_Module::ExitEnumJSPlugThread".

The following example script shows how this works with FoxitReader and can be easily adapted for other applications:

#!/bin/bash
file=/tmp/foxit.txt
YOURPATH/foxitsoftware/foxitreader/FoxitReader "$@" &> $file &
foxitpid=$!
fifo=/tmp/tmpfifo.$$
mkfifo $fifo || exit 1
tail -f $file >$fifo &
tailpid=$!
grep -m 1 "CJS_Module::ExitEnumJSPlugThread" $fifo
kill $tailpid
rm $fifo
kill -9 $foxitpid
rm -f $file
exit 0

Answer 3

According to the answer from @mcarans, you can fine-turn the launching script at the Foxit Reader installation directory:

<INSTALLPATH>/foxitreader/FoxitReader.sh

Modify this script to (remember to check the <INSTALLPATH>):

#!/bin/bash
selfpath="<INSTALLPATH>/foxitreader"
file=/tmp/foxit.txt
"$selfpath/FoxitReader" "$@" &> $file &
foxitpid=$!
fifo=/tmp/tmpfifo.$$
mkfifo $fifo || exit 1
tail -f $file >$fifo &
tailpid=$!
grep -m 1 "~CJS_Module()" -m 1 "CJS_Module::ExitEnumJSPlugThread()" $fifo
kill $tailpid
rm $fifo
kill -9 $foxitpid
rm -f $file
exit 0

Save it, and you are all set. You can double-click the PDF file and close it as usual, and there will be no leftover processes.