handle SIGINT with scanf in loop - c

Question

I have to take input from user in a while loop and then take some action. And I also want to exit my code on ctrl+c input.
void my_signal_handler(int sig)
{
running = false;
signal(sig, SIG_IGN);
}
int main(void)
{
struct sigaction sa = {{0}};
sa.sa_handler = &my_signal_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
if (sigaction(SIGINT, &sa, NULL) != 0)
{
fprintf(stderr, "sigaction error\n");
return -1;
}
while(running)
{
printf("enter number: ");
scanf("%d", &num);
// take action based on number
}
}
Problem with this code is after pressing ctrl+c, it doesn't exit but it waits for input for scanf. So once I press an extra key, the program exits (signal handler gets called).
How can I remove this extra step of giving input to scanf after pressing ctrl+c ?

Answer 1

You should install the signal handler. At the very least, add
signal(SIGINT, my_signal_handler);
inside your main before the while(running), but better use sigaction(2).
You should also know that stdio is buffering; usually stdout is line-buffered when it is a terminal (but see setvbuf(3) and friends). So you should either call fflush(3) (probably as fflush(NULL);) before the scanf inside the loop, or terminate every printf format control string with an explicit \n.
At last, scanf(3) can fail and is returning the count of scanned items, which you should test.
BTW, your  main is wrong, should be defined as int main(void) or preferably int main(int argc, char**argv).
However (assuming you are on Linux), read very carefully signal(7) (notice what is said about signal handlers and async-signal safe functions) and POSIX signal.h documentation and declare your running flag as
volatile sigatomic_t running;
(or perhaps, in C11, as volatile _Atomic bool running;)
The volatile qualifier is very important. Otherwise, the compiler is allowed to optimize (and e.g. pretend that running is always true).
Notice that using signal(2) is often a bad idea. First, if you really need signal handling, you'll better use sigaction(2). Then your call to signal(sig, SIG_IGN); is, in your case, useless (since the running volatile flag would have been changed in the signal handler). At last, for multiplexing input (& output), you could use poll(2) which can be used to wait and test if there is some available input on stdin (actually STDIN_FILENO which is 0), and more generally to implement event loops. You could use (instead of poll which I strongly recommend) the old and nearly obsolete select(2), but you'll rather use poll(2). See also epoll(7) & inotify(7) but you probably don't need them.
Be aware that in terminals, stdin is often a tty (check that with isatty(3)) following the line discipline (so some of the line buffering happens inside the kernel). Read the tty demystified page. Consider using the GNU readline library and function (or perhaps ncurses), which might be what you really need.
Read also Advanced Linux Programming and take the habit of reading the documentation of every function that you are using.