How to stop reading from keyboard once a signal is handled?

Question

I'm writing a program where the SIGINT signal is handled the first time it is sent, but set to default after that. So, for example, I have this:

static volatile int stop_terminating = 1;

void handler(int dummy) {
    stop_terminating = 0;
}

int main(){
    signal(SIGINT, handler);
    char input[256];
    while(1){
        if(stop_terminating == 0){
            // reset the action of the signal to default
            signal(SIGINT, SIG_DFL);
            printf("Message sent.\n");
            // increment counter so it doesn't enter this condition again
            stop_terminating++;
        }
        printf("User input:\n");
        fgets(input, sizeof(input), stdin);
        // In this stage, I wanna press CTRL+C and print a message, stopping the fgets
        // but what happens is: I press CTRL+C, the signal is catched, but fgets
        // is still asking for an input, and after I send something, the my message is printed
        // because it looped through the while(1) again.
    }
}

How can I stop fgets from asking for an input and just print the message and then ask again for an input?

`volatile` is not sufficient for multithreaded programming. Use atomics. — too honest for this site, Apr 05 '17 at 21:23
I actually don't know how to do that. I've been struggling to get to this point and I know some things just partially. — sbstnssndn, Apr 05 '17 at 21:43
@BenVoigt: I wonder why there is `sig_atomic_t` with additional guarantees then. Interestingly this type existed _before_ C11's atomics support already. Note: `volatile` does not guarantee atomic access. — too honest for this site, Apr 06 '17 at 13:45

score 3 · Accepted Answer · edited Jun 20 '20 at 09:12

The Linux manual page for signals says that

Interruption of system calls and library functions by signal handlers

If a signal handler is invoked while a system call or library function call is blocked, then either:

the call is automatically restarted after the signal handler returns; or

the call fails with the error EINTR.

Which of these two behaviors occurs depends on the interface and whether or not the signal handler was established using the SA_RESTART flag (see sigaction(2)).

You may use either the siginterrupt() function together with signal(), or use sigaction() instead of signal() for registering your signal handler, in order to disable restarting a read() system call after a signal.

Note however that fgets() from the C library might call read() multiple times until a newline character is found, therefore you may also need to switch to using the lower-level functions instead of stdio.h APIs.

score 1 · Answer 2 · answered Oct 21 '21 at 09:24

1

If you close stdin fgets will return immediately, then you can try to open stdin again. This is weird but can work as a workaround

answered Oct 21 '21 at 09:24

debuti

623
2
10
20

score 0 · Answer 3 · answered Apr 06 '17 at 05:52

0

You get a NULL from fgets when it reaches EOF. From the keyboard, that's usually signalled with CTRL-D (Linux/Unix/MacOS X) or CTRL-Z (DOS/Windows and I think MacOS before X)

answered Apr 06 '17 at 05:52

Rajeshkumar

739
5
16

This doesn't help with signal handling, which is the point of the question. – Ben Voigt Apr 06 '17 at 05:54
CTRL+D is not actually a signal, so that doesn't help me in this case. But I already solved it, thanks anyway. – sbstnssndn Apr 06 '17 at 07:31

How to stop reading from keyboard once a signal is handled?

3 Answers3

Linked