Only receiving parent printf when runnnig GeeksforGeeks sample signal code - c

Question

I am trying to wrap my mind around signals so I started out by running the code on GeeksforGeeks signals page. On their page it is showing output from the parent and the child but when I run in CLion, 9/10 times I am only receiving output from the parent and the child prints nothing. Every once in a while the child will print, but I don't know why or how to get it to consistently print.
https://www.geeksforgeeks.org/signals-c-set-2/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
void sighup();
void sigint();
void sigquit();
void main() {
int pid;
if ((pid = fork()) < 0) {
perror("fork");
exit(1);
}
if (pid == 0) {
signal(SIGHUP, sighup);
signal(SIGINT, sigint);
signal(SIGQUIT, sigquit);
for(;;)
;
}
else {
printf("\nPARENT: sending SIGUP\n\n");
kill(pid, SIGHUP);
sleep(3);
printf("\nPARENT: sending SIGINT\n\n");
kill(pid, SIGINT);
sleep(3);
printf("\nPARENT: sending SIGQUIT\n\n");
kill(pid, SIGQUIT);
sleep(3);
}
void sighup() {
signal(SIGHUP, sighup);
printf("CHILD: I have received a SIGHUP\n");
}
void sigint() {
signal(SIGINT, sigint);
printf("CHILD: I have received a SIGINT\n");
}
void sigquit() {
printf("My parent has killed me");
exit(0);
}

Answer 1

That code is choc-full of errors. You should start by enabling warnings on your compiler. On GCC and clang this is done by passing the flags -pedantic and a warning level. I suggest using -Wall -Wextra -Werror — this gives fairly stringent warnings without getting in the way.
The first two errors, as noted in the commend, are that the prototype declarations are wrong, and that the main function signature is wrong.
The second error is that you cannot safely invoke printf inside a signal handler (you will encounter this relatively common in code, but it’s wrong). In fact, the set of actions you can safely perform inside a signal handler is severely restricted — read the documentation carefully.
Thirdly, the code’s attempt to reset the handlers is botched (and at any rate unnecessary). If you want to reset a handler, you need to pass SIG_DFL as the second argument, not a custom callback. This is also explained in the documentation.
And lastly, there is no guarantee that the code in the child process is executed before the code in the parent process — in particular, it’s not guaranteed that the signal handlers will be set up. In my testing, the child code ends up never being executed, despite the sleep statements in the parent code. That may seem weird but it’s entirely legal and needs to be anticipated.
Putting these pieces together leaves us with the following, which you may notice is a lot more complex than the non-working code you tried.
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
static volatile sig_atomic_t child_signal;
static volatile sig_atomic_t setup_done = 0;
void child_signal_handler(int);
void parent_signal_handler(int);
int main() {
const int parent_pid = getpid();
int pid;
// Set up BEFORE calling `fork`
signal(SIGCHLD, parent_signal_handler);
if ((pid = fork()) < 0) {
perror("fork");
exit(1);
}
if (pid == 0) {
signal(SIGHUP, child_signal_handler);
signal(SIGINT, child_signal_handler);
signal(SIGQUIT, child_signal_handler);
kill(parent_pid, SIGCHLD);
for (;;) {
if (child_signal != 0) {
switch ((int) child_signal) {
case SIGHUP:
fprintf(stderr, "CHILD: I have received a SIGHUP\n");
break;
case SIGINT:
fprintf(stderr, "CHILD: I have received a SIGINT\n");
break;
case SIGQUIT:
fprintf(stderr, "My parent has killed me");
exit(1);
}
child_signal = 0;
}
}
} else {
while (! setup_done) { sleep(1); }
printf("\nPARENT: sending SIGUP\n");
kill(pid, SIGHUP);
sleep(1);
printf("\nPARENT: sending SIGINT\n");
kill(pid, SIGINT);
sleep(1);
printf("\nPARENT: sending SIGQUIT\n");
kill(pid, SIGQUIT);
}
}
void child_signal_handler(int signo) {
child_signal = signo;
}
void parent_signal_handler(int signo) {
if (signo == SIGCHLD) setup_done = 1;
}