TCP SERVER

#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/wait.h>
#include<fcntl.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/errno.h>
#define MYPORT 65110

void readstring(int,char*);

int main(int c,char* v[]){

int listensocket,connectionsocket,retbind;
struct sockaddr_in serveraddress,cliaddr;

socklen_t len;
char buf[100],databuf[1024];
listensocket=socket(AF_INET,SOCK_STREAM,0);
if(listensocket<0)
exit(1);

memset(&serveraddress,0,sizeof(serveraddress));

serveraddress.sin_family=AF_INET;
serveraddress.sin_port=htons(MYPORT);
serveraddress.sin_addr.s_addr=htonl(INADDR_ANY);

if(-1==retbind)
{
perror("BINDERROR\n");
exit(1);
}

listen(listensocket,5);

for( ; ;)
{
printf("server:Iam waiting ... for client...\n");
len=sizeof(cliaddr);

connectionsocket=accept(listensocket,(struct sockaddr*)&cliaddr,&len);
if(connectionsocket<0)
{
if(errno==EINTR)
printf("Interrupted system call??");
continue;
 }

printf("connection from
%s\n",inet_ntop(AF_INET,&cliaddr.sin_addr,buf,sizeof(bu
f)));
readstring(connectionsocket,databuf);
close(connectionsocket);
printf("finished serving one client");
}
}
void readstring(int connectionsocket, char* msg)
{
char rev[50];
int length,pointer=0,n,i=0;
while((n=read(connectionsocket,(msg+pointer),1024))>0)
{
pointer=pointer+n;
}
msg[pointer]='\0';
while(msg[i]!='\0')
{
i++;
}
length=i;
for(i=0;i<length;i++)
{
rev[i]=msg[length-1-i];
}
printf("server:received and reversed:%s\n",rev);

}
CONCURRENT SERVER

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/wait.h>
#include<fcntl.h>
#include<unistd.h>
#define SERV_PORT 54543
#define MAXLINE 1024
#define LISTENQ 100
void str_echo(int);

int main(int argc,char **argv)

{

int listenfd,connfd,retbind;
pid_t childpid;
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);

retbind=bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr));

if(-1==retbind)
{
printf("BIND ERROR");
exit(0);
}
listen(listenfd,LISTENQ);

for( ; ; )
{
printf(" waiting for client.........\n");
clilen=sizeof(cliaddr);
connfd=accept(listenfd,(struct sockaddr*)&cliaddr,&clilen);
if((childpid=fork()) ==0)
{ close(listenfd);
printf("new child forked");
str_echo(connfd);
}
else

close(connfd);
}}

void str_echo(int sockfd)

