// file: h1.c
// Comp.Sys.Org.II, Spring 2005, Tracy Kapp.
// GCD program using processes
//
#include <sys/types.h> 
#include <errno.h>
#include <sys/wait.h> 
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h> 
#include <math.h>

 
extern int errno;     /* system error number */
 
void syserr(char* );  /* error report, abort routine */ 

int terms;
int par2child[50][2]; /* Parent can write to child pipe */
int child2par[50][2]; /* Child can write to parent pipe */

 int main(int argc, char *argv[])
{
    char buf[1024];
    int index = 1, m, n, i;

    terms = (argc - 1)/2:

    signal(SIGUSR1, int_handler);
    int parent_id = getid();

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

m = atoi(argv[2*i +1]);
n = atoi(argv[2*i +2]);

        /* Open pipes */
        if (pipe(par2child[i]) == -1 || pipe(child2par[i]) == -1)
        {
            perror("pipe");
            exit(1);
        } else {
            set_fl(child2par[i][0], O_NONBLOCK);
}

switch(fork()){
         case -1:
          perror("fork");
          exit(1);
          break;
         case 0: //parent
          close(par2child[i][0]);
          close(child2par[i][1]);
          break;
         default: //child
          close(par2child[i][1]);
          close(child2par[i][0]);

         sleep(1); // remove this if you don't need it...

         while (n>0) {
                // 1. write m, n to pipe
				fprintf(child2par[i][1], "m = %d, n = %d\n",m,n);
                // 2. signal parent
                kill(parent_id, SIGUSR1);
                // 3. read from parent
				read(par2child[i][0],buf,1024);
         }//while
         printf("gcd=%d\n", m);
         //kill(parent_id, SIGUSR2);
         exit(0)
          break;

}//switch

    }//for

    for (i=0; i< terms; i++)
     wait(0);

    
    return 0;
}//main

//////////////////////////////////////////////////
// Clear buffer
//////////////////////////////////////////////////
void clearbuf(char *){
  int i;
  for (i=0; i<1024; i++)
   char[i]='\0';
}

//////////////////////////////////////////////////
// interrupt handler
//////////////////////////////////////////////////

void int_handler(int sig)
{
int m,n,ans, count;
signal(SIGUSR1, int_handler); //reset the signal handler

for(int i=0; i<terms; i++)
{
          clearbuf(buf);
          count=read(child2par[i][0],buf,1024);
          if (count>0) {
           sscanf(buf,"%d %d", &m, &n);
		   ans = m%n;
		   //write back the answer to "m%n"
		   fprintf(par2child[i][1],"n = %d,ans = %d\n",n ,ans); 
         return(0);
          }//if
         }//for
}//int_handler

///////////////////////////////////////////////////
// nonblock.c
///////////////////////////////////////////////////
void
set_fl(int fd, int flags) // flag=file status flags to turn on
{
	int val;
	if ((val = fcntl(fd, F_GETFL, 0)) < 0)
		perror("fcntl F_GETFL error");
	val |= flags;	// turn on flags
	if (fcntl(fd, F_SETFL, val)<0)
		perror("fcntl F_SETFL error");
}