Submitted By: Ayush Agarwal Submitted To: MCA II Prof. Mohan Lal 09811007

Program 1: read and write “ sequence number” from a file……/*******************************seqno.c**************************/#include<stdlib.h>#include<stdio.h>#include<unistd.h>#include<string.h>#define SEQFILE "seqno.txt"#define MAXBUFF 100int seqno=0;main(){ int fd,i,n; char buff[MAXBUFF+1];

int pid=getpid(); if((fd=open(SEQFILE,2))<0) perror("can't open file"); for(i=0;i<20;i++){ lseek(fd,0L,0); if((n=read(fd,buff,MAXBUFF))<0) perror("file read error"); buff[n]='\0'; if((n=sscanf(buff,"%d\n",&seqno))!=1) perror("seq no read error"); seqno++; printf("pid=%d seqno=%d\n",pid,seqno); sprintf(buff,"%03d\n",seqno); lseek(fd,0L,0); n=strlen(buff); if(write(fd,buff,n)!=n) perror("write error"); } }

/***********************OUTPUT*******************************/

Program 2: Pipe between two process (client & server)

/*****************************server.c********************************/

#include<stdio.h>#include<sys/errno.h>#include<unistd.h>#include<stdlib.h>#include<string.h>#define MAXBUFF 1024server(readfd,writefd) int readfd; int writefd; { char buff[MAXBUFF]; char errmesg[256],*sys_err_str(); int n,fd;

extern int errno; if((n=read(readfd,buff,MAXBUFF))<=0) perror("Server:filename read error"); buff[n]='\0'; if((fd=open(buff,0))<0){ sprintf(errmesg,":can't open , %s\n","file"); strcat(buff,errmesg); n=strlen(buff); if(write(writefd,buff,n)!=n) perror("Server:mesg write error");

}else { while((n=read(fd,buff,MAXBUFF))>0) if(write(writefd,buff,n)!=n) perror("Server:data write error"); if(n<0) perror("Server:data read error");}}

/***************************client.c**************************/

#include<stdio.h>#include<sys/errno.h>#include<unistd.h>#include<stdlib.h>#include<string.h>#define MAXBUFF 1024client(readfd,writefd)int readfd; int writefd;{ char buff[MAXBUFF]; int n; printf("Please enter the file name::"); if(fgets(buff,MAXBUFF,stdin)==NULL) perror("Client:filename read error"); n=strlen(buff);

if(buff[n-1]=='\n') n--; if(write(writefd,buff,n)!=n) perror("Client:filename write error"); printf("Here is the content of the file::\n\n"); while((n=read(readfd,buff,MAXBUFF))>0) if(write(1,buff,n)!=n) perror("Client:data write error"); if(n<0) perror("Client:data read error");}

/**************************pipe.c******************************/

#include<stdio.h>#include<sys/errno.h>#include<unistd.h>#include<stdlib.h>#include"client.c"#include"server.c"

main(){ int childpid,pipe1[2],pipe2[2]; if((pipe(pipe1)<0)||(pipe(pipe2)<0)) perror("can't create pipes"); if((childpid=fork())<0){ perror("can't fork"); }else if(childpid>0){ /*parent*/ close(pipe1[0]); close(pipe2[1]); client(pipe2[0],pipe1[1]); while(wait((int *)0)!= childpid) /*wait for child*/ close(pipe1[1]); close(pipe2[0]); exit(0); }

else { close(pipe1[1]); close(pipe2[0]); server(pipe1[0],pipe2[1]); close(pipe1[0]); close(pipe2[1]); exit(0);}}

OUTPUT:

Program 3: fifo between two process (client & server)

/******************************fifo.h***********************/

#include<sys/types.h>#include<sys/stat.h>#include<sys/errno.h>#include<unistd.h>#include<stdio.h>#include<string.h>#include<stdlib.h>extern int errno;

#define FIFO1 "/tmp/fifo.1"#define FIFO2 "/tmp/fifo.2"#define PERMS 0666