{

ssize_t n;
char buf[MAXLINE];

while((n=read(sockfd,buf,MAXLINE))>0)
write(sockfd,buf,n);

ITCONCLIENT

#include<stdio.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<error.h>
#include<stdlib.h>
#define MAXLINE 1024
#define SERV_PORT 54543
void str_cli(FILE*,int);

int main(int argc,char** argv)

{
int sockfd;
struct sockaddr_in servaddr;
//char sendline[MAXLINE]="CLIENTCONNECTED";
//char sendline[MAXLINE],recvline[MAXLINE];

if(argc!=2)
{
printf("usage:tcpcli <ipaddress>");
exit(0);
}

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);

if(connect(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
{
printf("cannot connect to the server");
exit(1);
}
//write(sockfd,sendline,strlen(sendline));
str_cli(stdin,sockfd);
close(sockfd);
}

void str_cli(FILE *fp,int sockfd)

{
char sendline[MAXLINE],recvline[MAXLINE];
printf("enter the string");

while(fgets(sendline,MAXLINE,fp)!=NULL)
{
write(sockfd,sendline,strlen(sendline));
if(read(sockfd,recvline,MAXLINE)==0)
{
//printf("server terminated prematurely");
exit(0);
}
fputs(recvline,stdout);
}
DAYTIME CLIENT

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>

#define MAXLINE 100

int main(int argc,char **argv)

{
int sockfd,n;
char recvline[MAXLINE+1];
struct sockaddr_in servaddr;

if(argc!=2)
{
printf("usage: ./a.out<IP address>");
exit(1);
}

if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0)
{
printf("socket error");

}
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(13);
if(inet_pton(AF_INET,argv[1],&servaddr.sin_addr)<=0)
{
printf("inet_pton error for %s",argv[1]);
exit(1);
}

if(connect(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
{
printf("connect error");
exit(1);
}

while((n=read(sockfd,recvline,MAXLINE))>0)
{

recvline[n]=0;
if(fputs(recvline,stdout)==EOF)
{
printf("fputs error");

}
}

if(n<0)
printf("read error");
 exit(0);

}
FILECLI

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<fcntl.h>

#define MAXLINE 1024

#define MYPORT 56789

void sendfile(int,struct sockaddr*,socklen_t,char*);

int main(int argc,char **argv)

{

int sd;
struct sockaddr_in sa;

if(argc!=4)
printf("enter correct no of argumnets\n");

bzero(&sa,sizeof(sa));

sa.sin_family=AF_INET;
sa.sin_port=htons(MYPORT);
inet_pton(AF_INET,argv[1],&sa.sin_addr);
sd=socket(AF_INET,SOCK_DGRAM,0);

sendfile(sd,(struct sockaddr*)&sa,sizeof(sa),argv[3]);

void sendfile(int sd,struct sockaddr* psa,socklen_t sel,char *fn)

{
int nr,nw,fd;
char buf[MAXLINE];

fd=open(fn,O_RDONLY,664);

do
{
nr=read(fd,buf,MAXLINE);
nw=sendto(sd,buf,nr,0,psa,sel);

}while(nr>0);

printf("file is sent");

}
FILE SERVER

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<fcntl.h>
#define MYPORT 59871

void getfile(int,char*);

int main(int c,char *v[])

{
int listensocket,connectionsocket,retbind;
struct sockaddr_in serveraddress,cliaddr;
socklen_t len;
char buf[100],filename[100];
listensocket=socket(AF_INET,SOCK_STREAM,0);
if(listensocket<0)
exit(1);

memset(&serveraddress,0,sizeof(serveraddress));
serveraddress.sin_family=AF_INET;
serveraddress.sin_port=htons(MYPORT);
serveraddress.sin_addr.s_addr=htonl(INADDR_ANY);
retbind=bind(listensocket,(struct
sockaddr*)&serveraddress,sizeof(serveraddress
));

if(-1==retbind)
{
printf("BIND ERROR\n");
exit(1);
}
listen(listensocket,5);

for( ; ; )
{
printf("server:Iam waiting..for client..\n");
len=sizeof(cliaddr);
connectionsocket=accept(listensocket,(struct sockaddr*)&cliaddr,&len);
 if(connectionsocket<0)
{
if(errno==EINTR)
printf("Interrupted sytem call??");
continue;
}

printf("connection from
%s\n",inet_ntop(AF_INET,&cliaddr.sin_addr,buf,sizeof(buf
)));
printf("enter the name of desti file");
scanf("%s",&filename);
getfile(connectionsocket,filename);
close(connectionsocket);
printf("Finished serving one client");

}
}

void getfile(int connectionsocket,char* filename)

{

int i,j,n,c,fd1;
char databuf[1000];
n=read(connectionsocket,databuf,1000);
i=strlen(databuf);
fd1=creat(filename,777);
c=write(fd1,databuf,i);

SELSERV

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
#include<sys/select.h>
#include<sys/time.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<fcntl.h>
#define MAXLINE 1000
#define SERV_PORT 53456

int main(int argc,char **argv)

{
int k,i,maxi,maxfd,listenfd,connfd,sockfd;
int nready,client[FD_SETSIZE],retbind;
ssize_t n;
fd_set rset,allset;
char line[MAXLINE],buf[100];
socklen_t clilen;
struct sockaddr_in cliaddr,servaddr;
listenfd=socket(AF_INET,SOCK_STREAM,0);
if(listenfd<0)
{
perror("socket is not created");
exit(1);
}

memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
servaddr.sin_port=htons(SERV_PORT);

retbind=bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
if(-1==retbind)
{
printf("bind error");
exit(0);
}

listen(listenfd,5);
maxfd=listenfd;
maxi=-1;

for(i=0;i<FD_SETSIZE;i++)
client[i]=-1;

FD_ZERO(&allset);
FD_SET(listenfd,&allset);

for(; ;)
{

printf("Servar:I am waiting . . . .start of main loop\n");

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);
printf("new client:%s,port
%d\n",inet_ntop(AF_INET,&cliaddr.sin_a
ddr,buf,sizeof(buf)),ntohs(cliaddr.sin_port));
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("\noutput at server\n");
for(k=0;line[k]!='\0';k++)
printf("%c",toupper(line[k]));
close(sockfd);
FD_CLR(sockfd,&allset);
client[i]=-1;
}
if(--nready<=0)
break;

}
}

POLLSERV

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<fcntl.h>
#include<poll.h>
#include<errno.h>
#define MAXLINE 100
#define SERV_PORT 56785
#define POLLRDNORM 5
#define INFTIM (-1)
#define OPEN_MAX 5

int main(int argc,char **argv)

{
int retbind,k,i,maxi,listenfd,connfd,sockfd;
ssize_t n;
int nready;
char line[MAXLINE],buf[100];
socklen_t clilen;
struct pollfd client[OPEN_MAX];
struct sockaddr_in cliaddr,servaddr;
listenfd=socket(AF_INET,SOCK_STREAM,0);
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
servaddr.sin_port=htons(SERV_PORT);

retbind=bind(listenfd,(struct
sockaddr*)&servaddr,sizeof(servaddr));
listen(listenfd,5);
client[0].fd=listenfd;
client[0].events=POLLRDNORM;

for(i=1;i<OPEN_MAX;i++)
client[i].fd=-1;

maxi=0;
for(; ;)
{
printf("Server:I am waiting for the client");
nready=poll(client,maxi+1,INFTIM);
if(client[0].revents&POLLRDNORM)
{
sizeof(cliaddr);
connfd=accept(listenfd,(struct sockaddr*)&cliaddr,&clilen);
printf("newclient:
%s\n",inet_ntop(AF_INET,&cliaddr.sin_addr,buf,sizeof(b
uf)));
for(i=1;i<OPEN_MAX;i++)
if(client[i].fd<0)
{
client[i].fd=connfd;
break;
}
if(i==OPEN_MAX)
printf("too many clients");
client[i].events=POLLRDNORM;
if(i>maxi)
 maxi=i;
if(--nready<=0)
continue;
}

for(i=1;i<=maxi;i++)
{
if((sockfd=client[i].fd)<0)
continue;
if(client[i].revents&(POLLRDNORM|POLLERR))
{
if((n=read(sockfd,line,MAXLINE))<0)
{
if(errno==ECONNRESET)
{
close(sockfd);
client[i].fd=-1;
}
else
printf("readline error");
}
else if(n==0)
{
close(sockfd);
client[i].fd=-1;
}
else
{
printf("\n data from the client is \n");
printf("data=%s\n",line);
write(sockfd,line,n);
strcpy(line," ");
}
if(--nready<=0)
break;
}
}
}
}

