Computer Networks Programs

8/3/2019 Computer Networks Programs

http://slidepdf.com/reader/full/computer-networks-programs 1/25

COMPUTER NETWORKS

Q1. SIMULATE CYCLIC REDUNDANCY CHECK (CRC)

#include<iostream.h>#include<conio.h>

#include<math.h>

#include<stdlib.h>

#include<graphics.h>

#include<DOS.h>

int digitinbin(int number)

{ int i=0;

int n=number;

while(n!=0)

{ n=n/2;

i++;

}return i;

}

int bintodec(int *a,int d)

{ int num=0;

for(int i=0;i<d;i++)

{ if(a[i]==1)

num=num+pow(2,i);

}

return num;

}

int* dectobin(int n)

{ int *A=new int[32];

int i=0;

int num=n;

while(num!=0)

{ A[i]=num%2;

num=num/2;

i++;

}

return A;

}

int sender(int mess,int poly){ int k=0,num1;

int d1=digitinbin(poly);

mess=mess*pow(2,d1-1);

int d2=digitinbin(mess);

int *B=dectobin(mess);

int counter=0;

int times=d2-d1+1;



int *temp=new int[d1];

int a=pow(2,d1-1);

while(counter<times)

{ int j=0;

if(counter==0)

{

for(int i=times-counter-1;i<d2-counter;i++)

{ temp[j]=B[i];

j++;

}

num1=bintodec(temp,j);

}

int num2=poly;

if(counter!=0)

num1=k;

if(num1>=a)

k=num1^num2;

elsek=num1;

if(d2-d1-counter-1>=0)

{

if(B[d2-d1-counter-1]==1)

k=k*2+1;

else

k=k*2;

}

counter++;

}

return (k^mess);}

void receiver(int mess,int poly)

{ int k=0,num1;

int d1=digitinbin(poly);

int d2=digitinbin(mess);

int *B=dectobin(mess);

int counter=0;

int times=d2-d1+1;

int *temp=new int[d1];

int a=pow(2,d1-1);

while(counter<times)

{ int j=0;

if(counter==0)

{

for(int i=times-counter-1;i<d2-counter;i++)

{ temp[j]=B[i];

j++;

}

num1=bintodec(temp,j);



}

int num2=poly;

if(counter!=0)

num1=k;

if(num1>=a)

k=num1^num2;

else

k=num1;

if(d2-d1-counter-1>=0)

{

if(B[d2-d1-counter-1]==1)

k=k*2+1;

else

k=k*2;

}

counter++;

}if(k==0)

cout<<"MESSAGE TRANSMITTED SUCCESSFULLY\n"<<endl;

else

cout<<"ERROR IN TRANSMISSION\n"<<endl;

}

void main()

{ clrscr();

int message,genpoly,ch=1;

cout<<"enter the number to be transmitted"<<endl;

cin>>message;

cout<<"Enter the generator polynomial number"<<endl;cin>>genpoly;

int gp=sender(message,genpoly);

while(ch==1 || ch==2)

{

cout<<"MENU"<<endl;

cout<<"1-SUCCESSFUL TRANSMISSION"<<endl;

cout<<"2-ERROR IN TRANSMISSION"<<endl;

cout<<"PRESS ANY OTHER KEY TO EXIT"<<endl;

cout<<"Enter your choice"<<endl;

cin>>ch;

if(ch==1)

{ cout<<"TRANSMITTING MESSAGE .......\n"<<endl;

delay(5000);

receiver(gp,genpoly);

int *B=dectobin(message);

int dig=digitinbin(message);

cout<<"The transmitted message is ";

for(int i=dig-1;i>=0;i--)



cout<<B[i];

cout<<"\n"<<endl;

}

else

if(ch==2)

{ cout<<"TRANSMITTING MESSAGE .......\n"<<endl;

delay(5000);

receiver(gp+1,genpoly);

cout<<endl;

}

}

cout<<"PROGRAM ENDS"<<endl;

getch();

}

OUTPUT

enter the number to be transmitted

729

Enter the generator polynomial number

19

MENU

1-SUCCESSFUL TRANSMISSION

2-ERROR IN TRANSMISSION

