exit() the program from parent before child process has terminated

Question

I have a C server. This server has to handle multiple connections and user's input (through a simple ncurses GUI). So I created two childs.
My problem comes when from the main menu of the user interface, I need to exit the program (then terminate the second child process -which handles the connections- from the first child process).

I'll try to explain myself with a little example:

int main(){
    pid_t pid;
    int status1, status2;
    if((pid = fork()) < 0){
        perror("main fork failure:");
        exit(1);
    }

    if(pid == 0){
        pid = fork();
        if(pid == 0){
            /*  
                some stuff the second child does while 
                the first child is already running
            */
        }
        /* this is the first child */
        int choice;
        choice = menu();
        switch(choice){
            case 1:
                break;
            case 2:
                /* 
                   HERE I have to exit (from the first child first,
                   and from the program then): how can I kill the
                   second child that is running to prevent
                   zombie processes? 
                */
                // kill() which pid?
                exit(2);
                break;
        }
        wait(&status2);
    }
    wait(&status1);
    return 0;
}

So, how can I kill it if I don't know the second child pid from the first child?

Answer 1

In your code, you reuse the variable pid, but fortunately, the non-zero pid is the one you need to signal.

Hence:

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>

extern int menu(void);

static void wait_for_pid(int pid)
{
    int status;
    int corpse;
    while ((corpse = wait(&status)) >= 0 && corpse != pid)
        printf("Unexpected child %d exited with status 0x%.4X\n", corpse, status);
    if (corpse == pid)
        printf("Child %d exited with status 0x%.4X\n", corpse, status);
    else
        printf("Child %d died without its death being tracked\n", pid);
}

int main(void)
{
    pid_t pid;
    if ((pid = fork()) < 0)
    {
        perror("main fork failure:");
        exit(1);
    }

    if (pid == 0)
    {
        if ((pid = fork()) < 0)
        {
            perror("child fork failure:");
            exit(1);
        }
        if (pid == 0)
        {
            pause();    /* Do nothing until signalled */
            exit(0);
        }
        /* this is the first child */
        int choice = menu();
        switch (choice)
        {
        case 1:
            /* action 1 */
            break;
        case 2:
            kill(pid, SIGTERM);
            exit(2);
            /*NOTREACHED*/
        }
        wait_for_pid(pid);
        exit(0);
    }
    wait_for_pid(pid);
    return 0;
}

The loop in the wait_for_pid() function should be overkill for the child, but the parent process could have children it doesn't know about under some circumstances — unlikely but not impossible circumstances.

The use of pause() in the second child is simply writing some code; it is not useful and would not therefore be what you'd write there. Writing the comment /* action 1 */ is likewise dummy code; you'd replace it with code that does something useful. I'd probably have functions to call for the first child and the second child, rather than embedding much code in main(). I assume that it's written as shown to create an MCVE (Minimal, Complete, Verifiable Example); thank you for keeping the code small.

---

The code above was untested because there was no menu() function. The code below has a menu function — not that it is very interactive.

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>

extern int menu(void);

int menu(void)
{
    printf("Dozing...\n");
    sleep(1);
    printf("Menu option 2 chosen\n");
    return 2;
}

static void wait_for_pid(int pid)
{
    int status;
    int corpse;
    int curpid = getpid();
    printf("%d: waiting for children to die\n", curpid);
    while ((corpse = wait(&status)) >= 0 && corpse != pid)
        printf("%d: Unexpected child %d exited with status 0x%.4X\n", curpid, corpse, status);
    if (corpse == pid)
        printf("%d: Child %d exited with status 0x%.4X\n", curpid, corpse, status);
    else
        printf("%d: Child %d died without its death being tracked\n", curpid, pid);
}

int main(void)
{
    pid_t pid;
    if ((pid = fork()) < 0)
    {
        perror("main fork failure:");
        exit(1);
    }

    if (pid == 0)
    {
        if ((pid = fork()) < 0)
        {
            perror("child fork failure:");
            exit(1);
        }
        if (pid == 0)
        {
            printf("Second child (%d) - pausing\n", (int)getpid());
            pause();    /* Do nothing until signalled */
            printf("Second child (%d) - awake despite no signal handling\n", (int)getpid());
            exit(0);
        }
        /* this is the first child */
        printf("First child (%d) - menuing\n", (int)getpid());
        int choice = menu();
        switch (choice)
        {
        case 1:
            /* action 1 */
            break;
        case 2:
            printf("kill(%d, SIGTERM)\n", pid);
            kill(pid, SIGTERM);
            wait_for_pid(pid);
            exit(2);
            /*NOTREACHED*/
        }
        /* Reached on menu choices != 2 */
        /* Probably needs a loop around the menu() - end loop before wait_for_pid()  */
        wait_for_pid(pid);
        exit(0);
    }
    wait_for_pid(pid);
    return 0;
}

When run, a sample output sequence was:

19489: waiting for children to die
First child (19490) - menuing
Dozing...
Second child (19491) - pausing
Menu option 2 chosen
kill(19491, SIGTERM)
19490: waiting for children to die
19490: Child 19491 exited with status 0x000F
19489: Child 19490 exited with status 0x0200

All of which looks as would be expected. You can see the death from SIGTERM in the status 0x000F (SIGTERM is normally 15, and is 15 on macOS Sierra, though AFAIK no standard demands that it is 15). You can see the first child exited normally with status 2 from the 0x0200. You can see that the parent started waiting before the children did anything. And you can see the debugging techniques — copious printing and including the PID most of the time.