Signal handling enhancement

include/conf.h

  */
 char *status2str(int);
 
+void pyfcgi_sighandler_drop(int signum);
+
 #endif

src/conf.c

 	}
 	return strndup(buff, 1024);
 }
+
+void pyfcgi_sighandler_drop(int signum)
+{
+	pyfcgi_log(LOG_DEBUG, "Catching signal %s", strsignal(signum));
+	return;
+}
+

src/main.c

 
 void sighandler(int signum)
 {
-	int ret;
+	int status, ret, i;
+	struct timespec req;
+
+	req.tv_sec = 0;
+	req.tv_nsec = 100000000; //0.1s
+
 	if(signum == SIGALRM)
 	{
 		pyfcgi_log(LOG_WARNING, "Master process received SIGALRM !");
 	}
 	if(pool_handler_pid)
 	{
+		pyfcgi_log(LOG_INFO, "Killing pool_handler(%d)",
+			pool_handler_pid);
 		kill(pool_handler_pid, SIGTERM);
-		waitpid(pool_handler_pid, &ret, 0);
+		for(i=0; i<5; i++)
+		{
+
+			ret = waitpid(pool_handler_pid, &status, WNOHANG);
+			if(ret <= 0)
+			{
+				nanosleep(&req, NULL);
+				continue;
+			}
+			pool_handler_pid = 0;
+			break;
+		}
 	}
 	if(monitor_serv_pid)
 	{
+		pyfcgi_log(LOG_INFO, "Killing monitor(%d)",
+			monitor_serv_pid);
 		kill(monitor_serv_pid, SIGTERM);
-		waitpid(monitor_serv_pid, &ret, 0);
+		for(i=0; i<5; i++)
+		{
+
+			ret = waitpid(monitor_serv_pid, &status, WNOHANG);
+			if(ret <= 0)
+			{
+				nanosleep(&req, NULL);
+				continue;
+			}
+			monitor_serv_pid = 0;
+			break;
+		}
+	}
+	if(pool_handler_pid)
+	{
+		pyfcgi_log(LOG_WARNING,
+			"pool_handler(%d) seems to freeze, sending SIGKILL",
+			pool_handler_pid);
+		kill(pool_handler_pid, SIGKILL);
+	}
+	if(monitor_serv_pid)
+	{
+		pyfcgi_log(LOG_WARNING,
+			"pool_handler(%d) seems to freeze, sending SIGKILL",
+			monitor_serv_pid);
+		kill(monitor_serv_pid, SIGKILL);
 	}
 	pyfcgi_log(LOG_INFO,
 		"Master process exiting.");
 
 	act.sa_handler = sighandler;
 	sigemptyset(&act.sa_mask);
-	sigaddset(&act.sa_mask, SIGTERM);
 	act.sa_flags = 0;
 	act.sa_restorer = NULL;
 
+	if(sigaction(SIGTERM, &act, NULL))
+	{
+		perror("Sigaction error");
+		exit(4);
+	}
 	if(sigaction(SIGINT, &act, NULL))
 	{
 		perror("Sigaction error");
 		exit(4);
 	}
-	sigfillset(&act.sa_mask);
-	sigdelset(&act.sa_mask, SIGINT);
-	sigdelset(&act.sa_mask, SIGTERM);
 	act.sa_handler = debug_sighandler;
 	if(sigaction(SIGALRM, &act, NULL))
 	{

src/monitor.c

 pid_t pyfcgi_spawn_monitor()
 {
 	pid_t res;
-	struct sigaction act;
-	const int signums[] = {SIGINT, SIGTERM, SIGALRM, 0};
-	const int *signum;
+	struct sigaction act, actdrop;
 	int err;
 
-	signum = signums;
 	act.sa_handler = pyfcgi_monitor_sighandler;
 	sigemptyset(&act.sa_mask);
 	act.sa_flags = 0;
 	act.sa_restorer = NULL;
+	
+	actdrop.sa_handler = pyfcgi_sighandler_drop;
+	sigemptyset(&act.sa_mask);
+	act.sa_flags = 0;
+	act.sa_restorer = NULL;
 
 	if(!PyFCGI_conf.mon_socket)
 	{
 	if(!res)
 	{ //child process
 		pyfcgi_logger_set_ident("StatServ");
-		while(*signum)
+		if(sigaction(SIGTERM, &act, NULL))
 		{
-			if(sigaction(*signum, &act, NULL))
-			{
-				err = errno;
-				pyfcgi_log(LOG_ERR, "Unable to run sigaction for %s : %s",
-					strsignal(*signum), strerror(err));
-				exit(PYFCGI_FATAL);
-			}
-			signum++;
+			err = errno;
+			pyfcgi_log(LOG_ERR, "Unable to run sigaction for SIGTERM : %s",
+				strerror(err));
+			exit(PYFCGI_FATAL);
+		}
+		if(sigaction(SIGINT, &actdrop, NULL))
+		{
+			pyfcgi_log(LOG_WARNING, "Unable run sigaction for SIGINT sigaction : %s",
+				strerror(errno));
+		}
+		if(sigaction(SIGALRM, &actdrop, NULL))
+		{
+			pyfcgi_log(LOG_WARNING, "Unable to restore ALARM sigaction : %s",
+				strerror(errno));
 		}
 		pyfcgi_monitor_loop();
 		pyfcgi_log(LOG_ALERT, "Monitor loop should never return but just did it...");

src/pyworker.c

 		FCGX_Accept(&in_stream, &out_stream, &err_stream, &envp) >= 0)
 	{
 		pyfcgi_wd_arm();
-		sem_post(PyFCGI_SEM(SEM_WREQS).sem); // increment request counter
+		sem_post(PyFCGI_SEM(SEM_WREQS).sem); // increment request counter discarding OF
 		gettimeofday(&start, NULL);
 		worker_set_busy();
 		count++;
 	while ((!count || count != max_reqs) && FCGX_Accept(&in_stream, &out_stream, &err_stream, &envp) >= 0)
 	{
 		pyfcgi_wd_arm();
-		sem_post(PyFCGI_SEM(SEM_WREQS).sem); // increment request counter
+		sem_post(PyFCGI_SEM(SEM_WREQS).sem); // increment request counter discarding OF
 		gettimeofday(&start, NULL);
 		worker_set_busy();
 

src/responder.c

 pid_t spawn_pool_handler()
 {
 	pid_t res;
+	struct sigaction act;
+
+	act.sa_handler = pyfcgi_sighandler_drop;
+	sigemptyset(&act.sa_mask);
+	act.sa_flags = 0;
+	act.sa_restorer = NULL;
 
 	res = fork();
 	if(res < 0)
 	}
 	if(!res)
 	{
+		if(sigaction(SIGINT, &act, NULL))
+		{
+			pyfcgi_log(LOG_WARNING,
+				"Unable to sigaction SIGINT handler : %s",
+				strerror(errno));
+		}
 		responder_loop();
 		exit((unsigned char)-1);
 	}
 	act.sa_flags = 0;
 	act.sa_restorer = NULL;
 
-	if(sigaction(SIGINT, &act, NULL))
+	if(sigaction(SIGTERM, &act, NULL))
 	{
-		perror("Sigaction error for pool process");
+		pyfcgi_log(LOG_ALERT,
+			"Sigaction error for SIGTERM pool process : %s",
+			strerror(errno));
 		exit(PYFCGI_FATAL);
 	}
 
 			exit(PYFCGI_FATAL);
 		}
 		// Set handler for SIGINT & SIGTERM
-		if(sigaction(SIGINT, &act, NULL))
+		/*
+		if(sigaction(SIGINT, &(PyFCGI_conf.context.master_old_sigint),
+			NULL))
 		{
-			perror("Sigaction error for pool process");
+			pyfcgi_log(LOG_ALERT,
+				"Sigaction error for worker process when restoring SIGINT handler: %s",
+				strerror(errno));
 			exit(PYFCGI_FATAL);
 		}
+		*/
 		if(sigaction(SIGTERM, &act, NULL))
 		{
-			perror("Sigaction2 error for pool process");
+			pyfcgi_log(LOG_ALERT,
+				"Sigaction error for worker process : %s",
+				strerror(errno));
 			exit(PYFCGI_FATAL);
 		}
 		// Set watchdog
 
 void pool_sighandler(int signum)
 {
-	unsigned int i;
+	unsigned int i, retry;
+	int status, ret;
 	struct timespec req;
-	req.tv_sec = 0;
-	req.tv_nsec = 200000000; //0.2s
+
+	pyfcgi_log(LOG_NOTICE, "Received signal %s, cleaning & exiting...",
+		strsignal(signum));
 	if(PyFCGI_conf.context.n_wrk < 1) { clean_exit(0); }
 
 	for(i=0; i<PyFCGI_conf.context.n_wrk; i++)
 		pyfcgi_log(LOG_INFO, "Sending SIGTERM to child #%d (pid %d)",
 			i,(*PyFCGI_conf.context.wrk_pids)[i]);
 		kill((*PyFCGI_conf.context.wrk_pids)[i], SIGTERM);
-		nanosleep(&req, NULL); //waiting 0.2s
+	}
+	retry = i = 0;
+	while(i<PyFCGI_conf.context.n_wrk)
+	{
+		ret = waitpid((*PyFCGI_conf.context.wrk_pids)[i], &status,
+			WNOHANG);
+		if(ret <= 0 && retry < 3)
+		{
+			retry++;
+			req.tv_sec = 0;
+			req.tv_nsec = 100000000; //0.1s
+			nanosleep(&req, NULL);
+		}
+		else
+		{
+			if(retry < 3)
+			{
+				(*PyFCGI_conf.context.wrk_pids)[i] = 0;
+			}
+			retry = 0;
+			i++;
+		}
 	}
 	for(i=0; i<PyFCGI_conf.context.n_wrk; i++)
 	{
-		if(kill((*PyFCGI_conf.context.wrk_pids)[i], SIGCONT))
+		if((*PyFCGI_conf.context.wrk_pids)[i])
 		{
 			pyfcgi_log(LOG_INFO, "Sending SIGKILL to child %d", i);
 			kill((*PyFCGI_conf.context.wrk_pids)[i], SIGKILL);