Parent process killing child process in infinite loop

Question

To solve my problem, I set prctl(PR_SET_PDEATHSIG, SIGHUP); as in stackoverflow answer before i called exec*, and took out the part where we pipe the PID. It works!!!!! Wow....

HOWEVER, stackoverflow won't let me say I've answered my own question yet...

So I tried to write a program, which I want to run a program, and kill that program after a cpl seconds if it doesn't finish. DADDY forks off a CHILD, which forks off another BABY, CHILD pipes the PID of the BABY to DADDY, which then waits a second and kills them both if they haven't wrapped up their business (it's a macabre scene). But it doesn't work, DADDY stays in S+ State, and the infinite loop that is Baby goes on forever until I ctr+c. On the bright side, this code is an amalgamation of everything I've learnt on stack-overflow. Here we go.

#include <math.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

static int read_from_pipe(int file)
{
    int c;
    FILE *stream = fdopen(file, "r");

    if (fscanf(stream, "%d", &c) != 1)
    {
        fprintf(stderr, "Failed to read integer from pipe\n");
        exit(1);
    }
    fclose(stream);
    return c;
}

static void write_to_pipe(int file, int pidRacket)
{
    FILE *stream = fdopen(file, "w");
    fprintf(stream, "%d", pidRacket);
    fclose(stream);
}

static int spawnpipe(char *fileName, int *fd)
{
    int pid;
    int pipe_fds[2];
    char *command[] = {"racket", fileName, NULL};
    if (pipe(pipe_fds) < 0)
    {
        fprintf(stderr, "FE: pipe\n");
        exit(1);
    }

    switch ((pid = fork()))
    {
    case -1:
        printf("syserr");
        exit(1);
    case 0:

        close(1);
        close(2);
        dup(pipe_fds[1]);
        close(pipe_fds[0]);
        close(pipe_fds[1]);
        execvp(*command, command);
        perror("execv");
        exit(EXIT_FAILURE);

    default:
        *fd = pipe_fds[0];
        close(pipe_fds[1]);
        return pid;
    }
}

static int spawnfp(char *fileName, FILE **fpp)
{
    int fd, pid;
    pid = spawnpipe(fileName, &fd);
    *fpp = fdopen(fd, "r");
    return pid;
}

int main(int argc, char *argv[])
{
    pid_t pid;
    int mypipe[2];
    if (pipe(mypipe))
    {
        fprintf(stderr, "Pipe failed.\n");
        return EXIT_FAILURE;
    }

    pid = fork();
    if (pid < (pid_t) 0)
    {
        fprintf(stderr, "Fork failed.\n");
        return EXIT_FAILURE;
    }
    else if (pid != (pid_t) 0)
    {
        double diff = 0;
        clock_t launch = clock();

        close(mypipe[1]);
        int pidRacket = read_from_pipe(mypipe[0]);
        while (diff < 1.3)
        {
            clock_t done = clock();
            diff = ((double)done - (double)launch) / (double)CLOCKS_PER_SEC;
        }
        kill(pidRacket, SIGKILL);
        kill(pid, SIGKILL);
        return EXIT_SUCCESS;
    }
    else if (pid == (pid_t) 0)
    {
        close(mypipe[0]);
        char buf[100];
        FILE *fp;
        char *fileName = argv[1];
        int pidRacket = spawnfp(fileName, &fp);
        write_to_pipe(mypipe[1], pidRacket);

        if (argc == 1)
        {
            printf("Not enough arguments!");
            _exit(EXIT_FAILURE);
        }
        else if (argc == 2)
        {
        }
        sleep(1);
        while (fgets(buf, sizeof buf, fp))
        {
            printf("%s\n", buf);
        }
        fclose(fp);
        kill(pid, SIGKILL);
        return 0;
    }
}

Credit to quinsley and vijay!

Answer 1

I made this a while back for stupid fun, it uses up a big chunk of your cpu to run but I'm sure you can modify it to break at a certain point or to fit your needs maybe.

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

int main(int argc, char*argv[])
{
    int childpid;
    int pids[100];
    int count1 = 0, count2 = 0;
    int count3 = 0;

    L1:
    childpid = fork();

    if(childpid == 0)
    {       

    }   
    else
    {

        if(childpid != 0 && childpid != -1)
        {
            if(count3 < 100)
            {
                pids[count3] = childpid;
                printf("Pid:%d\n",pids[count3]);                
                count3++;
                goto L1;
            }
            else
            {
                count3--;
                goto L2;
            }   
        }

        L2:
            while(count3 > 0)
            {
                if(pids[count3] != -1 || pids[count3] != 1)
                {
                    printf("Killing pid:%d\n",pids[count3]);
                    kill(pids[count3],SIGKILL);
                }       
                count3--;
            }

            if(count3 == 0)
            {
                goto L1;
            }   
    }

    return 0;
}

Answer 2

Various comments as I look at the code:

1. End messages with newlines; you're on Linux now, not Windows. Windows systems seem to encourage people to leave messages without newlines, but it won't work well on Unix in general and Linux in particular.

2. Don't use _exit() if you want your error messages to appear, especially ones that don't end in a newline.

3. Don't report error messages on standard output; report them on standard error (that's what it is for!).

