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

int msg[2];
const int MAX = 100;

int main(int argc, char *argv[]) {

    int master, i, child, num, pid, ppid, counter, loops;
    char buffer[MAX];
    num = atoi(argv[1]);
    loops = atoi(argv[2]);
    counter = 0;

    master = (int)getpid();

    //check num arguments
    if (argc != 4) {
        fprintf(stderr, "%sn", "incorrect # arguments");
    }
    pipe(msg);                      //create pipe
    dup2(msg[0], STDIN_FILENO);     //duplicate pipes
    dup2(msg[1], STDOUT_FILENO);
    close(msg[0]);                  //close ends of pipe
    close(msg[1]);

    //create other processes
    for(i=1; i<num; i++) {
        pipe(msg);                  //create new pipe

        //create new process
        child = fork();             //parent has child id
        pid = (int)getpid();        //has own pid
        ppid = (int)getppid();      //has parent pid

        //if parent, fix output
        if(child > 0){
            dup2(msg[1], STDOUT_FILENO);
        } else {
            dup2(msg[0], STDIN_FILENO);
        }
        close(msg[0]);
        close(msg[1]);
        if(child){
            break;
        }
    }

    //simple output
    fprintf(stderr, "process %d with id %d and parent id %dn", i, pid, ppid);

    //message passing
    //if master, establish trasnfer
    if (pid == master) {
        //parent
        close(msg[0]);  //closes its read end
        char buffer[MAX];
        fprintf(stderr, "Parent: Waiting for inputn");
        while(1) {
            scanf("%s", buffer);
            if (strcmp(buffer, "exit")==0) {
               break;
            }
            write(msg[1], buffer, MAX);
        }
        close(msg[1]);  //closes it write end
    } else {
        //child
        close(msg[1]);  //closes its write end
        char buffer[MAX];
        fprintf(stderr, "Child: Waiting for pipen");
        while(read(msg[0], buffer, MAX) > 0) {
            fprintf(stderr, "Received: %sn", buffer);
            buffer[0] = '';
        }
        close(msg[0]);  //closes its read end
    }

    //special stuff for master node
    if(master == pid){
        fprintf(stderr, "%sn", "i am the master");
        //special stuff
    } else {
        fprintf(stderr, "%sn", "i am a child");
        //nothing really?
    }

    wait(2); //let all processes finish.
    exit(0);
}

if (argc != 4) {
    ...
}

int num = atol(argv[1]);

C:+----------+-----------+
  |          |           |
  | Read End | Write End |
  |          |           |
  +----------+-----------+
         |




P:+----------+-----------+
  |          |           |
  | Read End | Write End |
  |          |           |
  +----------+-----------+      |
       /|                       |
        |                       |
        +-----------------------+

C2:+----------+-----------+
      |          |           |
      | Read End | Write End |
      |          |           |
      +----------+-----------+
             |




   C1:+----------+-----------+      |
      |          |           |      |
      | Read End | Write End |      |
      |          |           |      |
      +----------+-----------+      |
             |                     |
                                   |
                                   |
                                   |
                                   |
    P:+----------+-----------+      |
      |          |           |      |
      | Read End | Write End |      |
      |          |           |      |
      +----------+-----------+      |
           /|                       |
            |                       |
            +-----------------------+

C2:+----------+-----------+
                                     |          |           |
                                     | Read End | WriteEnd3 |
                                     |          |           |
                                     +----------+-----------+
                                             |



   C1:+----------+-----------+       +----------+-----------+ |
      |          |           |       |          |           | |
      | Read End | WriteEnd1 |       | Read End | WriteEnd2 | |
      |          |           |       |          |           | |
      +----------+-----------+       +----------+-----------+ |
             |                          /|                  |
                                         |                  |
                                         +------------------+


    P:+----------+-----------+
      |          |           |
      | Read End | Write End |
      |          |           |
      +----------+-----------+      |
           /|                       |
            |                       |
            +-----------------------+

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

#define BUF_LEN 32

int  input_pipe[2];
int output_pipe[2];

char buf[BUF_LEN];
const char msg[] = "hello world.n";
int str_len = sizeof(msg);

int status;