POLLCLI

#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<string.h>
#include<sys/stat.h>
#include<unistd.h>
#include<errno.h>
#include<sys/types.h>
#include<fcntl.h>
#include<netinet/in.h>
#define MAXLINE 1024
#define SERV_PORT 56785

void str_cli(FILE*,int);

int main(int argc,char** argv)

{
int sockfd;
struct sockaddr_in servaddr;

sockfd=socket(AF_INET,SOCK_STREAM,0);

if(sockfd<0)
{
perror("socket not created");
exit(1);
}

if(argv[1]==NULL)
{

printf("please specify server ip address");

exit(0);
}

if(argv[2]==NULL)
{
printf("please specify the string to be send to the server\n");
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);

if((connect(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr)))<0)
{
printf("cannot connect to the server");
exit(1);

str_cli(stdin,sockfd);

close(sockfd);

exit(0);

}
void str_cli(FILE *fp,int sockfd)
{

char sendline[MAXLINE],recvline[MAXLINE];

while(fgets(sendline,MAXLINE,fp)!=NULL){

write(sockfd,sendline,strlen(sendline));

if((read(sockfd,recvline,MAXLINE))==0)

{
printf("str_cli:server terminated prematurely");
exit(0);
}

fputs(recvline,stdout);

UDPECHOSERVER

#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<string.h>
#include<netinet/in.h>
#define SERV_PORT 57886
#define MAXLINE 1024

void dg_echo(int,struct sockaddr*,socklen_t);

int main(int argc,char** argv)

{
int sockfd,retbind;
struct sockaddr_in cliaddr,servaddr;
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);
retbind=bind(sockfd,(struct sockaddr*) &servaddr,sizeof(servaddr));
if(retbind==-1)
{
printf("bind error");
exit(1);
}

dg_echo(sockfd,(struct sockaddr*)&cliaddr,sizeof(cliaddr));
}
void dg_echo(int sockfd,struct sockaddr* pcliaddr,socklen_t clilen)
{
int n;
socklen_t len;
char mesg[MAXLINE];
for( ; ; )
{
len=clilen;
n=recvfrom(sockfd,mesg,MAXLINE,0,pcliaddr,&len);

sendto(sockfd,mesg,n,0,pcliaddr,len);
}
}
UDPECHOCLIENT

#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<error.h>
#include<netinet/in.h>
#include<string.h>
#define SERV_PORT 56789
#define MAXLINE 1024
void dg_cli(FILE*,int,const struct sockaddr*,socklen_t);

int main(int argc,char** argv)

{

struct sockaddr_in servaddr;

int sockfd;

if(argc!=2)
{
printf("usage:udpcli <IPaddress>");
exit(1);
}

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);
dg_cli(stdin,sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr));

