Externally disabling signals for a Linux program

Question

On Linux, is it possible to somehow disable signaling for programs externally... that is, without modifying their source code?

Context:

Answer 1

This is example code of enabling signals like Ctrl+C for programs which block it.

fixControlC.c

#include <stdio.h>
#include <signal.h>
int sigaddset(sigset_t *set, int signo) {
    printf("int sigaddset(sigset_t *set=%p, int signo=%d)\n", set, signo);
    return 0;
}

Compile it:

gcc -fPIC -shared -o fixControlC.so fixControlC.c

Run it:

LD_LIBRARY_PATH=. LD_PRELOAD=fixControlC.so mysqld

Answer 2

I would suggest that your C (and Java) application needs rewriting so that it can handle an exception, what happens if it really does need to be interrupted, power fails, etc...

I that fails, J-16 is right on the money. Does the user need to interract with the process, or just see the output (do they even need to see the output?)

Answer 3

The "trap" command is local to this process, never applies to children.

To really trap the signal, you have to hack it using a LD_PRELOAD hook. This is non-trival task (you have to compile a loadable with _init(), sigaction() inside), so I won't include the full code here. You can find an example for SIGSEGV on Phack Volume 0x0b, Issue 0x3a, Phile #0x03.

Alternativlly, try the nohup and tail trick.

nohup  your_command &
tail -F nohup.out

Answer 4

The process signal mask is inherited across exec, so you can simply write a small wrapper program that blocks SIGINT and executes the target:

#include <signal.h>
#include <unistd.h>
#include <stdio.h>

int main(int argc, char *argv[])
{
        sigset_t sigs;

        sigemptyset(&sigs);
        sigaddset(&sigs, SIGINT);
        sigprocmask(SIG_BLOCK, &sigs, 0);

        if (argc > 1) {
                execvp(argv[1], argv + 1);
                perror("execv");
        } else {
                fprintf(stderr, "Usage: %s <command> [args...]\n", argv[0]);
        }
        return 1;
}

If you compile this program to noint, you would just execute ./noint ./y.

As ephemient notes in comments, the signal disposition is also inherited, so you can have the wrapper ignore the signal instead of blocking it:

#include <signal.h>
#include <unistd.h>
#include <stdio.h>

int main(int argc, char *argv[])
{
        struct sigaction sa = { 0 };

        sa.sa_handler = SIG_IGN;
        sigaction(SIGINT, &sa, 0);

        if (argc > 1) {
                execvp(argv[1], argv + 1);
                perror("execv");
        } else {
                fprintf(stderr, "Usage: %s <command> [args...]\n", argv[0]);
        }
        return 1;
}

(and of course for a belt-and-braces approach, you could do both).

Answer 5

The solutions explained above are not working for me, even by chaining the both commands proposed by Caf.

However, I finally succeeded in getting the expected behavior this way :

#!/bin/zsh
setopt MONITOR
TRAPINT() { print AAA }

print 1
( ./child & ; wait)
print 2

If I press Ctrl-C while child is running, it will wait that it exits, then will print AAA and 2. child will not receive any signals.

The subshell is used to prevent the PID from being shown.

And sorry... this is for zsh though the question is for bash, but I do not know bash enough to provide an equivalent script.