int main(int argc, char **argv) {
    /* master input channel */
    int master_input;
    int ring_pid = 0;

    if (argc != 2) {
        fprintf(stdout, "Argument error!n");
        fflush(stdout);

        exit(-1);
    }

    int total_processes = atoi(argv[1]);

    if (pipe(input_pipe) || pipe(output_pipe)) {
        fprintf(stdout, "Cannot create pipes at master. Program exits.n");
        fflush(stdout);

        exit(-1);
    } else {
        /* fork child process */
        pid_t pid = fork();
        if (pid) {
            /* dup read end of input pipe and write end of output pipe. */
            int input_fd  = dup(input_pipe[0]);
            int output_fd = dup(output_pipe[1]);

            close(input_pipe[0]);
            close(input_pipe[1]);
            close(output_pipe[0]);
            close(output_pipe[1]);

            /* parent process */
            fprintf(stdout, "Send message to downstream: %s", msg);
            fflush(stdout);
            write(output_fd, msg, str_len + 1);

            read(input_fd, buf, BUF_LEN);
            fprintf(stdout, "Recieve message from upstream: %s", buf);
            fflush(stdout);

            waitpid(pid, &status, 0);
        } else {
            /* child process */
            /* write end of master's input pipe */
            master_input  = dup(input_pipe[1]);

            int input_fd  = dup(output_pipe[0]);
            int output_fd = -1;

            /* increase ring number */
            while (++ring_pid < total_processes) {
                int tmp_pipe[2];

                if (pipe(tmp_pipe)) {
                    fprintf(stdout, "Cannot create pipes at master. Program exits.n");
                    fflush(stdout);

                    exit(-1);
                } else {
                    /* pid of sub-process's child */
                    pid_t spid = fork();
                    if (spid) {
                        /* drop read end of the pipe, we read from parent process */
                        close(tmp_pipe[0]);
                        /* output of last process directs to master's input */
                        if (ring_pid == total_processes - 1) {
                            output_fd = dup(master_input);
                        } else {
                            output_fd = dup(tmp_pipe[1]);
                        }
                        close(tmp_pipe[1]);
                        /* receive and send message */
                        read(input_fd, buf, BUF_LEN);
                        fprintf(stdout, "Read from upstream: %s", buf);

                        fprintf(stdout, "Write to downstream: %s", buf);
                        write(output_fd, buf, BUF_LEN);

                        waitpid(spid, &status, 0);
                        break;
                    } else {
                        /* for child process, the input is read end of the new pipe. */
                        input_fd = dup(tmp_pipe[0]);
                        close(tmp_pipe[0]);
                    }
                }
            }
        }
    }
}

child_pid = fork();
if (child_pid==0) {
  childProcess(); // isolate the child process logic
  _exit(0); // make sure the execution doesn't escape the if statement
}

input(stdin)
   v
+> A -+
|     v
D     B
^     |
+- C <+

#define MAXCHILD 50
#define NO_OF_CHILDREN 20
#define MAXBUF 100

void child(int readend, int writeend);
int main()
{
int pipefd[MAXCHILD + 1][2];
int noofchildren = 0;
int nchild = NO_OF_CHILDREN;
int ret;
int i ;
char buf[MAXBUF];
for(i = 0; i <= nchild; i++)
{
    ret = pipe(pipefd[i]);
    if (0 > ret)
    {
        printf("Pipe Creation failedn");
        exit(1);
    }
}
printf("Pipes createdn");

for(i = 0; i < nchild; i++)
{

    ret = fork();
    if (0 == ret)
    {
        child(pipefd[i][0], pipefd[i + 1][1]);
    }
    //These ends are no longer needed in parent.
    close (pipefd[i][0]);
    close(pipefd[i + 1][1]);
}

printf("%d Children  Createdn", nchild);

while(1)
{
    printf("Enter Some datan");
    //Now the parent/master reads from the standard input
    fgets(buf, MAXBUF, stdin);
    //Write to the pipe which is connected to the first child.
    write(pipefd[0][1],buf, strlen(buf) + 1);
    //Read from the pipe, which is attached to the last child created
    read(pipefd[nchild][0], buf, MAXBUF);
    printf("Master Read from the pipe - %sn", buf);
    if (strcmp(buf, "exitn") == 0)
    {
        break;
    }
}
//By this time all other children, would have exited
//Let's wait to see this
while(1)
{
    ret = wait(NULL);
    if (0 > ret) //Returns -ve when no more child is left.
    {
        break;
    }
    noofchildren++;
}
printf("My %d children terminated! Now I am exiting", noofchildren);
exit(0);
}

void child(int readend, int writeend)
{
char buf[MAXBUF];
int ret;
//set up environment
dup2(readend, 0);
dup2(writeend,1);
while(1)
{
    ret = read(0, buf, MAXBUF );
    if (strcmp(buf, "exitn") == 0)
    {
        write(1, buf, ret);
        exit(0);
    }
    write(1, buf, ret);
}
}