/**************************servermain.c******************/

#include "fifo.h"#include "server.c"

main(int argc, char **argv){ int readfd, writefd; /* create two FIFOs; OK if they already exist */ if ((mknod(FIFO1, S_IFIFO|PERMS,0) < 0) && (errno != EEXIST)) printf("can't create %s", FIFO1); if ((mknod(FIFO2, S_IFIFO|PERMS,0) < 0) && (errno != EEXIST)) { unlink(FIFO1); printf("can't create %s", FIFO2); } readfd = open(FIFO1, 0); writefd = open(FIFO2,1); server(readfd, writefd); close(readfd); close(writefd); exit(0); }/*************************clientmain.c********************/

#include "fifo.h"

#include "client.c"

int main(int argc, char **argv){ int readfd, writefd; if((writefd = open(FIFO1,1))<0) perror(“client :can’t open write fifo: %s ”,FIFO1);if((readfd = open(FIFO2,0))<0) perror(“client :can’t open read fifo: %s ”,FIFO2); client(readfd, writefd); close(readfd); close(writefd);if( unlink(FIFO1)<0) perror(“client :can’t unlink fifo: %s ”,FIFO1);

if(unlink(FIFO2)<0) perror(“client :can’t unlink fifo: %s ”,FIFO2); exit(0); }

OUTPUT:

Program 4: MESSAGE QUEUE between two process (client & server)

/***********************mesg.h************************/

#define MAXMESGDATA (4096-16)#define MESGHDRSIZE (sizeof(Mesg)-MAXMESGDATA)

typedef struct{ int mesg_len; long mesg_type;char mesg_data[MAXMESGDATA];}Mesg;

/***************************mesgq.h******************/

#include<sys/types.h>#include<sys/ipc.h>#include<sys/msg.h>#include<string.h>#include<sys/errno.h>#include<stdio.h>#include<unistd.h>#include "mesg.h"extern int errno;#define MKEY1 1234L#define MKEY2 2345L#define PERMS 0666

/**********************send_recv_fun.c*******************/

#include "mesgq.h"mesg_recv(int id,Mesg *mesgptr){int n;n=msgrcv(id,(char *)&(mesgptr->mesg_type),MAXMESGDATA,mesgptr->mesg_type,0);if((mesgptr->mesg_len=n)<0)perror("msgrcv error");return n;}

mesg_send(int id,Mesg * mesgptr){if(msgsnd(id,(char*)&(mesgptr->mesg_type),mesgptr->mesg_len,0)!=0)perror("mesg send error");}

/**************************server.c**********************/

#include "send_recv_fun.c"Mesg mesg;extern int errno;server(int ipcreadfd,int ipcwritefd){ char errmesg[256];int n,filefd;mesg.mesg_type=1L;

if((n=mesg_recv(ipcreadfd,&mesg))<=0)perror("server:filename read error");mesg.mesg_data[n]='\0';if((filefd=open(mesg.mesg_data,0))<0){sprintf(errmesg,":can't open,%s\n","file");strcat(mesg.mesg_data,errmesg);mesg.mesg_len=strlen(mesg.mesg_data);mesg_send(ipcwritefd,&mesg);

} else{

while( (n=read(filefd,mesg.mesg_data,MAXMESGDATA))>0)mesg.mesg_len=n;mesg_send(ipcwritefd,&mesg);}close(filefd);if(n<0)perror("server:read error");mesg.mesg_len=0;

mesg_send(ipcwritefd,&mesg);

}

/***************************servermain.c******************************/

#include "server.c" main() { int readid,writeid; if((readid=msgget(MKEY1,PERMS|IPC_CREAT))<0) perror("Server: can't get message queue 1"); if((writeid=msgget(MKEY2,PERMS|IPC_CREAT))<0) perror("Server: can't get message queue 2"); server(readid,writeid); exit(0);} /*********************************client.c*************************/

