1.Implement the following forms of IPC.

a) Pipes
One way communication in one process
#include<stdio.h>
#include<stdlib.h>
main()
{
int pipefd[2],n;
char buff[100];
pipe(pipefd);
printf("\n readfd= %d", pipefd[0]);
printf("\n writefd= %d", pipefd[1]);
write(pipefd[1],"Hello World",12);
n=read(pipefd[0],buff, sizeof(buff));
printf("\n Size of the data %d",n);
printf("\n data from pipe: %s",buff);
}

OUTPUT :

One way communication in between two process

#include<stdio.h>
#include<stdlib.h>
main()
{
int pipefd[2],n,pid;
char buff[100];
pipe(pipefd);
printf("\n readfd=%d",pipefd[0]);
printf("\n writefd=%d",pipefd[1]);
pid=fork();
if(pid==0)
{
close(pipefd[0]);
printf("\n child proceesing sending data");
write(pipefd[1],"helloworld",12);
}
else
{
close(pipefd[1]);
printf("parent process receives data\n");
n=read(pipefd[0],buff,sizeof(buff));
printf("\n size of the data %d",n);
printf("\n data received from child through pipe:%s \n",buff);
}
}

OUTPUT :
Two way communication in between two process
#include<stdio.h>
#include<stdlib.h>
main()
{
int p1[2],p2[2],n,pid;
char buff1[25],buff2[25];
pipe(p1);
pipe(p2);
printf("\n readfds=%d%d \n",p1[0],p2[0]);
printf("\n writefds=%d%d \n",p1[1],p2[1]);
pid=fork();
if(pid==0)
{
close(p1[0]);
printf("\n child processing sendin data\n");
write(p1[1],"adity pg college",25);
close(p2[1]);
read(p2[0],buff1,25);
printf("reply from parent:%s \n",buff1);
sleep(2);
} else
{
close(p1[1]);
printf("\n parent process receives data \n");
n=read(p1[0],buff2,sizeof(buff2));
printf("\n data received from child through pipe:%s \n",buff2);
sleep(3);
close(p2[0]);
write(p2[1],"in kakinada",25);
printf("\n reply send \n");
}}

OUTPUT :
b) FIFO
Write a program to demonstrate inter process communication through
fifo between client and server
Server program
#include<stdio.h>
#include<ctype.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdlib.h>
#include<string.h>
main()
{
int wrfd,rdfd,n,d,ret_val,count;
char buf[50];
ret_val=mkfifo("np1",0666);
ret_val=mkfifo("np2",0666);
rdfd=open("np1",O_RDONLY);
wrfd=open("np2",O_WRONLY);
n=read(rdfd,buf,50);
buf[n]='\0';
printf("full duplex server:read from the pipe:%s\n",buf);
count=0;
while(count<n)
{
buf[count]=toupper(buf[count]);
count++;
}
write(wrfd,buf,strlen(buf));
}

OUTPUT :
Client Program
#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
main()
{
int wrfd,rdfd,n;
char buf[50],line[50];
wrfd=open("np1",O_WRONLY);
rdfd=open("np2",O_RDONLY);
printf("enter line of text");
write(wrfd,line,strlen(line));
n=read(rdfd,buf,50);
buf[n]='\0';
printf("full duplex client:read from the pipe:%s\n",buf);
}

OUTPUT :
 2.Implement file transfer using Message Queue form of IPC.

Server Program
#include<stdio.h>
#include<ctype.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdlib.h>
#include<string.h>
main()
{
int wrfd,rdfd,n,d,ret_val,count;
char buf[50];
ret_val=mkfifo("np1",0666);
ret_val=mkfifo("np2",0666);
rdfd=open("np1",O_RDONLY);
wrfd=open("np2",O_WRONLY);
n=read(rdfd,buf,50);
buf[n]='\0';
printf("full duplex server:read from the pipe:%s\n",buf);
count=0;
while(count<n)
{
buf[count]=toupper(buf[count]);
count++;
}
write(wrfd,buf,strlen(buf));
}