exit(0);

void dg_cli(FILE* fp,int sockfd,const struct sockaddr *pservaddr,socklen_t

servl
en)
{

int n;
char sendline[MAXLINE],recvline[MAXLINE+1];
while(fgets(sendline,MAXLINE,fp)!=NULL)
{
sendto(sockfd,sendline,strlen(sendline),0,pservaddr,servlen);
n=recvfrom(sockfd,recvline,MAXLINE,0,NULL,NULL);
recvline[n]=0;
fputs(recvline,stdout);

}
UDPSTRREV

#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<string.h>
#include<netinet/in.h>
#define SERV_PORT 64187
#define MAXLINE 1024

int main(int argc,char** argv)

{
int sockfd;
struct sockaddr_in cliaddr,servaddr;
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));
dg_echo(sockfd,(struct sockaddr*)&cliaddr,sizeof(cliaddr));
}

void dg_echo(int sockfd,struct sockaddr* pcliaddr,socklen_t clilen)

{
int n,i=0,j;
socklen_t len;
char msg[MAXLINE],revstr[MAXLINE];
for( ; ; )
{
len=clilen;
n=recv_from(sockfd,mesg,MAXLINE,0,pcliaddr,&len);
printf(" ");
j=n-1;
revstr[n]='\0';
while(msg[i]!='\0')
{
revstr[j]=-msg[i];
i++;
 j--;
}
printf("reversed string is %s\n",revstr);

}
}
UDPFSERV

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<fcntl.h>

#define MAXLINE 1024

#define MYPORT 56793

void getfile(int,struct sockaddr*,socklen_t,char*);

int main(int argc,char **argv)