#include "send_recv_fun.c"Mesg mesg;client( int ipcreadfd, int ipcwritefd){ int n; printf("Please enter the file name::"); if(fgets(mesg.mesg_data,MAXMESGDATA,stdin)==NULL) perror("filename read error");

n=strlen(mesg.mesg_data); if(mesg.mesg_data[n-1]=='\n') n--; mesg.mesg_len=n; mesg.mesg_type=1L; mesg_send(ipcwritefd,&mesg); printf("Here is the content of the file::\n\n"); while((n=mesg_recv(ipcreadfd,&mesg))>0)

if(write(1,mesg.mesg_data,n)!=n) perror("client:data write errors"); if(n<0) perror("data read error");}

/*******************************clientmain.c*************************/

#include "client.c"main() { int readid,writeid; if((writeid=msgget(MKEY1,0))<0) perror("Client: can't get message queue 1"); if((readid=msgget(MKEY2,0))<0) perror("Client: can't get message queue 2"); client(readid,writeid);if(msgctl(readid,IPC_RMID,(struct msqid_ds *)0)<0)perror("client: RMID mesg queue 1");if(msgctl(writeid,IPC_RMID,(struct msqid_ds *)0)<0)perror("client: RMID mesg queue 2"); exit(0);}

/*************************OUTPUT***************************/

Program 5: multiplexing MESSAGEs between process (client & server)

/*************************server.c*************************/

#include "send_recv_fun.c"Mesg mesg; main(){ int id; if((id=msgget(MKEY1,PERMS|IPC_CREAT))<0)printf("Server:can't get message queue 1");server(id);exit(0);}

/*server function */server(int id){ char errmesg[256];int n,filefd;mesg.mesg_type=1L;

if((n=mesg_recv(id,&mesg))<=0)

printf("server:filename read error");mesg.mesg_data[n]='\0';mesg.mesg_type=2L;if((filefd=open(mesg.mesg_data,0))<0){ sprintf(errmesg,":can't open,%s\n","file");strcat(mesg.mesg_data,errmesg);mesg.mesg_len=strlen(mesg.mesg_data);

mesg_send(id,&mesg);} else{while( (n=read(filefd,mesg.mesg_data,MAXMESGDATA))>0)mesg.mesg_len=n;mesg_send(id,&mesg);}close(filefd);if(n<0)printf("server read error");

mesg.mesg_len=0;mesg_send(id,&mesg);}

/*****************************client.c*****************************/

#include "send_recv_fun.c"Mesg mesg; main(){ int id; if((id=msgget(MKEY1,0))<0) perror("CLIENT:can't msgget message queue 1");

client(id); if(msgctl(id,IPC_RMID,(struct msqid_ds *) 0)<0)perror("client:cant RMID message queue 1");exit(0);}

/*client function */client( int id){ int n;printf("Please give a file name to read it::");if(fgets(mesg.mesg_data,MAXMESGDATA,stdin)==NULL)printf("filename read error");

n=strlen(mesg.mesg_data);if(mesg.mesg_data[n-1]=='\n')n--;mesg.mesg_len=n;mesg.mesg_type=1L;mesg_send(id,&mesg);

printf("Here is the file content::\n\n");mesg.mesg_type=2L;while((n=mesg_recv(id,&mesg))>0)if(write(1,mesg.mesg_data,n)!=n)perror("client:data write errors");if(n<0)perror("data read error");}

/**************************OUTPUT**************************/

Socket programming

/**********************util_routines.c*************************/

/*readn function*/

int readn(fd,ptr,nbytes) register int fd;register char *ptr;register int nbytes;{ int nleft,nread; nleft=nbytes; while(nleft>0) { nread=read(fd,ptr,nleft); if(nread<0) return nread; else if(nread ==0)

break; nleft-=nread; ptr+=nread;}return(nbytes-nleft);}

/*writen function */

int writen(fd,ptr,nbytes) register int fd;register char *ptr;register int nbytes;{ int nleft,nwrite; nleft=nbytes; while(nleft>0) { nwrite=write(fd,ptr,nleft); if(nwrite<=0) return nwrite; nleft-=nwrite; ptr+=nwrite;}return(nbytes-nleft);}

