Interrupt read call on signal

Question

I have to interrupt a read call if ctrl-c is pressed, using signal. I wrote this (simplified) sample code:

#include <unistd.h>
#include <sys/wait.h>

int should_stop = 0;

void sighandler(int signal)
{
    write(1, "\nctrl-c has been pressed\n", 25);
    should_stop = 1;
}

void read_function()
{
    char c;

    while (!should_stop)
        read(0, &c, 1);
    //Do some stuff and return someting
}

int main()
{
    signal(SIGINT, &sighandler);
    read_function();
    write(1, "read_function is over\n", 22);
    return (0);
}

As read is a blocking call (as far as I understood), the should_stop global variable will not be evaluated once read has been called. So I don't know how I could interrupt the read call by pressing ctrl-c.

Another constraint is that I'm only allowed to use those functions:

- write
- read
- fork
- wait
- signal
- kill
- exit

So I can't use select to set a timeout value. As I also need the return value of read_function, I can't use fork and just exit the process with a different signal handler.

Is there another way to interrupt the read call?

Answer 1

This is what currently happens: when you send an interrupt signal from keyboard, the signal handler comes into action, writes the \nctrl-c has been pressed\n message to your console and sets the should_stop variable. Then, control is returned back to read(0, &buf, 1) statement. As the stdin is buffered, read won't be over until it meets a newline. If you press Enter afterwards — read reads one bit and returns. After that, a condition should_stop is checked again, and since it contains 1 value now — loop is over.

Now, we want to modify that behavior so that your program is gracefully shut down after SIGINT.

From man 7 signal:

If  a  blocked  call  to one of the following interfaces is interrupted by a
signal handler, then the call is automatically restarted  after  the  signal
handler  returns  if  the SA_RESTART flag was used; otherwise the call fails
with the error EINTR:

From man 2 signal:

certain  blocking  system calls are automatically
restarted if interrupted by a signal handler (see signal(7)).  The  BSD  se‐
mantics are equivalent to calling sigaction(2) with the following flags:

   sa.sa_flags = SA_RESTART;

So, here's how we employ sigaction(2) for our case:

int main()
{
    struct sigaction sa;
    sigemptyset(&sa.sa_mask);
    sa.sa_handler = sighandler;
    sa.sa_flags = 0;

    sigaction(SIGINT, &sa, NULL);
    read_function();
    write(1, "read_function is over\n", 22);
    return (0);
}

This way, upon interruption by signal handler, read(2) returns with EINTR error and is not restarted.

signal(2) is generally inferior to sigaction(2) when it comes to portability of the code, you can read about it here

Answer 2

It should work provided you declare the should_stop variable to be volatile. This will instruct the compiler to re-read it from memory on every access:

...
volatile int should_stop = 0;
...

Simply depending on your system, a read call may be restarted after a signal, and you will have to hit return after the Ctrl-C to end the program. By default, my FreeBSD 11 bos behaves like that.

If you want the read call not to be restarted, you should explicitely ask for that behaviour with siginterrupt:

...
signal(SIGINT, &sighandler);
siginterrupt(SIGINT, 1);
...

That way, the program will stop immediately after the Ctrl-C