[SOLVED] Unblock fgets when signal is received.

user@123 · 12-05-2014, 04:34 AM

Hello All,

In following program i registered signal SIGINT. When executing this program if SIGINT is sent while fgets is waiting for input, i want to do something in signal handler so that fgets should be unblocked and further processing should happen.

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

void SignalHandler(int Signum)
{
//
// Signal received.
//
}

int main(int argc, char const *argv[])
{
char szBuffer[50];
signal(SIGINT, SignalHandler);
fgets(szBuffer, sizeof(szBuffer), stdin);

//
// Do further processing.
//
return 0;
}

mina86 · 12-05-2014, 04:45 AM

You can do stuff in the signal handler. If you want your main function to continue executing, I'm afraid you need to use lower level read function (at which point you'll have to take care of buffering and finding line ends) which returns -1 with errno == EINTR when signal is returned.

SoftSprocket · 12-05-2014, 08:48 AM

It's ugly but you can do this:

Code:

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

jmp_buf return_here;

void sigint_handler (int signum) {
        longjmp (return_here, 1);
}       

int main () {
        signal (SIGINT, sigint_handler);
        
        while (1) {
                if (setjmp (return_here)) {
                        printf ("Hello, sigint!\n");
                        signal (SIGINT, sigint_handler);
                }       
                
                char inp[40];
                fgets (inp, 40, stdin);
                printf ("%s\n", inp);
        }       
        
        return 0;
}

There are better ways such as using signalfd in Linux and polling on the file descriptors.

mina86 · 12-05-2014, 10:22 AM

If the above works, it's only by sheer luck. For one, there is a race condition between when signal handler is set up and when jmp_buf is initialized. Furthermore, this will accumulate stuff on your stack. And lastly, you leave the standard library in God knows hat state when you abruptly interrupt fgets. It's not that it's “ugly”, it's plane broken.

SoftSprocket · 12-05-2014, 11:11 AM

Quote:

Originally Posted by mina86

If the above works, it's only by sheer luck. For one, there is a race condition between when signal handler is set up and when jmp_buf is initialized. Furthermore, this will accumulate stuff on your stack. And lastly, you leave the standard library in God knows hat state when you abruptly interrupt fgets. It's not that it's “ugly”, it's plane broken.

The race condition condition is there, true, but that's easily fixed by setting the handler after setjmp.

The standard library affected? How? Longjmp can be safely used from a signal handler, fgets can be intermixed with other buffered io so there can't be an impact on other calls. The contents of the buffer will be lost but fgets will continue to function. Broken? Maybe but the hyperbole is a little over the top.

mina86 · 12-05-2014, 01:14 PM

Code:

#define _POSIX_C_SOURCE 1

#include <setjmp.h>
#include <signal.h>
#include <signal.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>


#define DIE_ON(cond, str) do {			\
		if ((cond)) {			\
			perror(str);		\
			return 1;		\
		}				\
	} while (0)

static void print(const char *str) {
	puts(str);
	fflush(stdout);
}


static jmp_buf return_here;

static void handler(int signum) {
	signum = signum;
	longjmp(return_here, 1);
}

static int child(FILE *fh) {
	char buf[1024];
	signal(SIGUSR1, handler);

	while (1) {
		if (setjmp(return_here)) {
			print("CHLD: SIG");
			signal(SIGUSR1, handler);
		}

		if (!fgets(buf, sizeof buf, fh)) {
			print("CHLD: EOF");
			return 0;
		}

		printf("CHLD: GOT: %s", buf);
		fflush(stdout);
	}
}


static int parent(int fd, pid_t pid) {
	print("PRNT: send \"foo\"");
	DIE_ON(write(fd, "foo", 3) != 3, "write");
	sleep(1);  /* Make sure data went through */

	print("PRNT: kill");
	DIE_ON(kill(pid, SIGUSR1) < 0, "kill");
	sleep(1); /* Make sure child had a chance to run */

	print("PRNT: send \"bar\\n\"");
	DIE_ON(write(fd, "bar\n", 4) != 4, "write");

	return 0;
}


int main(void) {
	int fds[2];
	pid_t pid;

	DIE_ON(pipe(fds) < 0, "pipe");

	pid = fork();
	DIE_ON(pid < 0, "fork");

	if (pid) {
		close(fds[0]);
		return parent(fds[1], pid);
	} else {
		close(fds[1]);
		return child(fdopen(fds[0], "r"));
	}
}

