GO BACK N ARQ IMPLEMENTATION
Aim:- write a program to perform simulation on sliding window protocol using Go-back-N
ARQ for noisy channel.
Description:-
Go-Back-N ARQ is mainly a specific instance of Automatic Repeat Request (ARQ)
protocol where the sending process continues to send a number of frames as specified by
the window size even without receiving an acknowledgement (ACK) packet from the
receiver. The sender keeps a copy of each frame until the acknowledgement arrives.
This protocol is a practical approach to the sliding window.
● In Go-Back-N ARQ, the size of the sender window is N and the size of the receiver
window is always 1.
● This protocol makes the use of cumulative acknowledgements means here the
receiver maintains an acknowledgement timer.
● If the receiver receives a corrupted frame, then it silently discards that corrupted
frame and the correct frame is retransmitted by the sender after the timeout timer
expires.
● In case if the receiver receives the out of order frame then it simply discards all the
frames.
● In case if the sender does not receive any acknowledgement then the frames in the
entire window will be retransmitted again.
SF is the sequence number of the first frame in the sliding window, S L is
the sequence number of the last frame in the sliding window. R is the
sequence number of the expected frame. W=S L-SF+1=N itself, indicating
the number of frames. Only when R and sequence number of
received frame are matched, frame is accepted, otherwise discard
frame. Receiver window size is 1.
Consequently, the size of the sending window is 2^n1. Thus in order to accommodate a sending window
2^3 - 1 = 7 i.e window will carry frames from 0 to 6 which are 7 in number. If window
size is 3, we use a 2-bit sequence number to transmit frames, i.e 2^2-1=3.
Frame 0 &1 send, ACK 1 & 2 back to sender. Frame 2 send, ACK 3 back to sender.
Algorithm to be written in record
GoBackN.c
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
int main()
int nf,N;
int tr=0;
srand(time(NULL));
printf("Enter the number of frames : ");
scanf("%d",&nf);
printf("Enter the Window Size : ");
scanf("%d",&N);
int i=1;
while(i<=nf)
{
int x=0;
for(int j=i;j<i+N && j<=nf;j++)
printf("Sent Frame %d \n", j);
tr++; //After each frame is send, increment tr by 1 to track total number of transmissions
for(int j=i;j<i+N && j<=nf;j++)
int flag = rand()%2; //lost frame set as frame 2
if(!flag)
printf("%d : Acknowledged! \n", j);
x++; //After acknowledging frame, increment x indicating success of frame transmission
else
{ printf("Frame %d Not Received \n", j);
printf("Retransmitting Window \n");
break;
printf("\n");
i+=x; //i updates number of successful transfers - all acknowledged frames
printf("Total number of transmissions : %d \n", tr);
return 0; }
Output
gcc goBackN.c
net@inlab:~$ ./a.out
Enter the number of
frames : 5
Enter the Window Size : 2
Sent Frame 1
Sent Frame 2
1 : Acknowledged!
Frame 2 Not Received
Retransmitting Window
Sent Frame 2
Sent Frame 3
2 : Acknowledged!
3 : Acknowledged!
Sent Frame 4
Sent Frame 5
4 : Acknowledged!
5 : Acknowledged!
Total number of
transmissions : 6
Go-Back N Client/Server Implementation in C
gbns.c
#include <stdio.h>
#include <stdlib.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <fcntl.h>
#include<string.h>
#include<unistd.h>
void itoa(int number, char numberString[])
{ numberString[0] = (char)(number + 48);
//integer to ascii conversion by adding 48 and then typecasting to character
numberString[1] = '\0';
int main()
int sockfd, newSockFd, size, windowStart = 1, windowCurrent = 1, windowEnd = 4, oldWindowStart, flag;
char buffer[100];
socklen_t len;
struct sockaddr_in server, client;
server.sin_family = AF_INET;
server.sin_port = 3033;
server.sin_addr.s_addr = INADDR_ANY;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
printf("\nStarting up...");
int k;
k=bind(sockfd, (struct sockaddr *)&server, sizeof(server)); //bind socket with ip addr of server
if(k==-1)
printf("Error in binding");
len = sizeof(client);
listen(sockfd,1);
//listen to 1 active connection to client
newSockFd = accept(sockfd, (struct sockaddr *)&client,&len); //accept client connection
recv(newSockFd, buffer, 100, 0);//receive message from client
fcntl(newSockFd,F_SETFL,O_NONBLOCK);//It allows the program to place a read or a write lock.
printf("\n Received a request from client. Sending packets one by one...");
do
if(windowCurrent != windowEnd)
itoa(windowCurrent, buffer); //convert current window no to ascii and copy to buffer
send(newSockFd, buffer, 100, 0); //send window no to server through newSockFd
printf("\nPacket Sent: %d\n",windowCurrent); //show which window number the transmitted frame
was
windowCurrent++; //After sending packet, increment the current window
recv(newSockFd, buffer, 100, 0); // receive message from Client
if(buffer[0]=='R') //check if buffer contained retransmission request packet denoting ‘R’
//resend packet number in buffer[1]
printf("\n** Received a RETRANSMIT packet.\n Resending packet no. %c...", buffer[1]);
itoa((atoi(&buffer[1])), buffer); //copy packet number as ascii value to buffer
send(newSockFd, buffer, 100, 0); //send packet number to client
windowCurrent = atoi(&buffer[0]); //note down the window number of retransmitted frame
windowCurrent++; //increment window after retransmission
else if(buffer[0] == 'A') //check if incoming buffer contained acknowledgement denoted by ‘A’
oldWindowStart = windowStart; //initialize 1 as window starting index
// update the new window no based on acknowledgement from receiver
windowStart = atoi(&buffer[1]) + 1; windowEnd += (windowStart - oldWindowStart);
//print on screen which ACK was received
printf("\n** Received ACK %c. Moving window boundary.",buffer[1]);
while(windowCurrent!= 10);
close(sockfd);
close(newSockFd);
printf("\nSending Complete. Sockets closed.Exiting...\n");
return(0);
gbnc.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include<unistd.h>
int main()
int sockfd, newSockFd, size, firstTime = 1, currentPacket, wait = 3;
char data[100], digit[2];
struct sockaddr_in client;
sockfd = socket(AF_INET, SOCK_STREAM,0);
client.sin_family = AF_INET;
client.sin_port = 3033;
client.sin_addr.s_addr = INADDR_ANY;
printf("\nStarting up...");
size = sizeof(client);
printf("\nEstablishing Connection to Server...");
connect(sockfd, (struct sockaddr *)&client, size);
sprintf(data, "REQUEST");
send(sockfd, data, strlen(data), 0); //send REQUEST message to server
do
recv(sockfd, data, 100, 0); //receive data from server
currentPacket = atoi(data); //note current packet number
printf("\nGot packet: %d", currentPacket);
if(currentPacket == 3 && firstTime)
{ //issue a retransmission after receiving packets until packet 3
printf("\n*** Simulation: Packet data corrupted or incomplete.");
printf("\n*** Sending RETRANSMIT for packet 1.");
memset(&data, 0, sizeof(data)); //clear buffer data
sprintf(data,"R1"); //Code for message requesting retransmission is R1 to retransmit packet 1
send(sockfd, data, strlen(data), 0);
//send R1 message to server
firstTime =0;
else
{ wait--; //wait time is initialized as 3ms. we can reduce wait time till 0
if(!wait)
printf("\n*** Packet Accepted -> Sending ACK");
wait = 3; //after accepting packet, reset wait time as 3ms
sprintf(data, "A");
digit[0] = (char)(currentPacket + 48); //convert packet number to ascii value
digit[1] = '\0';
strcat(data, digit); //concatenate A and packet number together for each packet
send(sockfd, data,strlen(data),0); //send acknowledgement to server
while(currentPacket != 9);
printf("\nAll packets received...Exiting.");
close(sockfd);
return(0);
SERVER SIDE OUTPUT – FIRST RUN SERVER
labb04@labb04:~/Desktop$ gcc gbns1.c -o s1
labb04@labb04:~/Desktop$ ./s1
Starting up...
Recieved a request from client. Sending packets one by one...
Packet Sent: 1
Packet Sent: 2
Packet Sent: 3
** Received a RETRANSMIT packet.
Resending packet no. 1...
Packet Sent: 2
Packet Sent: 3
** Received ACK 1. Moving window boundary.
Packet Sent: 4
** Received ACK 4. Moving window boundary.
Packet Sent: 5
Packet Sent: 6
Packet Sent: 7
** Received ACK 7. Moving window boundary.
Packet Sent: 8
Packet Sent: 9
Sending Complete. Sockets closed.Exiting…
CLIENT SIDE OUTPUT
labb04@labb04:~/Desktop$ gcc gbnc.c -o c1
labb04@labb04:~/Desktop$ ./c1
Starting up...
Establishing Connection...
Got packet: 1
Got packet: 2
Got packet: 3
*** Simulation: Packet data corrupted or incomplete.
*** Sending RETRANSMIT for packet 1.
Got packet: 1
*** Packet Accepted -> Sending ACK
Got packet: 2
Got packet: 3
Got packet: 4
*** Packet Accepted -> Sending ACK
Got packet: 5
Got packet: 6
Got packet: 7
*** Packet Accepted -> Sending ACK
Got packet: 8
Got packet: 9
All packets received...Exiting.