PRESS ANY OTHER KEY TO EXIT

Enter your choice

1

TRANSMITTING MESSAGE .......

MESSAGE TRANSMITTED SUCCESSFULLY

The transmitted message is 1011011001

MENU




Enter your choice

2

TRANSMITTING MESSAGE .......

ERROR IN TRANSMISSION

MENU






Enter your choice

4

PROGRAM ENDS

Q2. SIMULATE DISTANCE VECTOR ROUTING

# include <iostream.h>

# include <conio.h>

# include <stdio.h>

# include <string.h>

class router

{

private:

char name[20];

int dist[10];

public:

void get_r_table (int , int);

friend void find_table (router *);

};

void find_table (router *);

int total_r;



int adj;

char names[10][20];

char N[20];

void router :: get_r_table (int no , int flag)

{

if ( flag == 1 )

{

cout << "Enter the name of the adjacent router "

<< no << " : ";

gets (name);

}

else

strcpy (name , N);

cout << "Enter the distances of each router from this

router :\n";

cout << "\tROUTER\tDISTANCE\n";cout << "\t------\t--------\n";

for (int i = 0 ; i < total_r ; i++)

{

cout << "\t" << names[i] << "\t";

if ( strcmp ( names[i] , name ) == 0 )

{

dist[i] = 0;

cout << dist[i] << "\n";

}

else

cin >> dist[i];}

}

void find_table(router *r)

{

cout << "Routing table for router " << N << " :-\n";

cout << "\tRouter\tDistance\n";

cout << "\t------\t--------\n";

for ( int i = 0 ; i < total_r ; i++ )

{

int temp;

if ( strcmp (N , names[i] ) == 0 )

temp = 0;

else

{

temp = r[0].dist[i];

for ( int j = 1 ; j < adj + 1 ; j++ )



if ( r[j].dist[i] < temp &&

r[j].dist[i] != 0 )

temp = r[j].dist[i] + r[0].dist[j];

}

r[0].dist[i] = temp;

// r[0] contains data of the router whose routing table is

to be found out

}

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

{

cout << "\t" << names[i] << "\t";

cout << r[0].dist[i] << "\n";

}

}

void main()

{ router r[10];

clrscr();

cout << "Enter the total no of routers in the subnet

[MAX 10] :- ";

cin >> total_r;

cout << "Enter the names of all the routers :-\n";

for (int i = 0 ; i < total_r ; i++)

{

cout << "\t" << i + 1 << " . ";

gets (names[i]);}

cout << "Enter the router whose routing table is to be

found out : ";

gets (N);

cout << "Enter the no of routers adjacent to this

router : ";

cin >> adj;

int flag = 0;

for ( i = 0 ; i < adj + 1; i++ )

{

r[i].get_r_table (i , flag);

flag = 1;

}

find_table (r);

getch();

}



OUTPUT

Enter the total no of routers in the subnet [MAX 10] :- 6Enter the names of all the routers :-

1 . A

2 . B

3 . C

4 . D

5 . E

6 . F

Enter the router whose routing table is to be found out : C

Enter the no of routers adjacent to this router : 3

Enter the distances of each router from this router :

ROUTER DISTANCE

------ --------A 11

B 6

C 0

D 3

E 5

F 6

Enter the name of the adjacent router 1 : B


ROUTER DISTANCE

------ --------

A 5

B 0

C 8

D 12

E 6

F 2

Enter the name of the adjacent router 2 : D


ROUTER DISTANCE

------ --------

A 16

B 12

C 6D 0

E 9

F 10

Enter the name of the adjacent router 3 : E


ROUTER DISTANCE



------ --------

A 7

B 6

C 3

D 9

E 0

F 1

Routing table for router C :-

Router Distance

------ --------

A 10

B 6

C 0

D 3

E 5

F 4



Q3. SIMULATE GO BACK N PROTOCOL


# include <conio.h>

# include <stdlib.h>

# include <time.h>

# include <math.h>

# define TOT_FRAMES 500

# define FRAMES_SEND 10

class gobkn{

private:

int fr_send_at_instance;

int arr[TOT_FRAMES];

int arr1[FRAMES_SEND];

int sw;

int rw; // tells expected frame

public:

gobkn();

void input();

void sender(int);

void reciever(int);};

