NETWORKING LAB –LAB MANUAL

Experiment no :1 - tcp

server

#include<unistd.h>

int main()

char buf[100];

int k;

int sock_desc,temp_sock_desc;

socklen_t len;

struct sockaddr_in server,client;

sock_desc=socket(AF_INET,SOCK_STREAM,0);

if(sock_desc==-1){

printf("error in socketcreation");

server.sin_family=AF_INET;

server.sin_addr.s_addr=INADDR_ANY;

server.sin_port=3003;

client.sin_family=AF_INET;

client.sin_addr.s_addr=INADDR_ANY;

client.sin_port=3003;

k=bind(sock_desc,(struct sockaddr*)&server,sizeof(server));

if(k==-1){

printf("error in binding");}

k=listen(sock_desc,5);

if(k==-1)

{
printf("error in listening");

len=sizeof(client);

temp_sock_desc=accept(sock_desc,(struct sockaddr*)&client,&len);

if(temp_sock_desc==-1)

printf("error in socket cretaion");

k=recv(temp_sock_desc,buf,100,0);

if(k==-1){

printf("error in recieving");

printf("msg got from client :%s",buf);

close(temp_sock_desc);

return 0;

Client

#include<sys/socket.h>

#include<netinet/in.h>

#include<stdlib.h>

#include<string.h>

#include<stdio.h>

#include<unistd.h>

int main()

int k;

char buf[100];

int sock_desc;
struct sockaddr_in client;

sock_desc=socket(AF_INET,SOCK_STREAM,0);

if(sock_desc==-1)

printf("error in sockrt creation");

client.sin_family=AF_INET;

client.sin_addr.s_addr=INADDR_ANY;

client.sin_port=3003;

k=connect(sock_desc,(struct sockaddr*)&client,sizeof(client));

if(k==-1)

printf("error in connecting");

printf("\t enter the msg to be send: \t");

fgets(buf,100,stdin);

k=send(sock_desc,buf,100,0);

if(k==-1)

printf("error in sending");

close(sock_desc);

return 0;

Output :
Experiment no:2

UDP

Server

#include <stdio.h>

#include <strings.h>

#include <sys/types.h>

#include <arpa/inet.h>

#include <sys/socket.h>

#include<netinet/in.h>

#define PORT 5000

#define MAXLINE 1000

int main()

char buffer[100];

char *message = "wtsp client buddy";

int listenfd, len;

struct sockaddr_in servaddr, cliaddr;

bzero(&servaddr, sizeof(servaddr));

listenfd = socket(AF_INET, SOCK_DGRAM, 0);

servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

servaddr.sin_port = htons(PORT);

servaddr.sin_family = AF_INET;

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

len = sizeof(cliaddr);

int n = recvfrom(listenfd, buffer, sizeof(buffer) ,0, (struct sockaddr*)&cliaddr,&len);

puts(buffer);

sendto(listenfd, message, MAXLINE, 0,(struct sockaddr*)&cliaddr, sizeof(cliaddr));

}
Client

#include <stdio.h>

#include <strings.h>

#include <sys/types.h>

#include <arpa/inet.h>

#include <sys/socket.h>

#include<netinet/in.h>

#include<unistd.h>

#include<stdlib.h>

#define PORT 5000

#define MAXLINE 1000

int main()

char buffer[100];

char *message = "hey Server bro";

int sockfd, n;

struct sockaddr_in servaddr;

bzero(&servaddr, sizeof(servaddr));

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

servaddr.sin_port = htons(PORT);

servaddr.sin_family = AF_INET;

sockfd = socket(AF_INET, SOCK_DGRAM, 0);

if(connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)

printf("\n Error : Connect Failed \n");

exit(0);

sendto(sockfd, message, MAXLINE, 0, (struct sockaddr*)NULL, sizeof(servaddr));

puts(buffer);

close(sockfd);

Output:

Experiment no:3

Sliding window protocols

1.Stop and wait 2.GobackN 3. Selective Repeat

1. stop and wait

Server

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <arpa/inet.h>

#include <unistd.h>

#define PORT 8080

#define n 4

void stop_and_wait(int client_socket)

int seqNo = 0;

char ack[6];

int i=0;

int count = 1;

char exit[4] = {'e','x','i','t'};

while(1){

int noExit=0;

bzero(frame,100);

recv(client_socket,frame,sizeof(frame),0);

bzero(ack,6);

if(frame[0] == seqNo && count%n!=0){

ack[0] = 'A';

ack[1] = 'C';

ack[2] = 'K';

ack[3] = seqNo;

ack[4] = '\0';

printf("Frame received from client : ");

for(int j=1;frame[j]!='\0';j++) printf("%c",frame[j]);

printf("\n");

seqNo = seqNo==0?1:0;

else{

ack[0] = 'N';

ack[1] = 'A';

ack[2] = 'C';

ack[3] = 'K';

ack[4] = seqNo;
ack[5] = '\0';

sleep(1);

send(client_socket,ack,sizeof(ack),0);

for(int j=1;j<5;j++){

if(frame[j]!=exit[j-1]) {

noExit = 1;

break;

}}

if(noExit==0){

printf("Server has successfully exited the network ... \n");

return;

}count++;

}}

int main(){

int server_socket;

server_socket = socket(PF_INET,SOCK_STREAM,0);

if(server_socket<0){

printf("Error creating socket ...\n");

exit(1);}

else{

printf("Socket created successfully ...\n");

struct sockaddr_in sa;

bzero(&sa,sizeof(sa));

sa.sin_family = PF_INET;

sa.sin_port = htons(PORT);

sa.sin_addr.s_addr = inet_addr("127.0.0.7");
if( bind(server_socket,(struct sockaddr*)&sa, sizeof(sa))== 0){

printf("Socket binded successfully ...\n");

else{

printf("Unable to bind server... An error occured\n");

exit(1);

if (listen(server_socket,10)==0){

printf("Server listening...\n");

else{

printf("Server listen failed\n");

struct sockaddr_in cli;

int len = sizeof(cli);

int client_socket = accept(server_socket,(struct sockaddr*)&cli,&len);

if(client_socket<0){

printf("Falied to accept client\n");

exit(1);

else{

printf("Server accepted client\n");

stop_and_wait(client_socket);

close(server_socket);

}
Client

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <arpa/inet.h>

#include <unistd.h>

#define PORT 8080

void stop_and_wait(int client_socket){

char frame[100];

int seqNo = 0;

char ack[6];

int i=0;

int next = 1;

char exit[4] = {'e','x','i','t'};

while(1){

int noExit = 0;

if(next==1){

bzero(frame,100);

i=1;

printf("\nEnter message to server : ");

while((frame[i++]=getchar())!='\n');

frame[i-1]='\0';

frame[0] = seqNo;

sleep(1.5);
send(client_socket,frame,sizeof(frame),0);

bzero(ack,6);

recv(client_socket,ack,sizeof(ack),0); //Receive ack

if(ack[0]=='A')

printf("Acknowledgement received from server for frame %d - [",seqNo);

for(int j=1;frame[j]!='\0';j++) printf("%c",frame[j]);

printf("]\n");

seqNo = seqNo==0?1:0;

next = 1;

else{

next = 0;

printf("Negatve acknowledgement received from server for frame %d - [",seqNo);

for(int j=1;frame[j]!='\0';j++) printf("%c",frame[j]);

printf("]\nResending frame %d - [",seqNo);

for(int j=1;frame[j]!='\0';j++) printf("%c",frame[j]);

printf("]\n");

for(int j=1;j<5;j++){

if(frame[j]!=exit[j-1]) {

noExit = 1;

break;

}}

if(noExit==0){

printf("Client has successfully exited the network ... \n");

return;

}}
int main(){

int client_socket;

client_socket = socket(PF_INET,SOCK_STREAM,0);

if(client_socket<0){

printf("Error creating socket\n");

exit(1);

else{

printf("Socket creation successful\n");

struct sockaddr_in sa,cli;

bzero(&sa,sizeof(sa));

sa.sin_family = PF_INET;

sa.sin_port = htons(PORT);

sa.sin_addr.s_addr = inet_addr("127.0.0.7");

if(connect(client_socket,(struct sockaddr*)&sa,sizeof(sa))==0){

printf("Connected to server\n");

else{

printf("Connection failure\n");

stop_and_wait(client_socket);

close(client_socket);

return 0;

Output
2.Go Back N

Server

#include<stdio.h>

#include<string.h>

#include<sys/types.h>

#include<netinet/in.h>

#include<netdb.h>

#include<unistd.h>

//structure definition for designing the packet.

struct frame

int packet[40];

};

//structure definition for accepting the acknowledgement.

struct ack

int acknowledge[40];

};

int main()
{

int serversocket;

struct sockaddr_in serveraddr,clientaddr;

socklen_t len;

struct frame f1;

int windowsize,totalpackets,totalframes,i=0,j=0,framesend=0,k,l,buffer;

struct ack acknowledgement;

char req[50];

serversocket=socket(AF_INET,SOCK_DGRAM,0);

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

serversocket=socket(AF_INET,SOCK_DGRAM,0);

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

serveraddr.sin_family=AF_INET;

serveraddr.sin_port=htons(5018);

serveraddr.sin_addr.s_addr=INADDR_ANY;

bind(serversocket,(struct sockaddr*)&serveraddr,sizeof(serveraddr));

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

len=sizeof(clientaddr);

//connection establishment.

printf("\nwaiting for client connection");

recvfrom(serversocket,req,sizeof(req),0,

(struct sockaddr*)&clientaddr,&len);

printf("\nThe client connection obtained\t%s\n",req);

//sending request for windowsize.

printf("\nSending request for window size\n");

sendto(serversocket,"REQUEST FOR WINDOWSIZE",sizeof("REQUEST FOR WINDOWSIZE"),0,

(struct sockaddr*)&clientaddr,sizeof(clientaddr));

//obtaining windowsize.
printf("Waiting for the window size\n");

recvfrom(serversocket,(char*)&windowsize,sizeof(windowsize),0,

(struct sockaddr*)&clientaddr,&len);

printf("\nThe window size obtained as:\t %d \n",windowsize);

printf("\nObtaining packets from network layer \n");

printf("\nTotal packets obtained :%d\n",(totalpackets=windowsize*5));

printf("\nTotal frames or windows to be transmitted :%d\n",(totalframes=5));

//sending details to client.

printf("\nSending total number of packets \n");

sendto(serversocket,(char*)&totalpackets,sizeof(totalpackets),0,

(struct sockaddr*)&clientaddr,sizeof(clientaddr));

recvfrom(serversocket,req,sizeof(req),0,

(struct sockaddr*)&clientaddr,&len);

printf("\nSending total number of frames \n");

sendto(serversocket,(char*)&totalframes,sizeof(totalframes),0,

(struct sockaddr*)&clientaddr,sizeof(clientaddr));

recvfrom(serversocket,req,sizeof(req),0,

(struct sockaddr*)&clientaddr,&len);

printf("len=%d",len);

printf("\n Press enter to start the process \n");

fgets(req,2,stdin);

//starting the process of sending

while(i<totalpackets)

//initialising the transmit buffer.

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

printf("\nInitializing the transmit buffer \n");

printf("\n The frame to be send is %d with packets:",framesend);

j=0;

//Builting the frame.

while(j<windowsize && i<totalpackets)

printf("%d",i);

f1.packet[j]=i;

j++;

i++;

printf("sending frame %d\n",framesend);

//sending the frame.

sendto(serversocket,(char*)&f1,sizeof(f1),0,

(struct sockaddr*)&clientaddr,sizeof(clientaddr));

//Waiting for the acknowledgement.

printf("Waiting for the acknowlegment\n");

recvfrom(serversocket,(char*)&acknowledgement,sizeof(acknowledgement),0,

(struct sockaddr*)&clientaddr,&len);

//Checking acknowledgement of each packet.

j=0;

k=0;

l=buffer;

while(j<windowsize && l<totalpackets)

if(acknowledgement.acknowledge[j]==-1)

printf("\nnegative acknowledgement received for packet:%d \n",f1.packet[j]);

printf("\nRetransmitting from packet:%d \n",f1.packet[j]);

i=f1.packet[j];

k=l;

break;

j++;

l++;

if(k==0)

printf("\n Positive acknowledgement received for all packets,within the frame:%d

framesend++;

printf("\n press enter to proceed \n");

fgets(req,2,stdin);

printf("\nAll frames sends successfully\n Closing connection with the client \n");

close(serversocket);

Client

#include <stdio.h>

#include <sys/types.h>

#include <netinet/in.h>

#include <netdb.h>

#include <string.h>

#include <unistd.h>

//structure definition for accepting the packets.

struct frame
{

int packet[40];

};

//structure definition for constructing the acknowledgement frame

struct ack

int acknowledge[40];

};

int main()

int clientsocket;

struct sockaddr_in serveraddr;

socklen_t len;

//struct hostent *server;

struct frame f1;

int windowsize,totalpackets,totalframes,i=0,j=0,framesreceived=0,k,l,buffer;

struct ack acknowledgement;

char req[50];

clientsocket=socket(AF_INET,SOCK_DGRAM,0);

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

serveraddr.sin_family=AF_INET;

serveraddr.sin_port=htons(5018);

serveraddr.sin_addr.s_addr = inet_addr("127.0.0.1");

//server=gethostbyname("127.0.0.1");

//bcopy((char*)server->h_addr,(char*)&serveraddr.sin_addr.s_addr,

//sizeof(server->h_addr));

//establishing the connection.

printf("sending request to the server\n");

(struct sockaddr*)&serveraddr,sizeof(serveraddr));

printf("\nWaiting for reply\n");

recvfrom(clientsocket,req,sizeof(req),0,

(struct sockaddr*)&serveraddr,&len);

printf("\n The server has to send :\t%s\n",req);

//accepting window size from the user.

printf("\nenter the window size\n");

scanf("%d",&windowsize);

//sending the window size.

printf("\n sending window size\n");

sendto(clientsocket,(char*)&windowsize,sizeof(windowsize),0,

(struct sockaddr*)&serveraddr,sizeof(serveraddr));

//collecting details from server.

printf("\n waiting for the server response\n");

recvfrom(clientsocket,(char*)&totalpackets,sizeof(totalpackets),0,

(struct sockaddr*)&serveraddr,&len);

printf("\nTotal packets are :\t%d\n",totalpackets);

sendto(clientsocket,"RECEIVED",sizeof("RECEIVED"),0,

(struct sockaddr*)&serveraddr,sizeof(serveraddr));

recvfrom(clientsocket,(char*)&totalframes,sizeof(totalframes),0,

(struct sockaddr*)&serveraddr,&len);

printf("len=%d",len);

printf("\n total number of frames or windows are:\t%d\n",totalframes);

sendto(clientsocket,"RECEIVED",sizeof("RECEIVED"),0,

(struct sockaddr*)&serveraddr,sizeof(serveraddr));

//starting the process.

printf("\nstarting the process of receiving\n");

//initialising the receive buffer.

printf("\nInitializing the received buffer\n");

printf("\nThe expected frame is %d with packets:",framesreceived);

j=0;

buffer=i;

while(j<windowsize && i<totalpackets)

printf("%d",i);

i++;

j++;

printf("\nwaiting for the frame\n");

//accepting the frame.

recvfrom(clientsocket,(char*)&f1,sizeof(f1),0,

(struct sockaddr*)&serveraddr,&len);

printf("\n received frame %d\n\n enter -1 to send negative acknowledgement for the
following packets \n",framesreceived);

//constructing the acknowledgement frame.

j=0;

l=buffer;

k=0;

while(j<windowsize && l<totalpackets)

printf("\npacket:%d\n",f1.packet[j]);

//accepting acknowledgement from the user

if(k==0)

{
scanf("%d",&acknowledgement.acknowledge[j]);

if(acknowledgement.acknowledge[j]==-1)

i=f1.packet[j];

k=1;

}}

j++;

l++;

framesreceived++;

sendto(clientsocket,(char*)&acknowledgement,sizeof(acknowledgement),0,

(struct sockaddr*)&serveraddr,sizeof(serveraddr));

printf("\nall frames received successfully\n closing connection with the server\n");

close(clientsocket);

Output:
Experiment NO: 4

File transfer protocol

Server

#include<stdio.h>

#include<sys/types.h>

#include <string.h>

#include <arpa/inet.h>

#include <netinet/in.h>

#include <stdlib.h>

#include <unistd.h>

#define max 1024

void write1(int sockfd){

FILE *fp;

char buffer[max];

char *filename="recv1.txt";

fp=fopen(filename,"w");

while(1){

if(recv(sockfd,buffer,sizeof(buffer),0)<=0) {

break;

return;

else {

fprintf(fp,"%s",buffer);

bzero(buffer,max);

}}

return;

}
int main() {

char *ip="127.0.0.1";

int port=8080;

int e,d;

socklen_t addr_size;

int sockfd,newsock;

struct sockaddr_in serveraddr,cliaddr;

sockfd=socket(AF_INET,SOCK_STREAM,0);

if(sockfd<0){

printf("Socket Creation failure\n");

exit(1);

else {

printf("Socket Creation Successfully\n");

serveraddr.sin_family=AF_INET;

serveraddr.sin_port=port;

serveraddr.sin_addr.s_addr=inet_addr(ip);

e=bind(sockfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr));

if(e<0){

printf("Binding Unsecussefull\n");

exit(1);

else {

printf("Binding Successfull\n");

} if(listen(sockfd, 10) == 0){

else{

perror("[-]Error in listening");

exit(1);

} addr_size=sizeof(cliaddr);

newsock=accept(sockfd,(struct sockaddr*)&cliaddr,&addr_size);

printf("newsock=%d",newsock);

write1(newsock);

printf("Data written in the file successfully");

return 0;

Client

#include<stdio.h>

#include<stdlib.h>

#include <sys/types.h>

#include <string.h>

#include <strings.h>

#include <sys/socket.h>

#include <arpa/inet.h>

#include <netinet/in.h>

#include <unistd.h>

#define max 1024

void send1(int sockfd,FILE *fp){

char data[max]= {0};

while(fgets(data,max,fp)!=NULL){

if(send(sockfd,data,sizeof(data),0)==-1){
 printf("Error in sending");

bzero(data,max);

}}

int main() {

FILE *fp;

char *ip="127.0.0.1";

int port=8080;

int e;

// struct sockaddr_in serveraddr;

int sockfd;

char *filename="send1.txt";

sockfd=socket(AF_INET,SOCK_STREAM,0);

if(sockfd==-1){

printf("Error in socket creation");

exit(1);

else {

printf("Socket created succesfully\n");

struct sockaddr_in serveraddr;

serveraddr.sin_family=AF_INET;

serveraddr.sin_port=port;

serveraddr.sin_addr.s_addr=inet_addr(ip);

e=connect(sockfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr));

if(e<0) {
 printf("connection failure");

exit(1);

else {

printf("connection established succesfully\n");

fp=fopen(filename,"r");

if (fp == NULL) {

perror("[-]Error in reading file.");

exit(1);

send1(sockfd,fp);

printf("File transferred successfully\n");

close(sockfd);

return 0;

Output:
Experiment no:5

Distance vector Algorithm

#include<stdio.h>

#include<string.h>

struct node {

unsigned dist[20];

unsigned from[20];

}rt[10];

int main() {

int n,i,j,k,count;

int cost[20][20];

printf("Enter the no of nodes:");

scanf("%d",&n);

printf(" Enter the cost matrix:");

for(i=0;i<n;i++) {

for(j=0;j<n;j++) {

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

cost[i][i]=0;

rt[i].dist[j]=cost[i][j];

rt[i].from[j]=j;

do {

count=0;

for(i=0;i<n;i++) {

for(j=0;j<n;j++) {

for(k=0;k<n;k++) {
 if(rt[i].dist[j]>cost[i][k]+rt[k].dist[j]){

//calculate minimum distance

rt[i].dist[j]=rt[i].dist[k]+rt[k].dist[j];

rt[i].from[j]=k;

count++;

}while(count!=0);

for(i=0;i<n;i++) {

printf("For Router %d\n",i+1);

for(j=0;j<n;j++) {

printf("\t\nnode%d via%d dist%d\n",j+1,rt[i].from[j]+1,rt[i].dist[j]);

printf("\n\n");

Output:
Experiment No:6

Leaky Bucket

#include<stdio.h>

int main(){

int incoming, outgoing, buck_size, n, store = 0;

printf("Enter bucket size, outgoing rate and no of inputs: ");

scanf("%d %d %d", &buck_size, &outgoing, &n);

while (n != 0) {

printf("Enter the incoming packet size : ");

scanf("%d", &incoming);

printf("Incoming packet size %d\n", incoming);

if (incoming <= (buck_size - store)){

store += incoming;

printf("Bucket buffer size %d out of %d\n", store, buck_size);

} else {

printf("Dropped %d no of packets\n", incoming - (buck_size - store));

printf("Bucket buffer size %d out of %d\n", store, buck_size);

store = buck_size;

store = store - outgoing;

printf("After outgoing, %d packets left out of %d in buffer\n", store, buck_size);

n--;

Output: