RCS file: server.c,v
Working file: server.c
head:
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 0
description:
Made a server file which takes request from client and forwards it to processing client
Then it takes result from processing client and gives the result back to the requesting client
the requesting client is given a pid to which server returns his answer.
=============================================================================

RCS file: script,v
Working file: script
head:
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 0
description:
this is the script file which is made to execute all the files at once.
total 5 fifos are used and one semaphore is used in the server.
=============================================================================

RCS file: client.c,v
Working file: client.c
head:
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 0
description:
The client sends the request using command line arguments
and at the finishing end it reads the result back from the server.
=============================================================================

RCS file: add.c,v
Working file: add.c
head:
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 0
description:
processing client adds the two files after reading values from server
and writes back the result to the server
=============================================================================

RCS file: sub.c,v
Working file: sub.c
head:
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 0
description:
thats another processing client
it subtracts the two values
=============================================================================

RCS file: mul.c,v
Working file: mul.c
head:
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 0
description:
its function is also same as other processing clients but it multiplies them.
=============================================================================

RCS file: add.c,v
Working file: add.c
head:
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 0
description:
made the file for adding
will be exexuted from server through the pipe.
=============================================================================

RCS file: sub.c,v
Working file: sub.c
head:
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 0
description:
made the file for subtracting
will be executed from server through the pipe
=============================================================================

RCS file: mul.c,v
Working file: mul.c
head:
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 0
description:
similar function except this will multiply.
=============================================================================

RCS file: header.h,v
Working file: header.h
head:
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 0
description:
made the header file
included 5 header files
=============================================================================

printf(“\n+++++++++MENU+++++++++\n”);
printf(“1.CREATE NODE\n”);
printf(“2.INSERT\n”);
printf(“3.DELETE\n”);
printf(“4.DISPLAY\n”);
printf(“0.EXIT\n”);
printf(“enter your choice”);
scanf(“%d”,&choice);
get_choice(&choice);
}}
int get_choice(int *choice)
{
switch(*choice)
{
case 1:create_node();break;
case 2:enqueue();break;
case 3:dequeue();break;
case 4:display();break;
case 0:exit(0);
}}
int create_node()
{
if(flag==0)
{
printf(“queue created\n”);
flag++;
}
else if(flag>=1)
{
printf(“queue already created\n”);
}

}
int enqueue()
{
struct node*temp;
temp=(struct node*)malloc(10*sizeof(struct node*));

if(flag==0)
{
printf(“create a queue first\n”);
return 0;
}
else if(flag==1)
{
printf(“enter the values\n”);
scanf(“%d”,&(temp->val));
temp->next=NULL;
start=rear=temp;
}
if(flag>1)
{
printf(“enter the values!\n”);
scanf(“%d”,&(temp->val));
temp->next=NULL;
rear->next=temp;
rear=rear->next;

}
if(flag>5)
{

printf(“queue is full\n”);
return 0;
}
flag++;
display();
}
int dequeue()
{
struct node*temp,*temp1;
{
if(flag==0)
printf(“create a queue first\n”);

else if(flag==1)
{
printf(“queue is empty\n`”);

}
if(!front )
{
temp=start;
front=start->next;
printf(“%d is popped\n”,temp->val);
free(temp);

}
else if(front)
{
temp=front;
front=front->next;
printf(“%d is popped\n”,temp->val);
free(temp);
printf(“\n%d”,flag);
flag–;
}

display();

}}
int display()
{
struct node*temp;

if(flag==0)
{
printf(“nothing to display\n”);
}
else if(flag>=1)
{
if(!front)
{
temp=start;
}
else
{
temp=front;
}
while(temp)
{
printf(” %d–”,temp->val);
temp = temp->next;
}
}}

while (choice)
{
printf(“+++++++++++++++++++MENU++++++++++++++++++++++\n                “);
printf(”                1.CREATE NODE                \n                “);
printf(”                2.ENQUEUE                    \n                “);
printf(”                3.DEQUEUE                    \n                “);
printf(”                4.DISPLAY                    \n                “);
printf(”                0.EXIT                       \n                “);
printf(“enter your choice\n”);
scanf(“%d”,&choice);
get_choice(&choice);
}}
int get_choice(int*choice)
{
switch(*choice)
{
case 1:create_node();break;
case 2:enqueue();break;
case 3:dequeue();break;
case 4:display();break;
case 0:exit(0);break;
}}
int create_node()
{
if(flag==0)
{
front=NULL;
rear=NULL;
printf(“queue created successfully”);
flag++;
}
else if(flag==1)
{
printf(“queue already created”);
}
}
int enqueue()
{
struct node*temp;
int i;
temp=(struct node*)malloc(sizeof(struct node));

if(flag==0)
{
printf(“queue not created\n”);
return 0;
}
else if(flag>5)
{
printf(“queue is full\n”);
return 0;
}
if(flag == 1)
{

printf(“enter the value to insert\n”);
scanf(“%d”,&(temp->val));
temp->next=NULL;
start=rear=temp;
flag++;
}
else if(flag>1 && flag!=1)
{
printf(“enter value”);
scanf(“%d”,&(temp->val));
temp->next=NULL;
rear->next=temp;
rear=rear->next;
flag++;
}

printf(“element inserted %d\n”,flag);

display();

}
int dequeue()
{
struct node*temp;
i:    if(flag == 0 )
{
printf(“queue empty\n”);
return 0;
}
if(front == rear)
{
goto o;
}
if(!front)
{
front=start->next;
printf(“%d is dequed\n”,start->val);

}
else if(front)
{
temp=front;
front=front->next;
printf(“%d is dequed\n”,temp->val);
}
else if(front == rear && front->next==NULL)
{

o:    printf(“%d is dequed\n”,front->val);
printf(“queue empty\n”);
front->next=NULL;
rear=front=start->next=NULL;
flag =0;
goto i;
}

display();

}
int display()
{
struct node*temp;
if(flag==0)
{    printf(“create a queue first\n”);
return 0;
}
if(!front)
temp = start;
else
temp = front;
while(temp!=NULL)
{
printf(“<-%d”,(temp)->val);
temp=temp->next;

}
printf(“\n”);

}