gobkn :: gobkn()

{

sw = 0;

rw = 0;

}

void gobkn :: input()

{

int n; // no of bits for the frameint m; // no of frames from n bits

cout << "Enter the no of bits for the sequence no ";

cin >> n;

m = pow (2 , n);

int t = 0;



fr_send_at_instance = (m / 2);

for (int i = 0 ; i < TOT_FRAMES ; i++)

{

arr[i] = t;

t = (t + 1) % m;

}

sender(m);

}

void gobkn :: sender(int m)

{

int j = 0;

for (int i = sw ; i < sw + fr_send_at_instance ; i++)

{ arr1[j] = arr[i];

j++;

}

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

cout << " SENDER : Frame " << arr1[i] << " is

sent\n";

reciever (m);

}

void gobkn :: reciever(int m){

time_t t;

int f;

int f1;

int a1;

char ch;

srand((unsigned) time(&t));

f = rand() % 10;

// if = 5 frame is discarded for some reason

// else they are correctly recieved

if (f != 5)

{

for (int i = 0 ; i < fr_send_at_instance ; i++)

{

if (rw == arr1[i])

{



cout << "RECIEVER : Frame " << arr1[i]

<< " recieved correctly\n";

rw = (rw + 1) % m;

}

else

cout << "RECIEVER : Duplicate frame "

<< arr1[i] << " discarded\n";

}

a1 = rand() % 15;

// if a1 belongs to 0 to 3 then

// all ack after this (incl this one)

lost

// else

// all recieved

if (a1 >= 0 && a1 <= 3)

{ cout << "(Acknowledgement " << arr1[a1] << "

& all after this lost)\n";

sw = arr1[a1];

}

else

sw = (sw + fr_send_at_instance) % m;

}

else

{

f1 = rand() % fr_send_at_instance;

// f1 gives index of the frame being lost

for (int i = 0 ; i < f1 ; i++)

{

if (rw == arr1[i])

{

cout << " RECIEVER : Frame " << arr1[i]

<< " recieved correctly\n";

rw = (rw + 1) % m;

}

else

cout << " RECIEVER : Duplicate frame "

<< arr1[i] << " discarded\n";

}

int ld = rand() % 2;

// ld == 0 frame damaged

// else frame lost

if (ld == 0)



cout << " RECIEVER : Frame " << arr1[f1] <<

" damaged\n";

else

cout << " (Frame " << arr1[f1] <<

" lost)\n";

for (i = f1 + 1 ; i < fr_send_at_instance ; i++)

cout << " RECIEVER : Frame " << arr1[i] <<

" discarded\n";

cout << " (SENDER TIMEOUTS --> RESEND THE

FRAME)\n";

sw = arr1[f1];

}

cout << "Want to continue...";

cin >> ch;

if (ch == 'y')

sender(m);

else

exit(0);

}

void main()

{

clrscr();

gobkn gb;

gb.input();

getch();}

OUTPUT

Enter the no of bits for the sequence no 4SENDER : Frame 0 is sent

SENDER : Frame 1 is sent









RECIEVER : Frame 0 recieved correctly








Want to continue...n

Q4. SIMULATE SELECTIVE REPEAT PROTOCOL


# include <conio.h>

# include <stdlib.h>

# include <time.h>

# include <math.h>

# define TOT_FRAMES 500

# define FRAMES_SEND 10

class sel_repeat

{

private:

int fr_send_at_instance;

int arr[TOT_FRAMES];



int send[FRAMES_SEND];

int rcvd[FRAMES_SEND];

char rcvd_ack[FRAMES_SEND];

int sw;

int rw; // tells expected frame

public:

void input();

void sender(int);

void reciever(int);

};

void sel_repeat :: input()

{

int n; // no of bits for the frame

int m; // no of frames from n bits

cout << "Enter the no of bits for the sequence number

"; cin >> n;

m = pow (2 , n);

int t = 0;

fr_send_at_instance = (m / 2);

for (int i = 0 ; i < TOT_FRAMES ; i++)

{

arr[i] = t;

t = (t + 1) % m;}

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

{

send[i] = arr[i];

rcvd[i] = arr[i];

rcvd_ack[i] = 'n';

}

rw = sw = fr_send_at_instance;

sender(m);

}

