UDP ECHO SERVER

PROGRAM:

SERVER SIDE:

#include<stdio.h>

#include<unistd.h>

#include<sys/types.h>

#include<netinet/in.h>

#include<string.h>

#include<sys/socket.h>

#define LOCAL_SERVER_PORT 1500

#define MAX_MSG100

int main(int argc.char *argv[])

{

Int sd,rc,n,clien;

Struct sockaddr_in cliaddr,servaddr;

Char msg[MAX_MSG];

Sd=socket[AF_INET<SOCK_DGRAM,0);

If(sd>0)

{

Printf(“%s cannot open socket\n”,argv[0]);

Exit(0);

}

Servaddr.sin_family=AF_INET;

Servaddr.sin_addr.s_addr=hton1(INADDR_ANY);

Servaddr.sin_port=htons(local_server_port);

Rc=bind(sd,struct sockaddr *)eservaddr,sizeof(servaddr));

If(rc<0)

{

Printf(“%s:cannot bind port number %d \n”);

Argv[0],local_server_port);

Exit(0);

}

if(n<0)

{printf(“%s :cannot receive data\n”);

Continue;

}

Print(“received message is %s”,mag);

}

Return 0;

}

CLIENT SIDE:

#include<stdio.h>

#include<string.h>

#include<sys/types.h>

#include<netinet/in.h>

#include<sys/socket.h>

#define REMOTE_SERVER_PORT 1500

#define MAX_MSG100

Int main(int argc,char *argv[])

