多次调用sigint，而不是一次（C）

Question

This is a snippet of my code:

signal (SIGINT, ( void *)sig_handler); 

while(1){
    newsockd = -1;
    memset(&cli_addr, 0, sizeof(cli_addr));

    if((newsockd = accept(sockd, (struct sockaddr *) &cli_addr, (socklen_t *) &socket_len)) < 0){
        perror("Errore nella connessione\n");
        onexit(newsockd, sockd, 0, 2);
    }
    fprintf(stdout, "Ricevuta richiesta di connessione dall' indirizzo %s\n", inet_ntoa(cli_addr.sin_addr));

    child_pid = fork();
    if(child_pid < 0){
        perror("Fork error");
        onexit(newsockd, sockd, 0, 2);
    }
    if(child_pid == 0){
        do_child(newsockd);
        exit(0);
    }
    else{
       while(waitpid(child_pid, NULL, WNOHANG) > 0)
        continue;
       }
    }
}

and the function sig_handler:

void sig_handler(const int signo, const int sockd, const int newsockd){
  if (signo == SIGINT){
    printf("Received SIGINT, exiting..\n");
    if(newsockd) close(newsockd);
    if(sockd) close(sockd);
    exit(EXIT_SUCCESS);
  }
}

The problem happens when i press "CTRL+C" because sighandler is called multiple times.
Example:

1. Server is listening;
2. 2 x Connection received;
3. 2 x child fork;
4. 2 x child are closed;
5. now i want to close the server so i press CTRL+C;

expected output:
received SIGINT, exiting....
real output:
received SIGINT, exiting....
received SIGINT, exiting....
received SIGINT, exiting....

Why i got this behaviour?

EDIT: code updated
This is what happens when 1 fork is done and when the child has finished i close the server:

^C7518
7516
Received SIGINT, exiting...
Received SIGINT, exiting...

SOLUTION FOUND: the problem was that i haven't write exit(0) after the instruction do_child() ...code updated!

Answer 1

The signal is sent to every child process of the current process.
In your code, when you're using fork , you create a child process that inherits from the main process the SIGINT handler. That's why the message is printed several times.

Answer 2

There are few observations,

1)You should better use sigaction instead of signal function. http://pubs.opengroup.org/onlinepubs/7908799/xsh/sigaction.html

2)Now some fixes in your current code. You may use

if(child_pid == 0)
{
   /*Now in the child make again the action for SIGINT default, so that 
   your handler does not get called.*/ 
       signal (SIGINT, SIG_DFL);
       do_child(newsockd);
}   

3)Why you are calling waitpid in the main loop? You should have a handler for SIGCHLD and then use wait/waitpid inside it.

Ideally after creating a child to serve client, the main loop should go back to accept. (If it is geeting blocked after creation of a child then how your server becomes a concurrent server?)

(Or for the first version, I would suggest you avoid this instead use, after your call to signal handler for SIGINT,

signal(SIGCHLD, SIG_IGN);  //This should  automatically get rid of zombies.

(Pl. experiment this in your system)

Link for reference - http://en.wikipedia.org/wiki/SIGCHLD

4)It seems your argument to the handler for SIGINT is also not proper.The proper prototype is

void (*signal(int sig, void (*func)(int)))(int);

But your handler is

void sig_handler(const int signo, const int sockd, const int newsockd).

How the values of sockfd & newsockfd are getting passed?
Link

http://pubs.opengroup.org/onlinepubs/009696899/functions/signal.html

Answer 3

I am not sure how you kill the child process.If the child process is not in Zomb status yet, your sign_handler will work on it. May need add more log to clarify the sequence of child process life cycles.

Answer 4

On a related note: I found that I was getting multiple SIGINT for a single CTRL+C as well. When I checked my task manager, I actually had multiple hung node.js scripts for this application. Once I terminated them in task manager, I started receiving single SIGINT as expected.