/*readline function*/

intreadline(fd,ptr,maxlen)register int fd;register char *ptr;

register int maxlen;{ int n,rc; char c;

for(n=1;n<maxlen;n++){ if ((rc=read(fd,&c,1))==1){ *ptr++=c; if(c=='\n') break; }else if(rc==0){ if(n==1)return 0; else break; }else return (-1);}*ptr=0;return n;}

/****************************str_echo.c************************/

#include <stdio.h>#include<string.h>#define MAXLINE 512str_echo( int sockfd){ char line[MAXLINE]; int n;

for(;;){ n=readline(sockfd,line,MAXLINE);if(n==0) return; else if(n<0) perror("str_echo:readline error ");

if (writen(sockfd, line, n) !=n ) perror("str_echo: writen error");

} }

/****************************str_cli.c**************************/#include <stdio.h>#include<string.h>#define MAXLINE 512str_cli(FILE *fp, int sockfd){ char sendline[MAXLINE], recvline[MAXLINE+1]; int n; printf("Client:"); while (fgets(sendline, MAXLINE, fp) != NULL) { n=strlen(sendline); if(writen(sockfd,sendline,n)!=n) perror("str_cli:writen error on socket"); printf("Server:"); printf("Client:"); if (n=(readline(sockfd, recvline, MAXLINE)) < 0) perror("str_cli: readline error"); recvline[n]=0; fputs(recvline, stdout); } if(ferror(fp)) perror("str_cli:error reading file"); }

/***********************************dg_echo.c**************************/#include<sys/types.h>#include<sys/socket.h>#define MAXLINE 512dg_echo(sockfd,pcli_addr,maxclilen)int sockfd;struct sockaddr *pcli_addr;int maxclilen;{ int n,clilen;

char mesg[MAXLINE]; for(;;){ clilen=maxclilen; n=recvfrom(sockfd,mesg,MAXLINE,0,pcli_addr,&clilen); if(n<=0) printf("dg:echo:recieve error");

if(sendto(sockfd,mesg,n,0,pcli_addr,clilen)!=n) printf("dg:echo:sendto error"); }}/*****************************dg_cli.c**********************************/#include<sys/types.h>#include<sys/socket.h>#define MAXLINE 512dg_cli(FILE *fp, int sockfd,struct sockaddr * pserv_addr,int servlen){ char sendline[MAXLINE], recvline[MAXLINE+1]; int n;printf("Client:");while (fgets(sendline, MAXLINE, fp) != NULL) { n=strlen(sendline);

if(sendto(sockfd,sendline,n,0,pserv_addr,servlen)!=n) printf("dg_cli:writen error on socket");

if (n=(recvfrom(sockfd, recvline, MAXLINE,0,(struct sockaddr *)0,(int *)0)) < 0) printf("dg_cli: readline error"); recvline[n]=0; printf("Server:"); fputs(recvline, stdout); printf("Client:"); }if(ferror(fp)) printf("dg_cli:error reading file"); }

/********************************inet.h****************************/#include<stdio.h>#include<sys/types.h>#include<sys/socket.h>#include<netinet/in.h>#include<arpa/inet.h>#include<unistd.h>

#include "util_routines.c"#include "str_echo.c"#include "str_cli.c"#include "dg_echo.c"#include "dg_cli.c"

#define SERV_UDP_PORT 7000#define SERV_TCP_PORT 6000#define SERV_HOST_ADDR "127.0.0.1"

char *pname;

/********************************unix.h*******************************/#include<stdio.h>#include<sys/types.h>#include<sys/socket.h>#include<string.h>#include<sys/un.h>#include<unistd.h>

#include "util_routines.c"#include "str_echo.c"#include "str_cli.c"#include "dg_echo.c"#include "dg_cli.c"

