How to Create IPC (Interprocess Communication) C programme to create with two child process

Question

I want to create a IPC c program to create one parent and two child's processes. My code is:

#include <stdio.h>
void main()
{
    int pid, status;
    pid = fork();
    if(pid == -1) {
        printf(“fork failed\n”);
        exit(1);
    }
    if(pid == 0) { /* Child */
        if (execlp(“/bin/ls”, “ls”, NULL)< 0) {
            printf(“exec failed\n”);
            exit(1);
        }
    }
    else { /* Parent */
        wait(&status);
        printf(“Well done kid!\n”);
        exit(0);
    }
}

I want to show you an other code snippet to create one parent and two child process. This is what I am looking for. Now I want to write shell script for IPC, first take look of this code.

Note: there is an other code with same logic but different process names UP, uc1, uc2 e.g in this way we have two parent VP and UC and there childs vp1 vp2 and uc1 uc2.

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#define MAX_BUF 1024

int main(){

int mypipe_c1[2];
int ret_c1;
char buf_c1[6];

ret_c1 =pipe(mypipe_c1);

int mypipe_c2[2];
int ret_c2;
char buf_c2[6];

ret_c2 =pipe(mypipe_c2); 

if(ret_c1 == -1)
{
    perror("pipe");
    exit(1);
}

pid_t vc1;


pid_t vc2; 

  vc1 = fork ();
  if (vc1 == 0)
  {
read(mypipe_c1[0], buf_c1 , 37);
        printf("PIPE1 :%s\n", buf_c1);
    printf (" vc1 : I'm the child!  My pid is (%d)\n", getpid ());
close(ret_c1);

int fd;
    char * fifo1 = "/tmp/fifo1";
    char buf[MAX_BUF];

    /* open, read, and display the message from the FIFO */
    fd = open(fifo1, O_RDONLY);
    read(fd, buf, MAX_BUF);
    printf("FIFO1: %s\n", buf);
    close(fd);
exit(0);
  }
  if(vc1 < 0)
  {
    perror ("Ouch!  Unable to fork() child process!\n");
    exit (1);
  }

 vc2 = fork ();
   if (vc2 == 0)
  {
    printf ("vc2 : I'm the child!  My pid is (%d)\n", getpid ());
read(mypipe_c2[0], buf_c2 , 37);
   printf("PIPE2 %s\n", buf_c2);

int fd;
    char * fifo2 = "/tmp/fifo2";

    /* create the FIFO (named pipe) */
    mkfifo(fifo2, 0666);

    /* write "Hi" to the FIFO */
    fd = open(fifo2, O_WRONLY);
    write(fd, " assignment VU 2 ", sizeof(" assignment VU 2 "));
    close(fd);

    /* remove the FIFO */
    unlink(fifo2);
exit(0);
  }
  else if (vc2 < 0)
  {
    perror ("Ouch!  Unable to fork() child process!\n");
    exit (1);
  }
printf ("I'm the parent! My pid is  (%d)!\n",getpid());
write(mypipe_c1[1], "I am going to close you carry on UC1 \n", 37);
write(mypipe_c2[1], "I am going to close you carry on UC2 \n", 37);

exit(0);
}

Now I want shell script such that VP and UP should be started when users types … script.sh start VP or UP. vc1, vc2, uc1,uc2 should be stoppable only using script.sh stop vc1 or vc2 or uc1 or uc2

script.sh connect command should create two fifo and connect processes as shown in figure.

Answer 1

So you are asking for methods for IPC, with the sample code you provided, I think the best one is the use of pipes.

From the pipe() man page:

A pipe is a unidirectional data channel that can be used for interprocess communication

Basically, it is handled like a pair of file descriptors. First, you must init the pipe, and then create the childs using the fork() call, so both parents and childs share the resource. Then, using write and read methods, you can send data between them.

In this example I create a child which reads some data from the parent process:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main() {
    int pid;
    char buffer[255];
    int fd[2]; // channel 0 for reading and 1 for writing
    pipe(fd);
    pid = fork();
    if(pid == 0) {
        close(fd[1]); // close fd[1] since child will only read
        read(fd[0], &buffer, sizeof(buffer));
        close(fd[0]);
        exit(0);
    } else { // parent
        close(fd[0]) // close fd[0] since parent will only write
        // init buffer contents
        write(fd[1], &buffer, sizeof(buffer));
        close(fd[1]);
    }
    return 0;
}

As you can see pipe creates a pair of file descriptors, one for writing (number 1) and one for reading (number 0).

In my sample code, the child process closes the writing one, since it will only read, and the parent closes the reading one, since it will only write data.

Note that pipes are unidirectional, so if you want that both the childs and the parent write and read data from it, you should create two pipes (so 4 file descriptors) for each of the childs. An example of how to handle that situation:

int pipeA[2], pipeB[2];
pid = fork();
if (pid == 0) { // child will write to pipeB and read from pipeA
    close(pipeA[1]); // closing pipeA writing fd
    close(pipeB[0]); // closing pipeB reading fd
    write(pipeB[1],&buffer, sizeof(buffer));
    read(pipeA[0], &buffer2, sizeof(buffer2));
    close(pipeA[0]);
    close(pipeB[1]);
    exit(1);
} else { // parent will write to pipeA and read from pipeB
    close(pipeA[0]); // closing pipeA reading fd
    close(pipeB[1]); // closing pipeB writing fd
    read(pipeB[0], &buffer, sizeof(buffer));
    write(pipeA[1], &buffer2, sizeof(buffer2));
    close(pipeA[1]);
    close(pipeB[0]);
}

If you want more info about pipes you can check the man page here.

Also, other simple ways of IPC would be the use of Unix Sockets, although I think that for the example you presented pipes will be enough.

Answer 2

You'r code create one parent and one child, not two child, so you need to add another fork into child block :

#include <stdio.h>
void main()
{
    int pid,status;
    pid = fork();
    if(pid == -1) {
        printf(“fork failed\n”);
        exit(1);
    }
    if(pid == 0) { /* Child */
        fork();// another child
        if (execlp(“/bin/ls”, “ls”, NULL)< 0) {
            printf(“exec failed\n”);
            exit(1);
        }
    }
    else { /* Parent */
        wait(&status);
        printf(“Well done kid!\n”);
        exit(0);
    }
}