UNIX NETWORK

PROGRAMMING

Assignment :Unix Programs

Submitted By: Ayush Agarwal
MCA II
09811007

Submitted To:
Prof. Mohan Lal

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 100
int 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 1024
server(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 1024
client(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 :cant open write fifo: %s ,FIFO1);
if((readfd = open(FIFO2,0))<0)
perror(client :cant open read fifo: %s ,FIFO2);
client(readfd, writefd);
close(readfd);
close(writefd);
if( unlink(FIFO1)<0)
perror(client :cant unlink fifo: %s ,FIFO1);
if(unlink(FIFO2)<0)
perror(client :cant 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*/
int

readline(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 512
str_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 512
str_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 512
dg_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 512
dg_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"
int
main(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"
int
main(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"
int
main(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