Examples of some illegal operations that may produce runtime errors are:

Dividing a number by zero
Trying to open a file which is not created
Lack of free memory space

It should be noted that occurrence of these errors may stop program execution, thus to encounter this, a program should be written such that it is able to handle such unexpected errors and rather than terminating unexpectedly, it should be able to continue operating. This ability of the program is known as robustness and the code used to make a program robust is known as guard code as it guards program from terminating abruptly due to occurrence of execution errors.

if(ch==EOF)
{
printf(“try again\n”);
printf(“enter the password”);
scanf(“%s”,pwd);
if(j==2)
{
printf(“\nyou have tried maximum time.\nyour password is blocked\n”);
return (-1);
}
}
}
return 0;
}

int main()
{
int ret,len,sum,sub,n;
int r11[2];
int r12[2];
int r21[2];
int r22[2];
int p11[2];
int p12[2];
int p21[2];
int p22[2];
struct req rq;
char br11[4],br12[4],br21[4],br22[4],bp11[4],bp12[4],bp21[4],bp22[4];
ret=pipe(r11);
ret=pipe(r21);
ret=pipe(r22);
ret=pipe(r12);
ret=pipe(p11);
ret=pipe(p21);
ret=pipe(p22);
ret=pipe(p12);
ret=fork();
if(ret == 0)
{
sprintf(br11,”%d”,r11[1]);
sprintf(br12,”%d”,r12[0]);
execl(“./rq1″,”./rq1″,br11,br12,NULL);
}
else
{
len=sizeof(struct req);
read(r11[0],&rq,len);
printf(“rq.a=%d\nrq.b=%d\nrq.c=%c\n”,rq.a,rq.b,rq.opr);
ret=fork();
if(ret == 0)
{
sprintf(bp11,”%d”,p11[0]);
sprintf(bp12,”%d”,p12[1]);
execl(“./pq1″,”./pq1″,bp11,bp12,NULL);
}
else
{
write(p11[1],&rq,len);
read(p12[0],&sum,4);
printf(“\nserver ….sum =%d\n”,sum);
}
ret=write(r12[1],&sum,4);
printf(“written for server at rq1=%d”,ret);
ret=fork();
if(ret==0)
{
sprintf(br21,”%d”,r21[1]);
sprintf(br22,”%d”,r22[0]);
execl(“./rq2″,”./rq2″,br21,br22,NULL);
}
else
{
len=sizeof(struct req);
read(r21[0],&rq,len);
printf(“rq.a=%d\nrq.b=%d\nrq.c=%c\n”,rq.a,rq.b,rq.opr);
ret=fork();
if(ret == 0)
{
sprintf(bp21,”%d”,p21[0]);
sprintf(bp22,”%d”,p22[1]);
execl(“./pq2″,”./pq2″,bp21,bp22,NULL);
}
else
{
write(p21[1],&rq,len);
read(p22[0],&sub,4);
printf(“\nserver ….sub =%d\n”,sum);
ret=write(r22[1],&sub,4);
}
}
return 0;
}
}

int main()
{
int r1,p1,ret,len;
struct req res;
ret=access(“rq1″,F_OK);
if(ret <0)
{
ret=mkfifo(“rq1″,0777);
if(ret<0)
{
perror(“mkfifo”);
return -1;
}
}
ret=access(“rq2″,F_OK);
if(ret <0)
{
ret=mkfifo(“rq2″,0777);
if(ret<0)
{
perror(“mkfifo”);
return -1;
}
}
ret=access(“rq3″,F_OK);
if(ret <0)
{
ret=mkfifo(“rq3″,0777);
if(ret<0)
{
perror(“mkfifo”);
return -1;
}
}
ret=access(“pq1″,F_OK);
if(ret <0)
{
ret=mkfifo(“pq1″,0777);
if(ret<0)
{
perror(“mkfifo”);
return -1;
}
}
ret=access(“pq2″,F_OK);
if(ret <0)
{
ret=mkfifo(“pq2″,0777);
if(ret<0)
{
perror(“mkfifo”);
return -1;
}
}
ret=access(“pq3″,F_OK);
if(ret <0)
{
ret=mkfifo(“pq3″,0777);
if(ret<0)
{
perror(“mkfifo”);
return -1;
}
}
/////1st requesting client//////////////////
r1=open(“rq1″,O_RDONLY);
len=sizeof(struct req);
ret=read(r1,&res,len);

printf(“res.a=%d\nres.b=%d\nres.opr=%c\n”,res.a,res.b,res.opr);
///////1st processing client/////////////////
p1=open(“pq1″,O_WRONLY);
write(p1,&res,len);
close(p1);
p1=open(“pq1″,O_RDONLY);
read(p1,&res,len);
printf(“at server sum is = %d\n”,res.result);
close(r1);
r1=open(“rq1″,O_WRONLY);
write(r1,&res,len);
/////2nd requesting client//////////////////
close(r1);
r1=open(“rq1″,O_RDONLY);
len=sizeof(struct req);
ret=read(r1,&res,len);
printf(“ret =%d\n”,ret);

printf(“res.a=%d\nres.b=%d\nres.opr=%c\n”,res.a,res.b,res.opr);

A linked list is a dynamic data structure. The number of nodes in a list is not fixed and can grow and shrink on demand. Any application which has to deal with an unknown number of objects will need to use a linked list.

One disadvantage of a linked list against an array is that it does not allow direct access to the individual elements. If you want to access a particular item then you have to start at the head and follow the references until you get to that item.

Another disadvantage is that a linked list uses more memory compare with an array – we extra 4 bytes (on 32-bit CPU) to store a reference to the next node.

else
{
if(masterarr[j]==arr[i])
break;

}

}

}
printf(“masterarr=%s\n”,masterarr);
return 0;
}