void sel_repeat :: sender(int m)

{


{

if ( rcvd_ack[i] == 'n' )



cout << " SENDER : Frame " << send[i] << "

is sent\n";

}

reciever (m);

}

void sel_repeat :: reciever(int m)

{

time_t t;

int f;

int f1;

int a1;

char ch;

srand((unsigned) time(&t));


{ if (rcvd_ack[i] == 'n')

{

f = rand() % 10;

// if = 5 frame is discarded for some reason

// else frame is correctly recieved

if (f != 5)

{

for (int j = 0 ; j <

fr_send_at_instance ; j++)

if (rcvd[j] == send[i])

{

cout << "RECIEVER : Frame "

<< rcvd[j] << " recieved correctly\n";

rcvd[j] = arr[rw];

rw = (rw + 1) % m;

break;

}

if (j == fr_send_at_instance)

cout << "RECIEVER : Duplicate

frame " << send[i] << " discarded\n";

a1 = rand() % 5;

// if a1 == 3 then ack is lost

// else recieved

if (a1 == 3)



{

cout << "(Acknowledgement " <<

send[i] << " lost)\n";

cout << " (SENDER TIMEOUTS -->

RESEND THE FRAME)\n";

rcvd_ack[i] = 'n';

}

else

{

cout << "(Acknowledgement " <<

send[i] << " recieved)\n";

rcvd_ack[i] = 'p';

}

}

else

{

int ld = rand() % 2;

// if = 0 then frame damaged

// else frame lost

if (ld == 0)

{

cout << "RECIEVER : Frame " <<

send[i] << " is damaged\n";

cout << "RECIEVER : Negative

acknowledgement " << send[i] << " sent\n";

}

else

{cout << "RECIEVER : Frame " <<

send[i] << " is lost\n";

cout << " (SENDER TIMEOUTS -->

RESEND THE FRAME)\n";

}

rcvd_ack[i] = 'n';

}

}

}

for ( int j = 0 ; j < fr_send_at_instance ; j++)

{

if (rcvd_ack[j] == 'n')

break;

}

i = 0 ;

for (int k = j ; k < fr_send_at_instance ; k++)



{

send[i] = send[k];

if (rcvd_ack[k] == 'n')

rcvd_ack[i] = 'n';

else

rcvd_ack[i] = 'p';

i++;

}

if ( i != fr_send_at_instance )

{

for ( int k = i ; k < fr_send_at_instance ; k++)

{

send[k] = arr[sw];

sw = (sw + 1) % m;

rcvd_ack[k] = 'n';}

}

cout << "Want to continue...";

cin >> ch;

cout << "\n";

if (ch == 'y')

sender(m);

else

exit(0);

}

void main()

{

clrscr();

sel_repeat sr;

sr.input();

getch();

}

OUTPUT

Enter the no of bits for the sequence number 6











RECIEVER : Frame 24 is lost

(SENDER TIMEOUTS --> RESEND THE FRAME)


(Acknowledgement 32 recieved)





RECIEVER : Frame 28 is damaged

RECIEVER : Negative acknowledgement 28 sent




(Acknowledgement 36 lost)

(SENDER TIMEOUTS --> RESEND THE FRAME)


(Acknowledgement 37 recieved)Want to continue...n



Q5. Stop and Wait Protocol

#include <conio.h>

#include <dos.h>

#include <stdio.h>

#include <stdlib.h>

#define TIMEOUT 5

#define MAX_SEQ 1

#define TOT_PACKETS 8

#define inc(k) if(k<MAX_SEQ) k++; else k=0;typedef struct

{

int data;

}packet;

typedef struct

{

int kind;

int seq;

int ack;

packet info;

int err;

}frame;frame DATA;

typedef enum{frame_arrival,err,timeout,no_event} event_type;

void from_network_layer(packet *);

void to_network_layer(packet *);

void to_physical_layer(frame *);

void from_physical_layer(frame *);

void wait_for_event_sender(event_type *);

void wait_for_event_reciever(event_type *);