OUTPUT :

Client Program
#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
main()
{
int wrfd,rdfd,n;
char buf[50],line[50];
wrfd=open("np1",O_WRONLY);
rdfd=open("np2",O_RDONLY);
printf("enter line of text");
write(wrfd,line,strlen(line));
n=read(rdfd,buf,50);
buf[n]='\0';
printf("full duplex client:read from the pipe:%s\n",buf);
}
OUTPUT :

3.Write a Program to create an integer variable using Shared

Memory concept and increment the variable simultaneously
by two processes. Use Semaphores to avoid Race conditions.
#include<sys/stat.h>
#include<stdio.h>
#include<sys/types.h>
#include<sys/shm.h>
#include<sys/ipc.h>
#include<sys/sem.h>
#include<string.h>
#define SIZE 10
int *integer=0;
main()
{
int shmid;
key_t key_10;
char *shm;
int semid,pid;
shmid=shmget((key_t)10,SIZE,IPC_CREAT|0666);
shm=shmat(shmid,NULL,0);
semid = semget(0X20,1,IPC_CREAT|0666);
integer=(int *)shm;
pid=fork();
if(pid==0)
{
int i=0;
while(i<10)
{
sleep(2);
printf("\n child process use shared memory");
accessmem(semid);
i++;
}
}
else
{
int j=0;
while(j<10)
{
sleep(j);
printf("\n parent versus shared memory");
accessmem(semid);
j++;
}
}
shmctl(semid,IPC_RMID,0);
}
int accessmem(int semid)
{
struct sembuf sop;
sop.sem_num=0;
sop.sem_op=-1;
sop.sem_flg=0;
semop(semid,&sop,1);
(*integer)++;
printf("\t integer variable=%d",(*integer));
sop.sem_num=0;
sop.sem_op=1;
sop.sem_flg=0;
semop(semid,&sop,1);
}

OUTPUT :
 4. Design TCP iterative Client and Server application to
reverse the given input sentence.

Server Program
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<sys/types.h>
#define MAXLINE 20
#define SERV_PORT 5777
main(int argc,char *argv)
{
int i,j;
ssize_t n;
char line[MAXLINE],revline[MAXLINE];
int listenfd,connfd,clilen;
struct sockaddr_in servaddr,cliaddr;
listenfd=socket(AF_INET,SOCK_STREAM,0);
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_port=htons(SERV_PORT);
bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
listen(listenfd,1);
for( ; ; )
{
clilen=sizeof(cliaddr);
connfd=accept(listenfd,(struct sockaddr*)&cliaddr,&clilen);
printf("connect to client");
while(1)
{
if((n=read(connfd,line,MAXLINE))==0)
break;

line[n-1]='\0';
j=0;
for(i=n-2;i>=0;i--)
revline[j++]=line[i];
revline[j]='\0';
write(connfd,revline,n);
}
}
}

OUTPUT :

Client Program
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<sys/types.h>
#define MAXLINE 20
#define SERV_PORT 5777
main(int argc,char *argv)
{
char sendline[MAXLINE],revline[MAXLINE];
int sockfd;
struct sockaddr_in servaddr;
sockfd=socket(AF_INET,SOCK_STREAM,0);
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_port=ntohs(SERV_PORT);
connect(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
printf("\n enter the data to be send");
while(fgets(sendline,MAXLINE,stdin)!=NULL)
{
write(sockfd,sendline,strlen(sendline));
printf("\n line send");
read(sockfd,revline,MAXLINE);
printf("\n reverse of the given sentence is : %s",revline);
printf("\n");
}
exit(0);
}

OUTPUT :
5.Design TCP client and server application to transfer file
Server program:
#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<sys/types.h>
#define SERV_PORT 5576
main(int argc,char **argv)
{
int i,j; ssize_t n;
FILE *fp; char s[80],f[80];
struct sockaddr_in servaddr,cliaddr;
int listenfd,connfd,clilen;
listenfd=socket(AF_INET,SOCK_STREAM,0);
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_port=htons(SERV_PORT);
bind(listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr));
listen(listenfd,1);
clilen=sizeof(cliaddr);
connfd=accept(listenfd,(struct sockaddr*)&cliaddr,&clilen);
printf("\n clinet connected");
read(connfd,f,80);
fp=fopen(f,"r");
printf("\n name of the file: %s",f);
while(fgets(s,80,fp)!=NULL)
{ printf("%s",s);
write(connfd,s,sizeof(s));
}}