{

Int sd,rc,I;

Struct sockaddr_in cliaddr,remote servaddr;

Struct hostenet *h;

If(argc<3)

{

Printf(“usage:%s<server><data1>----<data>\n”.argv[0]);

Exit(1);

}

H=gethostbyname(argv[1]);

TCP SOCKET

PROGRAM:

SERVER SIDE:

#include<stdio.h>

#include<unistd.h>

#include<sys/types.h>

#include<netinet/in.h>

#include<string.h>

#include<sys/socket.h>

int main(int argc.char *argv[])

{

 Int sockfd,portno,new sockfd,clien,n;

Struct sockaddr_in serv_addr,cliaddr;

Struct hostent *server;

Char buffer[256];

If(argc<2)

{

Fprintf(stderr,*error no port provided”);

Exit(1);

}

Sockfd=socket(AF_INET,SOCK_STREAM,0);

If(sockfd,0)

Printerror(”\n error binding”);

Listen(sockfd,s);

Clien=sizeof(cliaddr);

Newsockfd=accept(sockfd,(struct sockaddr*)&cliaddr,&client);

If(newsockfd<0)

Printerror(”\n error on accept”);

Bzero(buffer,256);

N=read(newsockfd,buffer,255);

If(n<0)

Perror(”error reading from the socket”);

Printf(”message %s”,buffer);

N=write(new sockfd,buffer,50);

If(n<0)

Printerror(”\n error waiting to socket”);

Return 0;

Int printerror(char *msg)

{

Perror(msg);

Exit(1);

}

CLIENT SIDE:

#include<stdio.h>

#include<string.h>

#include<sys/types.h>

#include<netinet/in.h>

#include<sys/socket.h>

Int main(int argc,char *argv[])

{

Int sockfd,portno,n;

Struct sockaddr_in serv_addr;

Struct hostent *server;

Char buffer[256];

If(argc<3)

{

Fprintf(stderr,”type%s follwed by host name and then port no(n,”argv[0]);

exit(0);

}

Port no=atoi(argv[2]);

Sockfd=socket[AF_INET,SOCK_STREAM,0);

If(sockfd<0)

Printerror(“error opening socket”);

Server=gethost by name(argv[1]);

OPEN SHORTEST PATH FIRST PROTOCOL

PROGRAM:

#iinclude<stdio.h>

#include<string.h>

int main()

{

int count,src_router,i,j,k,w,v,min;

int cost_matrix[100][100],dist[100],last[100];

int flag[100];

printf("\n Enter the no of routers");

scanf("%d",&count);

printf("\n Enter the cost matrix values:");

for(i=0;i<count;i++)

{

for(j=0;j<count;j++)

{

printf("\n%d->%d:",i,j);

scanf("%d",&cost_matrix[i][j]);

if(cost_matrix[i][j]<0)

cost_matrix[i][j]=1000;

}

}

printf("\n Enter the source router:");

scanf("%d",&src_router);

for(v=0;v<count;v++)

{

flag[v]=0;

last[v]=src_router;

dist[v]=cost_matrix[src_router][v];

}

flag[src_router]=1;

for(i=0;i<count;i++)

{

min=1000;

for(w=0;w<count;w++)

{

if(!flag[w])

if(dist[w]<min){

v=w;

min=dist[w];

}

}

flag[v]=1;

for(w=0;w<count;w++)

{

if(!flag[w])

if(min+cost_matrix[v][w]<dist[w])

{

dist[w]=min+cost_matrix[v][w];

last[w]=v;

}

}

}

SOCKET APPLICATION PROGRAM FOR ARP AND RARP

SERVER SIDE:

#include<stdio.h>

#include<netdb.h>

#include<netinet/in.h>

#include<sys/types.h>

#include<sys/socket.h>

#include<errno.h>

int main(int argc,char **argv)

{

struct sockaddr_in saddr,caddr;

struct hostent *server;

int n,i,len,ssid,csid,pid,pi;

char wbuffer[1024],rbuffer[1024];

char a[20][20]={"12312","23211","43211","32122","23122"};

char b[20][20]={"12.12.12.12","33.22.22.22","45.34.22.33","23.33.11.22","64.45.3

2.54"};

float c;

if(argc<2)

fprintf(stderr,"port number not specified \n");

ssid=socket(AF_INET,SOCK_STREAM,0);

if(csid<0)

perror("socket failed \n");

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

saddr.sin_family=AF_INET;

saddr.sin_port=htons(atoi(argv[1]));

saddr.sin_addr.s_addr=INADDR_ANY;

if(bind(ssid,(struct sockaddr*)&saddr,sizeof(saddr))<0)

perror("socket bind \n");

listen(ssid,5);

len= sizeof (caddr);

while(1)

{

csid=accept(ssid,(struct sockaddr*)&caddr,&len);

if(csid<0)

perror("socket accept");

fprintf(stdout,"type message to client: \n");

pid=fork();

if(pid==0)

{

close(ssid);

bzero(rbuffer,1024);

n=read(csid,rbuffer,1024);

if(n==0)

perror("socket read \n");

else

fprintf(stdout,"message from client %s\n",rbuffer);

for(i=0;i<5;i++)

{

if(!strncmp(a[i],rbuffer,5))

{

n=write(csid,b[i],1024);

break;

}

else if(!strncmp(b[i],rbuffer,5))

{

n=write(csid,a[i],5);

break;

}

else if(strncmp(b[i],rbuffer,5))

{

n=write(csid,"invalid no",10);

break;

}

}

exit(0);

}

else

close(csid);

}

}

CLIENT SIDE:

#iinclude<stdio.h>

#include<netdb.h>

#include<netinet/in.h>

#include<sys/types.h>

#include<sys/socket.h>

#include<errno.h>

int main(int argc,char **argv)

{

struct sockaddr_in saddr;

struct hostent *server;

int n,ssid,csid,pid,pi;

char wbuffer[1024],rbuffer[1024];

char str[15];

if(argc<3)

fprintf(stderr,"parameter inadiquate \n");

csid=socket(AF_INET,SOCK_STREAM,0);

CLIENT TO RESOLVE A GIVEN HOSY NAME FROM DNS SERVER

SERVER SIDE:

#include<stdio.h>

#include<sys/socket.h>

#include<sys/types.h>

#include<arpa/inet.h>

#include<netinet/in.h>

#include<string.h>

#include<netdb.h>

#include<stdlib.h>

#include<unistd.h>

int main()

{

int a,c,clisize,size;

int sersock,newsock,n;

struct sockaddr_in seraddr,clinfo;

char str1[25],str2[100];

char host[25];

struct hostent *hp;

seraddr.sin_family=AF_INET;

seraddr.sin_port=htons(2005);

seraddr.sin_addr.s_addr=htonl(INADDR_ANY);

if((sersock=socket(AF_INET,SOCK_STREAM,0))<0)

{

perror("can not creat Socket");

exit(0);

}

bind(sersock,(struct sockaddr*)&seraddr,sizeof(seraddr));

listen(sersock,5);

clisize=sizeof(clinfo);

if((newsock=accept(sersock,(struct sockaddr*)&clinfo,&size))<0)

{

perror("ACCEPT");

exit(0);

}

printf("\n connected to %s",inet_ntoa(clinfo.sin_addr));

read(newsock,host,sizeof(host));

printf("%s",host);

hp=gethostbyname(host);

inet_ntop(AF_INET,hp->h_addr,str2,sizeof(str2));

printf("%s",str2);

write(newsock,str2,strlen(str2)+1);

close(newsock);

close(sersock);

return 0;

}

CLIENT SIDE:

#include<stdio.h>

#include<sys/socket.h>

#include<sys/types.h>

#include<arpa/inet.h>

#include<netinet/in.h>

#include<unistd.h>

#include<netdb.h>

#include<stdlib.h>

#include<string.h>

int main(int argc,char *argv)

{

int len;

int sockfd,n;

struct sockaddr_in servaddr,cliaddr;

char buff[1024];

char str[1000];

sockfd=socket(AF_INET,SOCK_STREAM,0);

if(sockfd<0)

perror("can not create socket");

bzero(&servaddr,sizeof(servaddr));

servaddr.sin_port=htons(2005);

servaddr.sin_family=AF_INET;

servaddr.sin_addr.s_addr=inet_addr("20.30.1.211");

SIMULATON OF SLIDING WINDOW PROTOCOL

SERVER SIDE:

#include<stdio.h>

#include<sys/types.h>

#include<sys/socket.h>

#include<netinet/in.h>

#include<string.h>

int main(int argc,char **argv)

{

int len;

int listenfd,connfd,n;

struct sockaddr_in servaddr,cliaddr;

char b[1024];

char c[1000];

listenfd=socket(AF_INET,SOCK_STREAM,0);

if(listenfd<0)

perror("cannot create socket");

bzero(&servaddr,sizeof(servaddr));

servaddr.sin_family=AF_INET;

servaddr.sin_addr.s_addr=inet_addr("20.30.1.211");

servaddr.sin_port=htons(20064);

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

listen(listenfd,5);

len=sizeof(cliaddr);

connfd=accept(listenfd,(struct sockaddr*)&cliaddr,&len);

if(connfd>0)

printf("\n connection established");

do

{

n=read(connfd,b,1024);

printf("\n reeive data %s",b);

printf("\n your acknowledgement[yes=1,no=0]:");

scanf("%s",c);

n=write(connfd,c,1024);

}while(1);

close(connfd);

close(listenfd);

return 0;

}

CLIENT SIDE:

#include<stdio.h>

#include<sys/types.h>

#include<sys/socket.h>

#include<netinet/in.h>

#include<string.h>

int main(int arg,char **argv)

{

int len;

int sockfd,n,m,p;

struct sockaddr_in servaddr,cliaddr;

char buff[1024];

char buff1[1000];

char str[1000];

char d[10]={'a','b','c','d','e','f','g','h','i','j'};

int count[10],ack[10];

int i,j,k;

for(k=0;k<10;k++)

{

count[k]=0;

ack[k]=0;

}

CLIENT SERVER APPLICATION FOR CHAT

SERVER SIDE:

#include<stdio.h>

#include<sys/types.h>

#include<sys/socket.h>

#include<netinet/in.h>

#include<string.h>

int main(int argc,char **argv)

{

int len;

int listenfd,connfd,n;

int i,j,k=0,l,count=0;

struct sockaddr_in servaddr,cliaddr;

char buff[1024];

char str[1000];

listenfd=socket(AF_INET,SOCK_STREAM,0);

if(listenfd<0)

perror("cant create socket");

bzero(&servaddr,sizeof(servaddr));

servaddr.sin_family=AF_INET;

servaddr.sin_addr.s_addr=INADDR_ANY;

servaddr.sin_port=htons(20060);

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

listen(listenfd,5);

len=sizeof(cliaddr);

connfd=accept(listenfd,(struct sockaddr *)&cliaddr,&len);

n=read(connfd,buff,1024);

printf("\n received message is %s\t",buff);

l=strlen(buff);

for(i=0;i<l;i++)

{

if(buff[i]=='l')

{

k=i;

count=0;

while(buff[k]=='l')

{

count++;

k++;

if(count==5)

{

for(j=k;j<l-1;j++)

buff[j]=buff[j+1];

l--;

buff[l]=='\0';

break;

}

i=k;

}

}

}

printf("\n unstuffed string is %s\n",buff);

close(connfd);

return 0;

}

CLIENT SIDE:

#include<stdio.h>

#include<sys/types.h>

#include<sys/socket.h>

#include<netinet/in.h>

#include<string.h>

int main(int argc,char **argv)

{

int len;

int sockfd,n,connfd;

int l,k=0,i,j,count=0;

struct sockaddr_in servaddr,cliaddr;

char buff[1024];

char str[1000];

sockfd=socket(AF_INET,SOCK_STREAM,0);