Code:

$ ./a 
PRNT: send "foo"
PRNT: kill
CHLD: SIG
PRNT: send "bar\n"
CHLD: GOT: bar
CHLD: EOF

Notice how child received “bar\n” while parent sent “foobar\n”.

So I still claim using longjmp is broken (but I was incorrect in claiming that stack will grow indefinitely).

SoftSprocket · 12-05-2014, 01:25 PM

Quote:

Originally Posted by mina86

Notice how child received “bar\n” while parent sent “foobar\n”.

So I still claim using longjmp is broken (but I was incorrect in claiming that stack will grow indefinitely).

There are places where you can use it and places where you can't. In the simple case presented by the OP you can; in the case you present you can't.

mina86 · 12-05-2014, 03:09 PM

Quote:

Originally Posted by SoftSprocket

There are places where you can use it and places where you can't.

You can say the same about gets.

Quote:

Originally Posted by SoftSprocket

In the simple case presented by the OP you can; in the case you present you can't.

OP's case is reading lines. My example shows reading lines. They do not differ.

Update: An example witch breaks your code:

Code:

$ cat reader.c 
#include <signal.h>
#include <setjmp.h>
#include <signal.h>
#include <stdio.h>

jmp_buf return_here;

void sigint_handler (int signum) {
	signum = signum;
	longjmp (return_here, 1);
}

int main(void) {
	signal (SIGINT, sigint_handler);

	while (1) {
		if (setjmp (return_here)) {
			printf ("Hello, sigint!\n");
			signal (SIGINT, sigint_handler);
		}

		char inp[40];
		if (!fgets (inp, 40, stdin)) {
			return 0;
		}
		printf ("%s\n", inp);
	}
}
$ cat writer.c 
#include <stdio.h>
#include <unistd.h>

static const char *const strings[] = {
	"foo-", "bar-", "baz-", "qux\n", NULL
};

int main(void) {
	const char *const *str = strings;
	for (; *str; ++str) {
		sleep(1);
		fputs(*str, stdout);
		fflush(stdout);
	}
	return 0;
}
$ sh -x run.sh 
+ ./writer
+ sleep 2
+ ./reader
+ kill -INT 11674
+ wait
Hello, sigint!
baz-qux

Notice how reader only reads “baz-qux”.

SoftSprocket · 12-05-2014, 03:32 PM

Quote:

Originally Posted by mina86

You can say the same about gets.

OP's case is reading lines. My example shows reading lines. They do not differ.

You can't say the same thing about gets. There is no safe way to use gets. Longjmp can be safely used and it can be safely used in signal handlers. You just need to be aware that the state of the data being read at the time of the interrupt is indeterminate.

So far you've made no argument to support your position.

SoftSprocket · 12-05-2014, 03:45 PM

I should add that I don't think it is a good idea to do this in anything but trivial code where I don't care about the state of the input. There are too many other solutions such as setting a variable in the signal handler and responding to it after returning from the fgets however that's not what the OP asked for.

mina86 · 12-05-2014, 03:52 PM

Quote:

Originally Posted by SoftSprocket

Longjmp can be safely used and it can be safely used in signal handlers.

I'm not saying longjmp cannot be used from signal handlers. I'm saying your solution to OP's problem is incorrect and provided code that demonstrates that.

Quote:

Originally Posted by SoftSprocket

however that's not what the OP asked for.

I also don't think OP asked for a solution where data can be dropped.

user@123 · 12-08-2014, 01:22 AM

Thanks @SoftSprocket for your response but this is working for one time means second time on words sigint_handler is not getting called.
For first time program runs and when i press ctrl+c "Hello, sigint!" is printed on stout after that program is waiting for user to give input but second time on words message is not displayed and program is waiting for input.
I visited this link http://www.csl.mtu.edu/cs4411.ck/www...oto/sig-1.html here also i am facing same problem signal handler is executed only on pressing ctrl+c for first time.

user@123 · 12-08-2014, 04:46 AM

Solved my problem using sigsetjmp and siglongjmp.

NevemTeve · 12-08-2014, 08:09 AM

Note: using setjmp/longjmp is essencially the same thing as ON ERROR GOTO in BASIC, exceptions in C++/Java/Ada, FCB.EXLST in System/360 Assembly. I wouldn't use any of them, if I could avoid.