4. Writing else if (argc == 2) { } (with nothing in the braces) is a little odd if there is an else clause after it, but it is pointless when there is no else clause. You should arguably test for argc != 2 since that is the correct number of arguments (or, perhaps more accurately, any arguments beyond argc == 2 are ignored).

5. If you want to sleep for a time involving sub-second timing (e.g. 1.3 seconds), use one of the appropriate sub-second sleep commands. In this case, nanosleep() is probably the function to use.

6. Don't use SIGKILL except in dire emergency. The process signalled with SIGKILL has no chance to clean up or anything; it is killed immediately (assuming your process is allowed to send a signal to the other at all, of course).

7. case -1: printf("syserr"); with no break; after it means that on error, the flow of control goes into the following case 0: code, which is not what's required. Either break; or exit(1); is probably appropriate. (Bullet 3 applies too.)

8. Don't close standard error. The code:

   close(1);
   close(2);
   dup(pipe_fds[1]);
   close(pipe_fds[0]);
   close(pipe_fds[1]);
   execvp(*command, command);
   perror("execv");
   _exit(EXIT_FAILURE);
   

   is never going to report an error; you closed standard error. Remember that programs are entitled to have a standard error channel. The C standard guarantees it, but you have to cooperate and make sure you've not closed standard error.

9. Some of the casts in:

   diff = ((double)((uintmax_t)(clock_t)done) - (double)((uintmax_t)(clock_t)launch)) / (double)CLOCKS_PER_SEC;
   

   are unnecessary. Since both done and launch are of the type clock_t, the casts to clock_t are unnecessary. The intermediate cast to uintmax_t also isn't really necessary. You could simply write:

   diff = ((double)done - (double)launch) / (double)CLOCKS_PER_SEC;
   

   and even then, two of the three casts are theoretically redundant (any two of the three could be removed).

10. The code in read_from_pipe() is curious and error prone. Since you've got a file stream, simply read an integer from it using fscanf(), rather than the curious construct using double arithmetic and fractional values that are then multiplied at the end. This is especially appropriate since the write_to_pipe() code uses printf("%d", ...); to write the data. Since c is already an int, the cast in return (int)c; is superfluous.

11. Theoretically, it would be a good idea to check the streams returned by fdopen() to ensure that the operation did not fail.

12. If the pipe() function fails, you report the error on standard output and then continue as nothing had gone wrong.

13. It is not clear what the racket command actually does. It doesn't exist on my machine.

14. argv in spawnfp() is unused.

