Aim:- write a program to perform simulation on sliding window protocol using Go-back-N
ARQ.
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.
Disadvantages
● Timeout timer runs at the receiver side only.
● The transmitter needs to store the last N packets.
● The retransmission of many error-free packets follows an erroneous packet.
Algorithm
1.
SF is the sequence number of the first frame in the slide window, SL is
the sequence number of the last frame in the slide window. R is the
sequence number of the excepted frame. W=SL-SF+1=2m-1. Only
when R and sequence number of received frame are matched, frame
accept, otherwise discard it.
Fram
e 0 &1 send, ACK 1 & 2 back to sender. Frame 2 send, ACK 3 back to sender.
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++;
for(int j=i;j<i+N && j<=nf;j++)
int flag = rand()%2;
if(!flag)
printf("%d : Acknowledged! \n", j);
x++;
else
{ printf("Frame %d Not Received \n", j);
printf("Retransmitting Window \n");
break;
printf("\n");
i+=x;
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
gbnclient.c
#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<sys/time.h>
#include<sys/wait.h>
#include<string.h>
#include<unistd.h>
#include<arpa/inet.h>
int main() {
int c_sock;
c_sock = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in client;
memset(&client, 0, sizeof(client));
client.sin_family = AF_INET;
client.sin_port = htons(9009);
client.sin_addr.s_addr = inet_addr("127.0.0.1");
if(connect(c_sock, (struct sockaddr*)&client, sizeof(client)) == -1)
printf("Connection failed");
return 0;
printf("\n\tClient -with individual acknowledgement scheme\n\n");
char msg1[50]="acknowledgement of :";
char msg2[50];
char buff[100];
int flag=1,flg=1;
for(int i=0;i<=9;i++) {
flg=1;
bzero(buff,sizeof(buff));
bzero(msg2,sizeof(msg2));
if(i==8&&flag==1){
printf("here\n"); //simulating loss
flag=0;
read(c_sock,buff,sizeof(buff));
int n = read(c_sock, buff, sizeof(buff));
if(buff[strlen(buff)-1]!=i+'0'){ //out of order
printf("Discarded as out of order \n");
i--;
else{
printf("Message received from server : %s \t %d\n",buff,i);
printf("Acknowledgement sent for message \n");
strcpy(msg2,msg1);
msg2[strlen(msg2)]=i+'0';
write(c_sock,msg2, sizeof(msg2));
close(c_sock);
return 0;
gbnserver.c
#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<sys/time.h>
#include<netinet/in.h>
#include<string.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<fcntl.h>
int main() {
int s_sock, c_sock;
s_sock = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in server, other;
memset(&server, 0, sizeof(server));
memset(&other, 0, sizeof(other));
server.sin_family = AF_INET;
server.sin_port = htons(9009);
server.sin_addr.s_addr = INADDR_ANY;
socklen_t add;
if(bind(s_sock, (struct sockaddr*)&server, sizeof(server)) == -1) {
printf("Binding failed\n");
return 0;
printf("\tServer Up\n Go back n (n=3) used to send 10 messages \n\n");
listen(s_sock, 10);
add = sizeof(other);
c_sock = accept(s_sock, (struct sockaddr*)&other, &add);
time_t t1,t2;
char msg[50]="server message :";
char buff[50];
int flag=0;
fd_set set1,set2,set3;
struct timeval timeout1,timeout2,timeout3;
int rv1,rv2,rv3;
int i=-1;
qq:
i=i+1;
bzero(buff,sizeof(buff));
char buff2[60];
bzero(buff2,sizeof(buff2));
strcpy(buff2,"server message :");
buff2[strlen(buff2)]=i+'0';
buff2[strlen(buff2)]='\0';
printf("Message sent to client :%s \n",buff2);
write(c_sock, buff2, sizeof(buff2));
usleep(1000);
i=i+1;
bzero(buff2,sizeof(buff2));
strcpy(buff2,msg);
buff2[strlen(msg)]=i+'0';
printf("Message sent to client :%s \n",buff2);
write(c_sock, buff2, sizeof(buff2));
i=i+1;
usleep(1000);
qqq:
bzero(buff2,sizeof(buff2));
strcpy(buff2,msg);
buff2[strlen(msg)]=i+'0';
printf("Message sent to client :%s \n",buff2);
write(c_sock, buff2, sizeof(buff2));
FD_ZERO(&set1);
FD_SET(c_sock, &set1);
timeout1.tv_sec = 2;
timeout1.tv_usec = 0;
rv1 = select(c_sock + 1, &set1, NULL, NULL, &timeout1);
if(rv1 == -1)
perror("select error ");
else if(rv1 == 0){
printf("Going back from %d:timeout \n",i);
i=i-3;
goto qq;}
else{
read(c_sock, buff, sizeof(buff));
printf("Message from Client: %s\n", buff);
i++;
if(i<=9)
goto qqq;
qq2:
FD_ZERO(&set2);
FD_SET(c_sock, &set2);
timeout2.tv_sec = 3;
timeout2.tv_usec = 0;
rv2 = select(c_sock + 1, &set2, NULL, NULL, &timeout2);
if(rv2 == -1)
perror("select error "); // an error accured
else if(rv2 == 0){
printf("Going back from %d:timeout on last 2\n",i-1);
i=i-2;
bzero(buff2,sizeof(buff2));
strcpy(buff2,msg);
buff2[strlen(buff2)]=i+'0';
write(c_sock, buff2, sizeof(buff2));
usleep(1000);
bzero(buff2,sizeof(buff2));
i++;
strcpy(buff2,msg);
buff2[strlen(buff2)]=i+'0';
write(c_sock, buff2, sizeof(buff2));
goto qq2;} // a timeout occured
else{
read(c_sock, buff, sizeof(buff));
printf("Message from Client: %s\n", buff);
bzero(buff,sizeof(buff));
read(c_sock, buff, sizeof(buff));
printf("Message from Client: %s\n", buff);
close(c_sock);
close(s_sock);
return 0;
Output
gcc gbserver.c -o s
cca@labb30:~$ ./s
Server Up
Go back n (n=3) used to send 10 messages
Message sent to client :server message :0
Message sent to client :server message :1
Message sent to client :server message :2
Message from Client: acknowledgement of0
Message sent to client :server message :3
Message from Client: acknowledgement of1
Message sent to client :server message :4
Message from Client: acknowledgement of2
Message sent to client :server message :5
Message from Client: acknowledgement of3
Message sent to client :server message :6
Going back from 6:timeout
Message sent to client :server message :4
Message sent to client :server message :5
Message sent to client :server message :6
Message from Client: acknowledgement of4
Message sent to client :server message :7
Message from Client: acknowledgement of5
Message sent to client :server message :8
Message from Client: acknowledgement of6
Message sent to client :server message :9
Message from Client: acknowledgement of7
Going back from 9:timeout on last 2
Message from Client: acknowledgement of8
Message from Client: acknowledgement of9
gcc gbclient.c -o c
cca@labb30:~$ ./c
Client -with individual acknowledgement scheme
Message received from server : server message :0 0
Acknowledgement sent for message
Message received from server : server message :1 1
Acknowledgement sent for message
Message received from server : server message :2 2
Acknowledgement sent for message
Message received from server : server message :3 3
Acknowledgement sent for message
Discarded as out of order
Discarded as out of order
Discarded as out of order
Message received from server : server message :4 4
Acknowledgement sent for message
Message received from server : server message :5 5
Acknowledgement sent for message
Message received from server : server message :6 6
Acknowledgement sent for message
Message received from server : server message :7 7
Acknowledgement sent for message
here
Discarded as out of order
Message received from server : server message :8 8
Acknowledgement sent for message
Message received from server : server message :9 9
Acknowledgement sent for message