{

int sd,retbind;
struct sockaddr_in sa,ca;

//if(argc!=4)
//printf("enter correct no of argumnets\n");

sd=socket(AF_INET,SOCK_DGRAM,0);

bzero(&sa,sizeof(sa));

sa.sin_family=AF_INET;
sa.sin_port=htons(MYPORT);
sa.sin_addr.s_addr=htonl(INADDR_ANY);
retbind=bind(sd,(struct sockaddr*)&sa,sizeof(sa));

getfile(sd,(struct sockaddr*)&ca,sizeof(ca),argv[1]);

void getfile(int sd,struct sockaddr* pca,socklen_t clen,char *fn)

{
int w,n,fd;
char msg[MAXLINE];
socklen_t len=clen;

fd=creat(fn,777);
do
{
n=recvfrom(sd,msg,MAXLINE,0,pca,&len);
w=write(fd,msg,n);

}while(n>0);

//printf("file is sent");

UDPFCLI

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<fcntl.h>

#define MAXLINE 1024

#define MYPORT 56793

void sendfile(int,struct sockaddr*,socklen_t,char*);

int main(int argc,char **argv)

{

int sd;
struct sockaddr_in sa;

if(argc!=4)
printf("enter correct no of argumnets\n");

bzero(&sa,sizeof(sa));

sa.sin_family=AF_INET;
sa.sin_port=htons(MYPORT);
inet_pton(AF_INET,argv[1],&sa.sin_addr);
sd=socket(AF_INET,SOCK_DGRAM,0);

sendfile(sd,(struct sockaddr*)&sa,sizeof(sa),argv[3]);

void sendfile(int sd,struct sockaddr* psa,socklen_t sel,char *fn)

{
int nr,nw,fd;
char buf[MAXLINE];

fd=open(fn,O_RDONLY,664);

do
{
nr=read(fd,buf,MAXLINE);
nw=sendto(sd,buf,nr,0,psa,sel);

}while(nr>0);

printf("file is sent");

TCPECHOSERVER

#include<stdlib.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<fcntl.h>
#define SERV_PORT 49613
#define MAXLEN 1024

int main(int argc,char **argv)

{

int retbind,listenfd,connfd,n;
struct sockaddr_in servaddr,cliaddr;
char buff[MAXLEN];
socklen_t clilen;

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);
retbind=bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr));

if(-1==retbind)
{
perror("BIND ERROR");
exit(1);
}

listen(listenfd,MAXLEN);
printf("listen accepted");

for( ; ; )
{
clilen=sizeof(cliaddr);
connfd=accept(listenfd,(struct sockaddr*)&cliaddr,&clilen);
while((n=read(listenfd,buff,MAXLEN))>0)
{
write(listenfd,buff,n);
}
close(connfd);
}
}
UDPFCLI

#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<error.h>
#include<netinet/in.h>
#include<string.h>
#define SERV_PORT 64290
#define MAXLINE 1024
void dg_ft(char*,int,const struct sockaddr*,socklen_t);

struct sockaddr_in servaddr;

int sockfd;

if(argc!=3)
{
printf("usage:udpcli <IPaddress>");
exit(1);
}

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);
dg_ft(argv[2],sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr));

exit(0);

void dg_ft(char* filename,int sockfd,const struct sockaddr

*pservaddr,socklen_t
servlen)

int fd,n_read,n_write,i;
 char buffer[MAXLINE];
fd=open(filename,O_RDWR,777);
n_read=read(fd,buffer,100);
i=strlen(buffer);
n_write=write(sockfd,buffer,i);
printf("file content is sent to server");
}

TCPUDPMULTIPLEXING

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/select.h>
#include<sys/time.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<fcntl.h>
#include<signal.h>
#define MAXLINE 1000
#define SERV_PORT 56792
void sig_child(int);
void str_echo(int);
int max(int,int);
int main(int argc,char **argv)
{

int listenfd,connfd,udpfd,nready,maxfdpl,n;
char msg[MAXLINE];
pid_t childpid;
fd_set rset;
ssize_t len;
const int on=1;
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);

setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on));
bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
listen(listenfd,5);

udpfd=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(udpfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
signal(SIGCHLD,sig_child);

FD_ZERO(&rset);

maxfdpl=max(listenfd,udpfd)+1;
for(;;)
{
FD_SET(listenfd,&rset);
FD_SET(udpfd,&rset);

if((nready=select(maxfdpl,&rset,NULL,NULL,NULL))<0)
{
if(errno==EINTR)
continue;
else
printf("select error");
}

if(FD_ISSET(listenfd,&rset))
{
len=sizeof(cliaddr);
connfd=accept(listenfd,(struct sockaddr*)&cliaddr,&len);

if((childpid=fork())==0)
{
close(listenfd);
str_echo(connfd);
exit(0);
}

close(connfd);

}
if(FD_ISSET(udpfd,&rset))
{
len=sizeof(cliaddr);
n=recvfrom(udpfd,msg,MAXLINE,0,(struct sockaddr*)&cliaddr,&len);

sendto(udpfd,msg,n,0,(struct sockaddr*)&cliaddr,len);
printf("data received %s",msg);
}
}
}
void str_echo(int sockfd)
{
ssize_t n;
char buf[1024];
again:
 while((n=read(sockfd,buf,1024))>0)
write(sockfd,buf,n);

if(n<0&&errno==EINTR)
goto again;

else if(n<0)
printf("str_echo:readerror");
else
printf("data is %s",buf);
}

void sig_child(int signo)

{
pid_t pid;
int stat;
pid=wait(&stat);
printf("child %s is terminated\n",pid);
return;
}

int max(int a,int b)

{
if(a>b)
return(a);
else
return(b);
}