15. pid = fork(); if (pidDos < (pid_t) 0) generates a warning (accurately) that pidDos might be used uninitialized. The condition should presumably be using pid, not pidDos. You then send a SIGKILL signal to the PID identified at random by pidDos, which is unlikely to lead to happiness.

When I copy cat to racket and invoke the following code (as a program mk built from mk.c) as mk /etc/passwd, I get to see the password file double-spaced (and the message from the shell about Killed: 9.

#include <math.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

static int read_from_pipe(int file)
{
    int c;
    FILE *stream = fdopen(file, "r");

    if (fscanf(stream, "%d", &c) != 1)
    {
        fprintf(stderr, "Failed to read integer from pipe\n");
        exit(1);
    }
    fclose(stream);
    return c;
}

static void write_to_pipe(int file, int pidRacket)
{
    FILE *stream = fdopen(file, "w");
    fprintf(stream, "%d", pidRacket);
    fclose(stream);
}

static int spawnpipe(char *fileName, int *fd)
{
    int pid;
    int pipe_fds[2];
    char *command[] = {"racket", fileName, NULL};
    if (pipe(pipe_fds) < 0)
    {
        fprintf(stderr, "FE: pipe\n");
        exit(1);
    }

    switch ((pid = fork()))
    {
    case -1:
        printf("syserr");
        exit(1);
    case 0:

        close(1);
        close(2);
        dup(pipe_fds[1]);
        close(pipe_fds[0]);
        close(pipe_fds[1]);
        execvp(*command, command);
        perror("execv");
        exit(EXIT_FAILURE);

    default:
        *fd = pipe_fds[0];
        close(pipe_fds[1]);
        return pid;
    }
}

static int spawnfp(char *fileName, FILE **fpp)
{
    int fd, pid;
    pid = spawnpipe(fileName, &fd);
    *fpp = fdopen(fd, "r");
    return pid;
}

int main(int argc, char *argv[])
{
    pid_t pid;
    int mypipe[2];
    if (pipe(mypipe))
    {
        fprintf(stderr, "Pipe failed.\n");
        return EXIT_FAILURE;
    }

    pid = fork();
    if (pid < (pid_t) 0)
    {
        fprintf(stderr, "Fork failed.\n");
        return EXIT_FAILURE;
    }
    else if (pid != (pid_t) 0)
    {
        double diff = 0;
        clock_t launch = clock();

        close(mypipe[1]);
        int pidRacket = read_from_pipe(mypipe[0]);
        while (diff < 1.3)
        {
            clock_t done = clock();
            diff = ((double)done - (double)launch) / (double)CLOCKS_PER_SEC;
        }
        kill(pidRacket, SIGKILL);
        kill(pid, SIGKILL);
        return EXIT_SUCCESS;
    }
    else if (pid == (pid_t) 0)
    {
        close(mypipe[0]);
        char buf[100];
        FILE *fp;
        char *fileName = argv[1];
        int pidRacket = spawnfp(fileName, &fp);
        write_to_pipe(mypipe[1], pidRacket);

        if (argc == 1)
        {
            printf("Not enough arguments!");
            _exit(EXIT_FAILURE);
        }
        else if (argc == 2)
        {
        }
        sleep(1);
        while (fgets(buf, sizeof buf, fp))
        {
            printf("%s\n", buf);
        }
        fclose(fp);
        kill(pid, SIGKILL);
        return 0;
    }
}

I fixed some, but by no means all, of the issues identified in this revision of the code.

---

Oh, and item 16: the read end of the pipe isn't closed until the third process terminates. You need to pass mypipe[1] to spawnfp(), which needs to relay it to spawnpipe(), and the child created there needs to close the pipe descriptor before executing 'racket'. This is compounded by fscanf() looking for either EOF or a non-digit at the end of the PID it reads from the pipe. You could provide a newline or something at the end and that would also free up the parent process to spin in its timing loop. Since you say racket doesn't terminate, that's why you don't see anything much.

It's easier to paste the whole program again than present the diffs:

#include <assert.h>
#include <math.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

static int read_from_pipe(int file)
{
    int c;
    FILE *stream = fdopen(file, "r");
    assert(stream != 0);

    if (fscanf(stream, "%d", &c) != 1)
    {
        fprintf(stderr, "Failed to read integer from pipe\n");
        exit(1);
    }
    fclose(stream);
    return c;
}

static void write_to_pipe(int file, int pidRacket)
{
    FILE *stream = fdopen(file, "w");
    assert(stream != 0);
    fprintf(stderr, "%d: pidRacket = %d\n", (int)getpid(), pidRacket);
    fprintf(stream, "%d", pidRacket);
    fclose(stream);
}

static int spawnpipe(char *fileName, int *fd, int pfd)
{
    int pid;
    int pipe_fds[2];
    char *command[] = {"racket", fileName, NULL};
    if (pipe(pipe_fds) < 0)
    {
        fprintf(stderr, "FE: pipe\n");
        exit(1);
    }

    switch ((pid = fork()))
    {
    case -1:
        printf("syserr");
        exit(1);
    case 0:

        close(pfd);
        close(1);
        //close(2);
        dup(pipe_fds[1]);
        close(pipe_fds[0]);
        close(pipe_fds[1]);
        execvp(*command, command);
        perror("execv");
        exit(EXIT_FAILURE);

    default:

        fprintf(stderr, "%d: pid = %d\n", (int)getpid(), pid);
        *fd = pipe_fds[0];
        close(pipe_fds[1]);
        return pid;
    }
}

static int spawnfp(char *fileName, FILE **fpp, int pfd)
{
    int fd, pid;
    pid = spawnpipe(fileName, &fd, pfd);
    *fpp = fdopen(fd, "r");
    assert(*fpp != 0);
    return pid;
}

int main(int argc, char *argv[])
{
    pid_t pid;
    int mypipe[2];
    if (pipe(mypipe))
    {
        fprintf(stderr, "Pipe failed.\n");
        return EXIT_FAILURE;
    }

    pid = fork();
    if (pid < (pid_t) 0)
    {
        fprintf(stderr, "Fork failed.\n");
        return EXIT_FAILURE;
    }
    else if (pid != (pid_t) 0)
    {
        double diff = 0.0;
        clock_t launch = clock();

        close(mypipe[1]);
        fprintf(stderr, "%d: Reading from pipe:\n", (int)getpid());
        int pidRacket = read_from_pipe(mypipe[0]);
        fprintf(stderr, "%d: Read PID %d from pipe\n", (int)getpid(), pidRacket);
        while (diff < 1.3)
        {
            clock_t done = clock();
            diff = ((double)done - (double)launch) / (double)CLOCKS_PER_SEC;
            printf("%f\n", diff);
        }
        kill(pidRacket, SIGKILL);
        kill(pid, SIGKILL);
        return EXIT_SUCCESS;
    }
    else if (pid == (pid_t) 0)
    {
        close(mypipe[0]);
        char buf[100];
        FILE *fp;
        char *fileName = argv[1];
        int pidRacket = spawnfp(fileName, &fp, mypipe[1]);
        fprintf(stderr, "%d: Writing PID %d to pipe\n", (int)getpid(), pidRacket);
        write_to_pipe(mypipe[1], pidRacket);
        fprintf(stderr, "%d: Written PID to pipe\n", (int)getpid());

        if (argc == 1)
        {
            printf("Not enough arguments!");
            _exit(EXIT_FAILURE);
        }
        else if (argc == 2)
        {
        }
        sleep(1);
        while (fgets(buf, sizeof buf, fp))
        {
            printf("%s\n", buf);
        }
        fclose(fp);
        fprintf(stderr, "%d: Finished reading from pipe\n", (int)getpid());
        kill(pid, SIGKILL);
        return 0;
    }
}