Server.c (Receiver) server_addr.

sin_family = AF_INET;
#include <stdio.h> server_addr.sin_addr.s_addr = INADDR_ANY;
#include <stdlib.h> server_addr.sin_port = htons(PORT);
#include <string.h>
#include <unistd.h> if (bind(sockfd, (const struct sockaddr *)&server_addr,
#include <sys/types.h> sizeof(server_addr)) < 0) {
#include <sys/socket.h>
#include <netinet/in.h> perror("bind failed");

#define PORT 8080 exit(EXIT_FAILURE);

#define BUFFER_SIZE 1024
}

int main() { printf("Server listening on port %d...\n", PORT);

int pre_fnumber=-1;

int sockfd; while (1) {

struct sockaddr_in server_addr, client_addr; int r_time = rand() % 5;

socklen_t client_len;
sleep(r_time);
char buffer[BUFFER_SIZE];
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { memset(buffer, 0, BUFFER_SIZE);

perror("socket creation failed"); client_len = sizeof(client_addr);

exit(EXIT_FAILURE); ssize_t msg_len = recvfrom(sockfd, buffer, BUFFER_SIZE, 0, (struct

sockaddr *)&client_addr, &client_len);
}
if (msg_len == -1) {
memset(&server_addr, 0, sizeof(server_addr)); perror("recvfrom failed");
memset(&client_addr, 0, sizeof(client_addr));
 exit(EXIT_FAILURE); return 0;

} }

const char *response = &buffer[1];

int f_number = 0;

sscanf(response, "%d", &f_number);

if(f_number<pre_fnumber)
{
continue;
}

printf("Received frame from client: %c\n", buffer[0]);

ssize_t sent_bytes = sendto(sockfd, response, strlen(response),

0, (struct sockaddr *)&client_addr, client_len);

if (sent_bytes == -1) {
perror("send to failed");
exit(EXIT_FAILURE);
}

printf("Acknowledement send to client\n");

pre_fnumber = f_number;

close(sockfd);
Client.c (Sender) close(sockfd);
#include <stdio.h>#include <stdlib.h> return -1;
#include <string.h> }
#include <unistd.h>
#include <sys/types.h> flags = flags | O_NONBLOCK;
#include <sys/socket.h>
#include <netinet/in.h> if (fcntl(sockfd, F_SETFL, flags) == -1) {
#include <arpa/inet.h> printf("Error setting socket to non-blocking mode.\n");
#include <fcntl.h> close(sockfd);
return -1;
#define PORT 8080 }
#define BUFFER_SIZE 4
#define TIMEOUT_SECONDS 3 memset(&server_addr, 0, sizeof(server_addr));

server_addr.sin_family = AF_INET;
int send_and_receive_ack(char message[]) { server_addr.sin_port = htons(PORT);
int sockfd; if (inet_pton(AF_INET, "127.0.0.1", &(server_addr.sin_addr)) <= 0) {
struct sockaddr_in server_addr; perror("invalid address or address not supported");
socklen_t server_len; exit(EXIT_FAILURE);
char ack[BUFFER_SIZE]; }
ssize_t sent_bytes, received_bytes;

fd_set readFds; sent_bytes = sendto(sockfd, message, strlen(message), 0, (const struct

FD_ZERO(&readFds); sockaddr *)&server_addr, sizeof(server_addr));
if (sent_bytes == -1) {
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { perror("sendto failed");
perror("socket creation failed"); exit(EXIT_FAILURE);
exit(EXIT_FAILURE); }
}
FD_SET(sockfd, &readFds);
int flags = fcntl(sockfd, F_GETFL, 0);
struct timeval timeout;
if (flags == -1) { timeout.tv_sec = TIMEOUT_SECONDS;
printf("Error getting socket flags\n"); timeout.tv_usec = 0;
 void main()
int selectResult = select(sockfd + 1, &readFds, NULL,NULL, {
&timeout); char message[100];
printf("Enter the Message : ");
if (selectResult == -1) { scanf("%[^\n]",message);
printf("Error in select.\n"); int cs_flag=0;
close(sockfd); int f_number = 0;
return -1; int i = 0;
} int len = strlen(message);
else if (selectResult == 0) { while(i!=len)
close(sockfd); {
return -1; char frame[5];
} frame[0] = message[i];
else sprintf(frame + 1, "%d", f_number);
{ printf("sending the frame %d\n",f_number);
int ack = send_and_receive_ack(frame);
server_len = sizeof(server_addr); if(ack == f_number)
memset(ack, 0,BUFFER_SIZE); {
received_bytes = recvfrom(sockfd, ack, BUFFER_SIZE, 0, printf("Acknowledgement for frame %d is received\
(struct sockaddr *)&server_addr, &server_len); n",f_number);
if (received_bytes == -1) { f_number++;
perror("recvfrom failed"); i++;
exit(EXIT_FAILURE); }
} else
{
int ack_in_number; printf("Acknowledgement for frame %d is not
sscanf(ack, "%d", &ack_in_number); received\n re",f_number);
}
close(sockfd); }
printf("Data Tranfer is completed\n");
return ack_in_number; }
}
}
Server.c (Receiver) server_addr.sin_port = htons(PORT);
#include <stdio.h>
#include <stdlib.h> if (bind(sockfd, (const struct sockaddr *)&server_addr,
#include <string.h> sizeof(server_addr)) < 0) {
#include <unistd.h> perror("bind failed");
#include <sys/types.h> exit(EXIT_FAILURE);
#include <sys/socket.h> }
#include <netinet/in.h>

printf("Server listening on port %d...\n", PORT);

#define PORT 8080
#define BUFFER_SIZE 1024

while (1) {

int main() { int r_time = rand() % 4;

int sockfd; sleep(r_time);

struct sockaddr_in server_addr, client_addr;
socklen_t client_len; memset(buffer, 0, BUFFER_SIZE);
char buffer[BUFFER_SIZE];
client_len = sizeof(client_addr);

if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { ssize_t msg_len = recvfrom(sockfd, buffer, BUFFER_SIZE, 0, (struct
perror("socket creation failed"); sockaddr *)&client_addr, &client_len);
exit(EXIT_FAILURE);
} if (msg_len == -1) {

memset(&server_addr, 0, sizeof(server_addr)); perror("recvfrom failed");

memset(&client_addr, 0, sizeof(client_addr));
exit(EXIT_FAILURE);
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = INADDR_ANY; }
 const char *response = &buffer[1];

int f_number = 0;

sscanf(response, "%d", &f_number);

printf("Received frame from client: %c\n", buffer[0]);

ssize_t sent_bytes = sendto(sockfd, response, strlen(response),

0, (struct sockaddr *)&client_addr, client_len);

if (sent_bytes == -1) {

perror("sendto failed");

exit(EXIT_FAILURE);

printf("Acknowledement send to client\n");

close(sockfd);
return 0;

}
Client.c (Sender)
#include <stdio.h> int flags = fcntl(sockfd, F_GETFL, 0);
#include <stdlib.h>
#include <string.h> if (flags == -1) {
#include <unistd.h> printf("Error getting socket flags\n");
#include <sys/types.h> close(sockfd);
#include <sys/socket.h> return -1;
#include <netinet/in.h> }
#include <arpa/inet.h>
#include <fcntl.h> flags = flags | O_NONBLOCK;

#define PORT 8080 if (fcntl(sockfd, F_SETFL, flags) == -1) {

#define BUFFER_SIZE 4 printf("Error setting socket to non-blocking mode.\n");
#define TIMEOUT_SECONDS 3 close(sockfd);
return -1;
}
int ack_array[2][4];
int window_size = 4,a_get=0,r_send=0,w_pos=0,f_number=0,length=0; memset(&server_addr, 0, sizeof(server_addr));

server_addr.sin_family = AF_INET;
int send_and_receive_ack(char message[]) { server_addr.sin_port = htons(PORT);
int sockfd; if (inet_pton(AF_INET, "127.0.0.1", &(server_addr.sin_addr)) <=
struct sockaddr_in server_addr; 0) {
socklen_t server_len; perror("invalid address or address not supported");
char ack[BUFFER_SIZE]; exit(EXIT_FAILURE);
ssize_t sent_bytes, received_bytes; }

fd_set readFds;
FD_ZERO(&readFds); sent_bytes = sendto(sockfd, message, strlen(message), 0, (const
struct sockaddr *)&server_addr, sizeof(server_addr));
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { if (sent_bytes == -1) {
perror("socket creation failed"); perror("sendto failed");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
 close(sockfd);
FD_SET(sockfd, &readFds);
return ack_in_number;
struct timeval timeout; }
timeout.tv_sec = TIMEOUT_SECONDS; }
timeout.tv_usec = 0;

int selectResult = select(sockfd + 1, &readFds, NULL,NULL, void slide()

&timeout); {
for(int i=0;i<window_size;i++)
if (selectResult == -1) { {
printf("Error in select.\n"); ack_array[0][i] = ack_array[0][i+1];
close(sockfd); ack_array[1][i] = ack_array[1][i+1];
return -1; }
} }
else if (selectResult == 0) {
close(sockfd); void send_window(char message[])
return -1; {
} char frame[5];
else for(int i=0;i<window_size && i<r_send;i++)
{ {
frame[0] = message[f_number];
server_len = sizeof(server_addr); sprintf(frame + 1, "%d", f_number);
memset(ack, 0,BUFFER_SIZE); printf("sending the frame %d\n",f_number);
received_bytes = recvfrom(sockfd, ack, BUFFER_SIZE, 0, (struct ack_array[0][i] = f_number;
sockaddr *)&server_addr, &server_len); ack_array[1][i] = send_and_receive_ack(frame);
if (received_bytes == -1) { f_number++;
perror("recvfrom failed"); }
exit(EXIT_FAILURE); }
}

int ack_in_number; void get_ack_send(char message[])

sscanf(ack, "%d", &ack_in_number); {
int i=0;
 char frame[5]; }
while(a_get!=length) printf("Data Transfer Completed\n");
{ }
if(ack_array[1][i]!=-1)
{
printf("Acknowledgement for frame %d is recived\
n",ack_array[0][i]); void main()
r_send--; {
a_get++; printf("Window Size is 4 frames\n");
if(r_send<window_size) char message[100];
{ printf("Enter the Message : ");
i++; scanf("%[^\n]",message);
w_pos++; int len = strlen(message);
} r_send = len;
else length = len;
{
slide(); send_window(message);
w_pos++; get_ack_send(message);
frame[0] = message[f_number];
sprintf(frame + 1, "%d", f_number); }
printf("sending the frame %d\n",f_number);
ack_array[0][window_size-1] = f_number;
ack_array[1][window_size-1] =
send_and_receive_ack(frame);
f_number++;
}
}
else
{
printf("Acknowledgement for frame %d is not
received resending window\n",ack_array[0][i]);
f_number = w_pos;
send_window(message);
}
Server.c (Receiver)
#include <stdio.h> memset(&server_addr, 0, sizeof(server_addr));
#include <stdlib.h> memset(&client_addr, 0, sizeof(client_addr));
#include <string.h>
#include <unistd.h> server_addr.sin_family = AF_INET;
#include <sys/types.h> server_addr.sin_addr.s_addr = INADDR_ANY;
#include <sys/socket.h> server_addr.sin_port = htons(PORT);
#include <netinet/in.h>

if (bind(sockfd, (const struct sockaddr *)&server_addr,

sizeof(server_addr)) < 0) {
#define PORT 8080
#define BUFFER_SIZE 1024 perror("bind failed");

exit(EXIT_FAILURE);

int main() { }
int sockfd;

struct sockaddr_in server_addr, client_addr;

printf("Server listening on port %d...\n", PORT);
socklen_t client_len;

char buffer[BUFFER_SIZE];
while (1) {
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
int r_time = rand() % 5;
perror("socket creation failed"); sleep(r_time);
memset(buffer, 0, BUFFER_SIZE);
exit(EXIT_FAILURE); client_len = sizeof(client_addr);
ssize_t msg_len = recvfrom(sockfd, buffer, BUFFER_SIZE, 0,
} (struct sockaddr *)&client_addr, &client_len);

if (msg_len == -1) {
 perror("recvfrom failed");

exit(EXIT_FAILURE);

const char *response = &buffer[1];

int f_number = 0;

sscanf(response, "%d", &f_number);

printf("Received frame from client: %c\n", buffer[0]);

ssize_t sent_bytes = sendto(sockfd, response, strlen(response),

0, (struct sockaddr *)&client_addr, client_len);

if (sent_bytes == -1) {

perror("sendto failed");

exit(EXIT_FAILURE);

}
printf("Acknowledement send to client\n");

close(sockfd);
return 0;
}
Client.c (Sender)
#include <stdio.h> fd_set readFds;
#include <stdlib.h>
#include <string.h> FD_ZERO(&readFds);
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h> if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
#include <arpa/inet.h>
#include <fcntl.h> perror("socket creation failed");

exit(EXIT_FAILURE);

#define PORT 8080 }

#define BUFFER_SIZE 4
#define TIMEOUT_SECONDS 3

int ack_array[2][4]; int flags = fcntl(sockfd, F_GETFL, 0);

int window_size = if (flags == -1) {

4,a_get=0,r_send=0,w_pos=0,f_number=0,length=0;
int send_and_receive_ack(char message[]) { printf("Error getting socket flags\n");

int sockfd; close(sockfd);

struct sockaddr_in server_addr; return -1;

socklen_t server_len; }

char ack[BUFFER_SIZE]; flags = flags | O_NONBLOCK;

if (fcntl(sockfd, F_SETFL, flags) == -1) {
ssize_t sent_bytes, received_bytes;
printf("Error setting socket to non-blocking mode.\n");
 close(sockfd);
struct timeval timeout;
return -1;
timeout.tv_sec = TIMEOUT_SECONDS;
}
timeout.tv_usec = 0;
memset(&server_addr, 0, sizeof(server_addr));
int selectResult = select(sockfd + 1, &readFds,
NULL,NULL, &timeout);
server_addr.sin_family = AF_INET;
if (selectResult == -1) {
server_addr.sin_port = htons(PORT);
printf("Error in select.\n");
if (inet_pton(AF_INET, "127.0.0.1", &(server_addr.sin_addr)) <=
0) { close(sockfd);

perror("invalid address or address not supported"); return -1;

exit(EXIT_FAILURE); }

} else if (selectResult == 0) {

sent_bytes = sendto(sockfd, message, strlen(message), 0, close(sockfd);

(const struct sockaddr *)&server_addr, sizeof(server_addr));
return -1;
if (sent_bytes == -1) {
}
perror("sendto failed");
else
exit(EXIT_FAILURE);
{
} server_len = sizeof(server_addr);

FD_SET(sockfd, &readFds); memset(ack, 0,BUFFER_SIZE);

 received_bytes = recvfrom(sockfd, ack, BUFFER_SIZE, 0, }
(struct sockaddr *)&server_addr, &server_len);

if (received_bytes == -1) {
void send_window(char message[])
perror("recvfrom failed");
{
exit(EXIT_FAILURE);
char frame[5];
}
for(int i=0;i<window_size && i<r_send;i++)
int ack_in_number;
{
sscanf(ack, "%d", &ack_in_number);
close(sockfd); frame[0] = message[f_number];
return ack_in_number;
sprintf(frame + 1, "%d", f_number);
}
printf("sending the frame %d\n",f_number);
}
ack_array[0][i] = f_number;

void slide() ack_array[1][i] = send_and_receive_ack(frame);

{
f_number++;
for(int i=0;i<window_size;i++)
}
{
}
ack_array[0][i] = ack_array[0][i+1];
ack_array[1][i] = ack_array[1][i+1];

}
void get_ack_send(char message[]) {

{ slide();

int i=0; w_pos++;

char frame[5]; frame[0] = message[f_number];

while(a_get!=length) sprintf(frame + 1, "%d", f_number);

{ printf("sending the frame %d\n",f_number);

if(ack_array[1][i]!=-1) ack_array[0][window_size-1] = f_number;

{ ack_array[1][window_size-1] =
send_and_receive_ack(frame);
printf("Acknowledgement for frame %d is
recived\n",ack_array[0][i]); f_number++;

r_send--; }

a_get++; }

if(r_send<window_size) else

{ {

i++; printf("Acknowledgement for frame %d is

w_pos++; not received resending the frame\n",ack_array[0][i]);

} int m_index = ack_array[0][i];

else frame[0] = message[m_index];

 sprintf(frame + 1, "%d", m_index);
send_window(message);
printf("Resending the frame %d\n",m_index); get_ack_send(message);

ack_array[1][i] =
send_and_receive_ack(frame); }

printf("Data Transfer Completed\n");

void main()

printf("Window Size is 4 frames\n");

char message[100];

printf("Enter the Message : ");

scanf("%[^\n]",message);

int len = strlen(message);

r_send = len;

length = len;
Server.c (Receiver)
#include <stdio.h> sockfd = socket(AF_INET, SOCK_STREAM, 0);
#include <stdlib.h> if(sockfd < 0) {
#include <string.h> perror("Error in socket");
#include <arpa/inet.h> exit(1);
#define SIZE 1024 }
printf("Server socket created successfully.\n");
void write_file(int sockfd){
int n; server_addr.sin_family = AF_INET;
FILE *fp; server_addr.sin_port = port;
char *filename = "recv.txt"; server_addr.sin_addr.s_addr = inet_addr(ip);
char buffer[SIZE];
e = bind(sockfd, (struct sockaddr*)&server_addr,
fp = fopen(filename, "w"); sizeof(server_addr));
while (1) { if(e < 0) {
n = recv(sockfd, buffer, SIZE, 0); perror("Error in bind");
if (n <= 0){ exit(1);
break; }
return; printf("Binding successfull.\n");
}
fprintf(fp, "%s", buffer); if(listen(sockfd, 10) == 0){
bzero(buffer, SIZE); printf("Listening....\n");
} }else{
return; perror("Error in listening");
} exit(1);
}
int main(){ addr_size = sizeof(new_addr);
char *ip = "127.0.0.1"; new_sock = accept(sockfd, (struct sockaddr*)&new_addr,
int port = 8080; &addr_size);
int e; write_file(new_sock);
int sockfd, new_sock; printf("Data written in the file successfully.\n");
struct sockaddr_in server_addr, new_addr;
socklen_t addr_size; return 0;
char buffer[SIZE]; }
Client.c (Sender) int main(){
#include <stdio.h>
#include <stdlib.h> char *ip = "127.0.0.1";
#include <unistd.h> int port = 8080;
#include <string.h> int e;
int sockfd;
#include <arpa/inet.h>
#define SIZE 1024 struct sockaddr_in server_addr;

FILE *fp;
char *filename = "send.txt";
void send_file(FILE *fp, int sockfd){
sockfd = socket(AF_INET, SOCK_STREAM, 0);
int n;
if(sockfd < 0) {
char data[SIZE] = {0};
perror("Error in socket");

exit(1);
while(fgets(data, SIZE, fp) != NULL) {
}
if (send(sockfd, data, sizeof(data), 0) == -1) {
printf("Server socket created successfully.\n");
perror("Error in sending file.\n"); server_addr.sin_family = AF_INET;
server_addr.sin_port = port;
exit(1); server_addr.sin_addr.s_addr = inet_addr(ip);
e = connect(sockfd, (struct sockaddr*)&server_addr,
} sizeof(server_addr));

bzero(data, SIZE); if(e == -1) {

} perror("Error in socket");

} exit(1);
 }

printf("Connected to Server.\n");
fp = fopen(filename, "r");

if (fp == NULL) {

perror("Error in reading file.");

exit(1);

send_file(fp, sockfd);
printf("File data sent successfully.\n");
printf("Closing the connection.\n");
close(sockfd);
return 0;

}
 {
#include<stdio.h>
#include<stdlib.h> if( (packet_sz[i] + p_sz_rm) > b_size)
#include<unistd.h> {
#define NOF_PACKETS 10 if(packet_sz[i] > b_size)
{
int custom_rand(int a) printf("\n\nIncoming packet size (%dbytes) is Greater
{ than bucket capacity (%dbytes)-PACKET REJECTED",
int rn = (random() % 10) % a; packet_sz[i], b_size);
return rn == 0 ? 1 : rn; }
} else
{
printf("\n\nBucket capacity exceeded-PACKETS
REJECTED!!");
int main() }
{ else
int packet_sz[NOF_PACKETS], i, clk, b_size, o_rate,
p_sz_rm=0, p_sz, p_time, op; {

for(i = 0; i<NOF_PACKETS; ++i) p_sz_rm += packet_sz[i];

{
packet_sz[i] = custom_rand(6) * 10; printf("\n\nIncoming Packet size: %d", packet_sz[i]);
}
for(i = 0; i<NOF_PACKETS; ++i) printf("\nBytes remaining to Transmit: %d", p_sz_rm);
{
printf("\npacket[%d]:%d bytes\t", i, packet_sz[i]); p_time = custom_rand(4) * 10;
}
printf("\nTime left for transmission: %d units", p_time);
printf("\nEnter the Output rate:");
scanf("%d", &o_rate); for(clk = 10; clk <= p_time; clk += 10)
printf("Enter the Bucket Size:"); {
scanf("%d", &b_size); sleep(1);
for(i = 0; i<NOF_PACKETS; ++i) if(p_sz_rm)
{
 if(p_sz_rm <= o_rate)
{
op = p_sz_rm, p_sz_rm = 0;
}
else
{
op = o_rate, p_sz_rm -= o_rate;
}
printf("\nPacket of size %d Transmitted", op);

printf("----Bytes Remaining to Transmit: %d\n",

p_sz_rm);
}
else
{
printf("\nTime left for transmission: %d units", p_time-
clk);
printf("\nNo packets to transmit!!\n");
}
}
}
}
}