#define UNIXSTR_PATH "./unixstr"#define UNIXDG_PATH "./unixdg"#define UNIXDG_TMP "/tmp/dg.abcdef"

char *pname;

Program 6: INET tcp program (client & server)

/*************************tcp_server.c**************************/

#include "inet.h" int main(argc, argv) int argc; char *argv[];{int sockfd,newsockfd,clilen,childpid;struct sockaddr_in serv_addr,cli_addr;

pname=argv[0];

if((sockfd = socket(AF_INET, SOCK_STREAM,0))<0) printf("server: can't open socket stream");

bzero((char *)&serv_addr, sizeof(serv_addr));serv_addr.sin_family = AF_INET;serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);serv_addr.sin_port = htons(SERV_TCP_PORT);

if(bind(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr))<0) printf("server: can't bind address");

listen(sockfd,5);

for(;;){ clilen=sizeof(cli_addr);newsockfd=accept(sockfd,(struct sockaddr *)&cli_addr,&clilen);

if(newsockfd<0) printf("server: accept error"); if((childpid=fork())<0) printf("server: fork error");

else if(childpid==0) {

close(sockfd); str_echo( newsockfd); exit(0); } close(newsockfd);}}

/****************************tcp_client.c****************************/

#include "inet.h"intmain(argc, argv)int argc;char *argv[];{int sockfd;struct sockaddr_in serv_addr;pname=argv[0];bzero((char *)&serv_addr, sizeof(serv_addr));serv_addr.sin_family = AF_INET;serv_addr.sin_addr.s_addr=inet_addr(SERV_HOST_ADDR);serv_addr.sin_port = htons(SERV_TCP_PORT);

if((sockfd = socket(AF_INET, SOCK_STREAM,0))<0) printf("client: can't open socket stream");if(connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr))<0) printf("client: can't connect to server"); str_cli(stdin, sockfd); exit(0); }

/******************************OUTPUT******************************/

Program 7: INET udp program (client & server)

/*****************************udp_server.c*****************************/

#include "inet.h" int main(argc, argv) int argc; char *argv[];{int sockfd;struct sockaddr_in serv_addr,cli_addr;pname=argv[0];

if((sockfd = socket(AF_INET, SOCK_DGRAM,0))<0) printf("server: can't open socket stream");

bzero((char *)&serv_addr, sizeof(serv_addr));

serv_addr.sin_family = AF_INET;serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);serv_addr.sin_port = htons(SERV_UDP_PORT);

if(bind(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr))<0) printf("server: can't bind address");

dg_echo(sockfd,(struct sockaddr *)&cli_addr,sizeof(cli_addr));

}

/********************************udp_client.c***************************/

#include "inet.h"intmain(argc, argv)int argc;char *argv[];{int sockfd;struct sockaddr_in serv_addr,cli_addr;pname=argv[0];bzero((char *)&serv_addr, sizeof(serv_addr));serv_addr.sin_family = AF_INET;serv_addr.sin_addr.s_addr=inet_addr(SERV_HOST_ADDR);serv_addr.sin_port = htons(SERV_UDP_PORT);

if((sockfd = socket(AF_INET, SOCK_DGRAM,0))<0) printf("client: can't open socket stream");

bzero((char *)&cli_addr, sizeof(cli_addr));serv_addr.sin_family = AF_INET;serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);serv_addr.sin_port = htons(0);if(bind(sockfd,(struct sockaddr *)&cli_addr,sizeof(cli_addr))<0) printf("client: can't bind address"); dg_cli(stdin,sockfd,(struct sockaddr *) & serv_addr,sizeof(serv_addr)); close(sockfd); //exit(0); }

/*************************OUTPUT****************************/

Program 8: unix tcp program (client & server)

/****************************unix_tcp_server*******************/

#include "unix.h" int main(argc, argv) int argc; char *argv[];{int sockfd,newsockfd,clilen,childpid,servlen;struct sockaddr_un serv_addr,cli_addr;pname=argv[0];