OUTPUT :
Client Program :
#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<sys/types.h>
#define SERV_PORT 5576
main(int argc,char **argv)
{
int i,j;
ssize_t n;
char filename[80],recvline[80];
struct sockaddr_in servaddr;
int sockfd;
sockfd=socket(AF_INET,SOCK_STREAM,0);
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_port=htons(SERV_PORT);
inet_pton(AF_INET,argv[1],&servaddr.sin_addr);
connect(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
printf("enter the file name");
scanf("%s",filename);
write(sockfd,filename,sizeof(filename));
printf("\n data from server: \n");
while(read(sockfd,recvline,80)!=0)
{
fputs(recvline,stdout);
}
}

OUTPUT :

6. Design a TCP concurrent server to convert a given text into

upper case using multiplexing system call “select”.

Server Program
#include<stdio.h>
#include<netinet/in.h>
#include<sys/types.h>
#include<string.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<sys/select.h>
#include<unistd.h>
#define MAXLINE 20
#define SERV_PORT 7134
main(int argc,char **argv)
{
int i,j,maxi,maxfd,listenfd,connfd,sockfd;
int nread,client[FD_SETSIZE];
ssize_t n;
fd_set rset,allset;
char line[MAXLINE];
socklen_t clilen;
struct sockaddr_in cliaddr,servaddr;
listenfd=socket(AF_INET,SOCK_STREAM,0);
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_port=htons(SERV_PORT);
bind(listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr));
listen(listenfd,1);
maxfd=listenfd;
maxi=-1;
for(i=0;i<FD_SETSIZE;i++)
client[i]=-1;
FD_ZERO(&allset);
FD_SET(listenfd,&allset);
for(; ;)
{
rset=allset;
nread=select(maxfd+1,&rset,NULL,NULL,NULL);
if(FD_ISSET(listenfd,&rset))
{
clilen=sizeof(cliaddr);
connfd=accept(listenfd,(struct sockaddr*)&cliaddr,&clilen);
for(i=0;i<FD_SETSIZE;i++)
if(client[i]<0)
{
client[i]=connfd; break;
}
if(i==FD_SETSIZE)
{
printf("too many clients");
exit(0);
}
FD_SET(connfd,&allset);
if(connfd>maxfd) maxfd=connfd;
if(i>maxi)
maxi=i;
if(--nread<=0) continue;
}
for(i=0;i<=maxi;i++)
{
if((sockfd=client[i])<0) continue;
if(FD_ISSET(sockfd,&rset))
{
if((n=read(sockfd,line,MAXLINE))==0)
{
close(sockfd);
FD_CLR(sockfd,&allset);
client[i]=-1;
}
else
{
printf("line recieved from the client :%s\n",line);
for(j=0;line[j]!='\0';j++) line[j]=toupper(line[j]);
write(sockfd,line,MAXLINE);
}
if(--nread<=0) break;
}
}
}
}
OUTPUT :

Client Program :
#include<netinet/in.h>
#include<sys/types.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/socket.h>
#include<sys/select.h>
#include<unistd.h>
#define MAXLINE 20
#define SERV_PORT 7134
main(int argc,char **argv)
{
int maxfdp1;
fd_set rset;
char sendline[MAXLINE],recvline[MAXLINE];
int sockfd;
struct sockaddr_in servaddr;
if(argc!=2)
{
printf("usage tcpcli <ipaddress>");
return;
}
sockfd=socket(AF_INET,SOCK_STREAM,0);
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_port=htons(SERV_PORT);
inet_pton(AF_INET,argv[1],&servaddr.sin_addr);
connect(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
printf("\n enter data to be send");
while(fgets(sendline,MAXLINE,stdin)!=NULL)
{
write(sockfd,sendline,MAXLINE);
printf("\n line send to server is %s",sendline);
read(sockfd,recvline,MAXLINE);
printf("line recieved from the server %s",recvline);
}
exit(0);
}

OUTPUT :
7. Design UDP Client and server application to reverse the
given input sentence
Server Program
#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<sys/types.h>
#include<stdlib.h>
#define SERV_PORT 5839
#define MAXLINE 20 main(int argc,char **argv)
{
int i,j; ssize_t n;
char line[MAXLINE],recvline[MAXLINE];
struct sockaddr_in servaddr,cliaddr;
int sockfd,clilen;
sockfd=socket(AF_INET,SOCK_DGRAM,0); bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET; servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
servaddr.sin_port=htons(SERV_PORT);
bind(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
for( ; ; )
{
clilen=sizeof(cliaddr);
while(1)
{
if((n=recvfrom(sockfd,line,MAXLINE,0,(struct sockaddr*)&cliaddr,&clilen))==0)
break;
printf("\n line received successfully");
line[n-1]='\0';
j=0; for(i=n-2;i>=0;i--){
recvline[j++]=line[i];
}
recvline[j]='\0';
sendto(sockfd,recvline,n,0,(struct sockaddr*)&cliaddr,clilen);
}
}
}

OUTPUT :

Client Program
#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<sys/types.h>
#include<stdlib.h>
#define SERV_PORT 5839
#define MAXLINE 20 main(int argc,char **argv)
{
ssize_t n;
struct sockaddr_in servaddr;
char sendline[MAXLINE],recvline[MAXLINE];
int sockfd;
if(argc!=2)
{
printf("usage:<IPADDRESS>");
exit(0);
}
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_port=htons(SERV_PORT);
inet_pton(AF_INET,argv[1],&servaddr.sin_addr);
sockfd=socket(AF_INET,SOCK_DGRAM,0);
printf("enter the data to be send");
while(fgets(sendline,MAXLINE,stdin)!=NULL)
{
sendto(sockfd,sendline,strlen(sendline),0,(struct
sockaddr*)&servaddr,sizeof(servaddr)); printf("line sent");
n=recvfrom(sockfd,recvline,MAXLINE,0,NULL,NULL);
recvline[n]='\0';
fputs(recvline,stdout);
printf("\n reverse of the sentense is %s",recvline); printf("\n");
}
exit(0);
}

OUTPUT :
 8. Design UDP Client Server to transfer a file.

Server Program

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#define SERV_PORT 6349 main(int argc,char **argv)
{
char filename[80],recvline[80]; FILE *fp;
struct sockaddr_in servaddr,cliaddr;
int clilen,sockfd;
sockfd=socket(AF_INET,SOCK_DGRAM,0);
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_port=htons(SERV_PORT);
bind(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
clilen=sizeof(cliaddr);
recvfrom(sockfd,filename,80,0,(struct sockaddr*)&cliaddr,&clilen);
printf("\n date in the file is \n ");
fp=fopen(filename,"r");
while(fgets(recvline,80,fp)!=NULL)
{
printf("\n %s\n ",recvline);
}fclose(fp);
}

OUTPUT :
Client Program

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<unistd.h>
#define SERV_PORT 6349 main(int argc,char **argv)
{
char filename[80]; int sockfd;
struct sockaddr_in servaddr;
sockfd=socket(AF_INET,SOCK_DGRAM,0);
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_port=htons(SERV_PORT);
inet_pton(AF_INET,argv[1],&servaddr.sin_addr);
printf("enter the file name");
scanf("%s",filename);
sendto(sockfd,filename,strlen(filename),0,(structsockaddr*)&servaddr,sizeof
(servaddr))
}

OUTPUT :
 9.Design using poll client server application to multiplex TCP
and UDP requests for converting a given text into upper case.

Server Program
#include<stdio.h>
#include<netinet/in.h>
#include<sys/types.h>
#include<string.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<sys/select.h>
#include<unistd.h>
#define MAXLINE 20
#define SERV_PORT 8114
main(int argc,char **argv)
{
int i,j,maxi,maxfd,listenfd,connfd,sockfd;
int nready,client[FD_SETSIZE];
ssize_t n;
fd_set rset,allset;
char line[MAXLINE];
socklen_t clilen;
struct sockaddr_in cliaddr,servaddr;
listenfd=socket(AF_INET,SOCK_STREAM,0);
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
servaddr.sin_port=htons(SERV_PORT);
bind(listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr));
listen(listenfd,1);
maxfd=listenfd; maxi=-1;
for(i=0;i<FD_SETSIZE;i++) client[i]=-1;
FD_ZERO(&allset); FD_SET(listenfd,&allset);
for(;;)
{
rset=allset;
nready=select(maxfd+1,&rset,NULL,NULL,NULL);
if(FD_ISSET(listenfd,&rset))
{
clilen=sizeof(cliaddr);
connfd=accept(listenfd,(struct sockaddr *)&cliaddr,&clilen);
for(i=0;i<FD_SETSIZE;i++)if(client[i]<0)
{
client[i]=connfd;
break;
}
if(i==FD_SETSIZE)
{
printf("too many clients");
exit(0);
}
FD_SET(connfd,&allset); if(connfd>maxfd)
maxfd=connfd;
if(i>maxi)
maxi=i; if(--nready<=0)
continue;
}
for(i=0;i<=maxi;i++)
{
if((sockfd=client[i])<0)
continue; if(FD_ISSET(sockfd,&rset))
{
if((n=read(sockfd,line,MAXLINE))==0)
{
close(sockfd); FD_CLR(sockfd,&allset);
client[i]=-1;
}
else
{
printf("line received from client:%s\n",line);
for(j=0;line[j]!='\0';j++)
line[j]=toupper(line[j]);
write(sockfd,line,MAXLINE);
}
if(--nready<=0) break;
}
}
}
}

OUTPUT :

Client Program :
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<netinet/in.h>
#define MAXLINE 20
#define SERV_PORT 8114 main(int argc,char **argv)
{
int maxfdp1;
fd_set rset;
char sendline[MAXLINE],recvline[MAXLINE];
int sockfd;
struct sockaddr_in servaddr; if(argc!=2)
{
printf("usage tcpcli <ipaddress>"); return;
} sockfd=socket(AF_INET,SOCK_STREAM,0);
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_port=htons(SERV_PORT);
inet_pton(AF_INET,argv[1],&servaddr.sin_addr);
connect(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr));
printf("\nenter data to be send:");
while(fgets(sendline,MAXLINE,stdin)!=NULL)
{
write(sockfd,sendline,MAXLINE);
printf("\nline send to server :%s ",sendline);
read(sockfd,recvline,MAXLINE);
printf("line received from the server : %s",recvline);
}
exit(0);
}

OUTPUT :
10. Design a RPC application to add and subtract a given pair
of integers.
#include<stdio.h>

#include<sys/types.h>

#include<sys/socket.h>

#include<string.h>

#include<netinet/in.h>

#include<netinet/tcp.h>

main()

int sockfd,maxseg,sendbuff,optlen;

sockfd=socket(AF_INET,SOCK_STREAM,0);

optlen=sizeof(maxseg);

if(getsockopt(sockfd,IPPROTO_TCP,TCP_MAXSEG,(char *)&maxseg,&optlen)<0)

printf("Max seg error");

else

printf("TCP max seg=%d\n",maxseg);

sendbuff=2500;

if(setsockopt(sockfd,SOL_SOCKET,SO_SNDBUF,(char*)&sendbuff,sizeof(sendbuff))<
0)
printf("set error");

optlen=sizeof(sendbuff);

getsockopt(sockfd,SOL_SOCKET,SO_SNDBUF,(char *)&sendbuff,&optlen);

printf("send buff size=%d\n",sendbuff);

OUTPUT :