void reciever();

void sender();

int i=1; //Data to be sent by sender

char turn; //r , s

int DISCONNECT=0;

/

*__________________________________________________________

________________*/

void main()



{

clrscr();

randomize();

while(!DISCONNECT)

{

sender();

delay(400);

reciever();

}

getch();

}

/

*__________________________________________________________

________________*/

void sender()

{

static int frame_to_send=0;

static frame s;packet buffer;

event_type event;

static int flag=0;

if(flag==0)

{

from_network_layer(&buffer);

s.info = buffer;

s.seq = frame_to_send;

printf("SENDER : Info = %d Seq No = %d

",s.info,s.seq);

turn = 'r';to_physical_layer(&s);

flag = 1;

}

wait_for_event_sender(&event);

if(turn=='s')

{

if(event==frame_arrival)

{

from_network_layer(&buffer);

inc(frame_to_send);

s.info = buffer;

s.seq = frame_to_send;

printf("SENDER : Info = %d Seq No = %d

",s.info,s.seq);

turn = 'r';

to_physical_layer(&s);

}

if(event==timeout)

{



printf("SENDER : Resending Frame ");

turn = 'r';

to_physical_layer(&s);

}

}

}

/

*__________________________________________________________

________________*/

void reciever()

{

static int frame_expected=0;

frame r,s;

event_type event;

wait_for_event_reciever(&event);

if(turn=='r')

{if(event==frame_arrival)

{

from_physical_layer(&r);

if(r.seq==frame_expected)

{

to_network_layer(&r.info);

inc(frame_expected);

}

else

printf("RECIEVER : Acknowledgement Resent\n");

turn = 's';to_physical_layer(&s);

}

if(event==err)

{

printf("RECIEVER : Garbled Frame\n");

turn = 's'; //if frame not recieved

} //sender shold send it again

}

}

/

*__________________________________________________________

________________*/

void from_network_layer(packet *buffer)

{

(*buffer).data = i;

i++;

}



/

*__________________________________________________________

_________________*/

void to_physical_layer(frame *s)

{ // 0 means error

s->err = random(4); //non zero means no error

DATA = *s; //probability of error = 1/4

}

/

*__________________________________________________________

_________________*/

void to_network_layer(packet *buffer)

{

printf("RECIEVER :Packet %d recieved , Ack Sent\n",

(*buffer).data);

if(i>TOT_PACKETS) //if all packets recieved then

disconnect

{DISCONNECT = 1;

printf("\nDISCONNECTED");

}

}

/

*__________________________________________________________

_________________*/

void from_physical_layer(frame *buffer)

{

*buffer = DATA;

}

/*__________________________________________________________

_________________*/

void wait_for_event_sender(event_type * e)

{

static int timer=0;

if(turn=='s')

{

timer++;

if(timer==TIMEOUT)

{

*e = timeout;

printf("SENDER : Ack not recieved=> TIMEOUT\n");

timer = 0;

return;

}

if(DATA.err==0)

*e = err;

else



{

timer = 0;

*e = frame_arrival;

}

}

}

/

*__________________________________________________________

__________________*/

void wait_for_event_reciever(event_type * e)

{

if(turn=='r')

{

if(DATA.err==0)

*e = err;

else

*e = frame_arrival;

}}

OUTPUT

SENDER : Info = 1 Seq No = 0 RECIEVER :Packet 1

recieved , Ack Sent

SENDER : Ack not recieved=> TIMEOUT

SENDER : Resending Frame RECIEVER :

Acknowledgement Resent


recieved , Ack Sent

SENDER : Info = 3 Seq No = 0 RECIEVER :Packet 3recieved , Ack Sent


SENDER : Resending Frame RECIEVER :

Acknowledgement Resent


recieved , Ack Sent


recieved , Ack Sent


recieved , Ack Sent

SENDER : Info = 7 Seq No = 0 RECIEVER :Packet 7recieved , Ack Sent

SENDER : Info = 8 Seq No = 1 RECIEVER : Garbled

Frame


SENDER : Resending Frame RECIEVER :Packet 8

recieved , Ack Sent

DISCONNECTED



Computer Networks Programs

Documents