if((sockfd = socket(AF_UNIX, SOCK_STREAM,0))<0) perror("server: can't open socket stream");

unlink(UNIXSTR_PATH);bzero((char *)&serv_addr, sizeof(serv_addr));serv_addr.sun_family = AF_UNIX;strcpy(serv_addr.sun_path,UNIXSTR_PATH);servlen=strlen(serv_addr.sun_path)+sizeof(serv_addr.sun_family);

if(bind(sockfd,(struct sockaddr *)&serv_addr,servlen)<0) perror("server: can't bind address");

listen(sockfd,5);

for(;;){ clilen=sizeof(cli_addr);newsockfd=accept(sockfd,(struct sockaddr *)&cli_addr,&clilen);

if(newsockfd<0) perror("server: accept error"); if((childpid=fork())<0) perror("server: fork error");

else if(childpid==0) { close(sockfd); str_echo( newsockfd); exit(0); } close(newsockfd);}}

/**************************unix_tcp_client***************************/

#include "unix.h"

intmain(argc, argv)int argc;char *argv[];{int sockfd,servlen;struct sockaddr_un serv_addr;pname=argv[0];bzero((char *)&serv_addr, sizeof(serv_addr));serv_addr.sun_family = AF_UNIX;strcpy(serv_addr.sun_path,UNIXSTR_PATH);servlen=strlen(serv_addr.sun_path)+sizeof(serv_addr.sun_family);

if((sockfd = socket(AF_UNIX, SOCK_STREAM,0))<0) perror("client: can't open socket stream");if(connect(sockfd,(struct sockaddr *)&serv_addr,servlen)<0) perror("client: can't connect to server"); str_cli(stdin, sockfd); close(sockfd); exit(0); }

/******************************OUTPUT*****************************/

Program 9: unix udp program (client & server)

/***************************unix_udp_server************************/

#include "unix.h" int main(argc, argv) int argc; char *argv[];{int sockfd,servlen;struct sockaddr_un serv_addr,cli_addr;pname=argv[0];

if((sockfd = socket(AF_UNIX, SOCK_DGRAM,0))<0) perror("server: can't open socket datagram");unlink(UNIXSTR_PATH);bzero((char *)&serv_addr, sizeof(serv_addr));serv_addr.sun_family = AF_UNIX;

strcpy(serv_addr.sun_path,UNIXDG_PATH);servlen=strlen(serv_addr.sun_path)+sizeof(serv_addr.sun_family);if(bind(sockfd,(struct sockaddr *)&serv_addr,servlen)<0) perror("server: can't bind address"); dg_echo( sockfd,(struct sockaddr *)&cli_addr,sizeof(cli_addr)); exit(0);

}/****************************unix_udp_client**********************/

#include "unix.h" int main(argc, argv) int argc; char *argv[];{int sockfd,clilen,servlen;char *mktemp();struct sockaddr_un serv_addr,cli_addr;pname=argv[0];unlink(UNIXSTR_PATH);bzero((char *)&serv_addr, sizeof(serv_addr));serv_addr.sun_family = AF_UNIX;strcpy(serv_addr.sun_path,UNIXDG_PATH);servlen=strlen(serv_addr.sun_path)+sizeof(serv_addr.sun_family);

if((sockfd = socket(AF_UNIX, SOCK_DGRAM,0))<0) perror("client: can't open socket data gram");

bzero((char *)&cli_addr, sizeof(cli_addr));cli_addr.sun_family = AF_UNIX;strcpy(cli_addr.sun_path,UNIXDG_TMP);mktemp(cli_addr.sun_path);clilen=strlen(cli_addr.sun_path)+sizeof(cli_addr.sun_family);if(bind(sockfd,(struct sockaddr *)&cli_addr,clilen)<0) perror("client: can't bind address");

dg_cli(stdin, sockfd,(struct sockaddr *)&serv_addr,servlen); close(sockfd); unlink(cli_addr.sun_path); exit(0); }

/*****************************OUTPUT***********************/

THANK YOU