Question

Write code that forks into two processes: a parent process, and a child process.
Your code will be called with command-line arguments consisting of negative
integers. Do not worry about bad command-line arguments such as "xyz". Your code
will not be tested in this way.

The parent process will take the arguments to main(), convert them into ints by
calling atoi(), and send those ints one at a time to the child process through
a pipe (one call to write() for each int).

Do not send anything from argv[0] through the pipe. Start with argv[1] and
continue through the rest of the arguments.

The child process will read the ints sent by the parent process one at a
time, and add them up. The child process should not use the arguments to main(),
argc and argv, in any way whatsoever. The child process will communicate the sum
of the numbers to the parent as the return value from main().

The parent process will need to reap the child process to find out that sum.

It may be of use to know that read() will return immediately with a zero once
the other end of the pipe is closed by the parent.

your code must be able to handle negative integers input from the command-line.

If I call your code this way:

a03 -3 5 -7

The parent process should print out:

dl200 - Assignment - I.
sum = -5

The sums produced from the test input I use will be in the range [-128 .. 127].

the code c file

// Numbers from command line arguments are sent to child process
// from parent process one at a time through pipe.
//
// Child process adds up numbers sent through pipe.
//
// Child process returns sum of numbers to parent process.
//
// Parent process prints sum of numbers.

#include <stdio.h>

int main(int argc, char **argv)
{
// set up pipe

// call fork()

printf("dl200 - Assignment - I ");

if (0 /* replace 0 with test for parent vs child, delete this comment */) {
// -- running in child process --
int sum = 0;

// Receive numbers from parent process via pipe
// one at a time, and count them.

// Return sum of numbers.
return sum;
}
else {
// -- running in parent process --
int sum = 0;

// Send numbers (datatype: int, 4 bytes) from command line arguments
// starting with argv[1] one at a time through pipe to child process.

// Wait for child process to return. Reap child process.
// Receive sum of numbers via the value returned when
// the child process is reaped.
printf("sum = %d\n", sum);
return 0;
}
}

Answer 1

Do like and comment if you have any queries.

code to copy:

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

   int main(int argc, char *argv[])
   {
       int pipe_Descriptor[2]; //pipe desciptors
       pid_t pID; //pID
       // create pipe descriptors
       pipe(pipe_Descriptor);
       pID=fork() ; //fork the process
       if(pID==0)
       {
           //child process
           int n,args[100],args_Sum=0;
           //reading from pipe ,its a blocking process
           read(pipe_Descriptor[0],&n,sizeof(n)); //reading n from pipe
           int i;
           for(i=0;i<n;i++) //read n elements from pipe
           {
               int y;
               read(pipe_Descriptor[0],&y,sizeof(y)); //read
               args[i]=y; //store in array
           }
           for (i = 0; i < (n); ++i)
           {
               args_Sum+= args[i]; //calculate the Sum
           }
           write(pipe_Descriptor[1],&args_Sum,sizeof(args_Sum)); //send the Sum to parent process
           exit(0); //exit
       }
       else
       {
           //parent process
           int args[100],args_Sum; //array to hold command line arguments
           int i;
           //int n=*(argv[1])-'0';
           if(argc<2)
           {
               printf("Enter number of elements and values: \n");
               return 0;
           }
           int n = atoi(argv[1]); //read no of elements
           //argv[0] stands for program name
           for(i=0;i<(n);i++)
           {
               args[i] = atoi(argv[i+2]); //read each element and store in array
           }
           write(pipe_Descriptor[1],&n, sizeof(n)); //write n
           for(i=0;i<n;i++)
           {
               int x = args[i];
               write(pipe_Descriptor[1],&x, sizeof(x)); //write n values
           }
           //wait for child process to return
           wait(NULL);
           //read Sum
           read(pipe_Descriptor[0],&args_Sum,sizeof(args_Sum));
           //print Sum
           printf("Sum = %d \n",args_Sum );
       }
   }

Output Screenshot:

Code Screenshot: