diff -up tcp_wrappers_7.6/shell_cmd.c.patch20 tcp_wrappers_7.6/shell_cmd.c

--- tcp_wrappers_7.6/shell_cmd.c.patch20	1994-12-28 17:42:44.000000000 +0100

+++ tcp_wrappers_7.6/shell_cmd.c	2008-08-29 09:45:12.000000000 +0200

@@ -20,6 +20,11 @@ static char sccsid[] = "@(#) shell_cmd.c

 #include <stdio.h>

 #include <syslog.h>

 #include <string.h>

+#include <errno.h>

+#include <unistd.h>

+#include <sys/wait.h>

+#include <sys/stat.h>

+#include <fcntl.h>

 extern void exit();

@@ -31,13 +36,42 @@ extern void exit();

 static void do_child();

+/*

+ * The sigchld handler. If there is a SIGCHLD caused by a child other than

+ * ours, we set a flag and raise the signal later.

+ */

+volatile static int foreign_sigchld;

+volatile static int our_child_pid;

+static void sigchld(int sig, siginfo_t *si, void *unused)

+{

+    if (si && si->si_pid != our_child_pid)

+	foreign_sigchld = 1;

+}

+

 /* shell_cmd - execute shell command */

 void    shell_cmd(command)

 char   *command;

 {

     int     child_pid;

-    int     wait_pid;

+

+    struct sigaction new_action, old_action;

+    sigset_t new_mask, old_mask, empty_mask;

+

+    new_action.sa_sigaction = &sigchld;

+    new_action.sa_flags = SA_SIGINFO;

+    sigemptyset(&new_action.sa_mask);

+    sigemptyset(&new_mask);

+    sigemptyset(&empty_mask);

+    sigaddset(&new_mask, SIGCHLD);

+

+    /*

+     * Set the variables for handler, set the handler and block the signal

+     * until we have the pid.

+     */

+    foreign_sigchld = 0; our_child_pid = 0;

+    sigprocmask(SIG_BLOCK, &new_mask, &old_mask);

+    sigaction(SIGCHLD, &new_action, &old_action);

     /*

      * Most of the work is done within the child process, to minimize the

@@ -49,12 +83,26 @@ char   *command;

 	tcpd_warn("cannot fork: %m");

 	break;

     case 00:					/* child */

+	/* Clear the blocked mask for the child not to be surprised. */

+	sigprocmask(SIG_SETMASK, &empty_mask, 0);

 	do_child(command);

 	/* NOTREACHED */

     default:					/* parent */

-	while ((wait_pid = wait((int *) 0)) != -1 && wait_pid != child_pid)

-	     /* void */ ;

+	our_child_pid = child_pid;

+	sigprocmask(SIG_UNBLOCK, &new_mask, 0);

+	while (waitpid(child_pid, (int *) 0, 0) == -1 && errno == EINTR);

     }

+

+    /*

+     * Revert the signal mask and the SIGCHLD handler.

+     */

+    sigprocmask(SIG_SETMASK, &old_mask, 0);

+    sigaction(SIGCHLD, &old_action, 0);

+

+    /* If there was a foreign SIGCHLD, raise it after we have restored the old

+     * mask and handler. */

+    if (foreign_sigchld)

+	raise(SIGCHLD);

 }

 /* do_child - exec command with { stdin, stdout, stderr } to /dev/null */