7. Write a C program to implement Sliding window protocol Selective repeat.

#include<stdio.h>

#include<stdlib.h>

#include<stdbool.h>

#include<string.h>

#define WINDOW_SIZE 4

#define MAX_SEQ_NUM 8

typedef struct {

int seq_num;

bool acked;

bool sent;

} Frame;

void send_frame(Frame frame) {

printf("Sending frame with sequence number %d\n", frame.seq_num);

// Simulate transmission delay

sleep(1);

void receive_ack(Frame frame) {

printf("Received ACK for frame with sequence number %d\n", frame.seq_num);

int main() {
Frame frames[MAX_SEQ_NUM];

int base = 0;

int next_seq_num = 0;

while (base < MAX_SEQ_NUM) {

// Send new frames within the window

while (next_seq_num < base + WINDOW_SIZE && next_seq_num < MAX_SEQ_NUM) {

Frame frame = {next_seq_num, false, true};

frames[next_seq_num] = frame;

send_frame(frame);

next_seq_num++;

// Receive acknowledgments

for (int i = base; i < next_seq_num; i++) {

if (!frames[i].acked) {

receive_ack(frames[i]);

frames[i].acked = true;

// Slide the window

while (base < MAX_SEQ_NUM && frames[base].acked) {

base++;

}
}

return 0;

OUTPUT:

Sending frame with sequence number 0

Sending frame with sequence number 1

Sending frame with sequence number 2

Sending frame with sequence number 3

Received ACK for frame with sequence number 0

Received ACK for frame with sequence number 1

Received ACK for frame with sequence number 2

Received ACK for frame with sequence number 3

Sending frame with sequence number 4

Sending frame with sequence number 5

Sending frame with sequence number 6

Sending frame with sequence number 7

Received ACK for frame with sequence number 4

Received ACK for frame with sequence number 5

Received ACK for frame with sequence number 6

Received ACK for frame with sequence number 7

8. Write a C program to implement Stop and Wait Protocol

#include<stdio.h>

#include<stdlib.h>

#include<stdbool.h>

#include<unistd.h>

#define PACKET_SIZE 1024

typedef struct {

int seq_num;

char data[PACKET_SIZE];

} Packet;

void send_packet(Packet packet) {

printf("Sending packet with sequence number: %d\n", packet.seq_num);

// Simulate transmission delay

usleep(1000);

Packet receive_packet() {

Packet packet;

printf("Receiving packet...\n");

// Simulate reception delay

usleep(1000);

return packet;

}
void send_ack(int seq_num) {

printf("Sending ACK for sequence number: %d\n", seq_num);

// Simulate transmission delay

usleep(1000);

int main() {

int expected_seq_num = 0;

while (true) {

Packet packet = receive_packet();

if (packet.seq_num == expected_seq_num) {

send_packet(packet);

expected_seq_num++;

send_ack(expected_seq_num - 1);

return 0;

}
OUTPUT:

Receiving packet...

Sending ACK for sequence number: -1

Receiving packet...

Sending packet with sequence number: 0

Sending ACK for sequence number: 0

Receiving packet...

Sending ACK for sequence number: 0

Receiving packet...

Sending ACK for sequence number: 0

Receiving packet...

Sending ACK for sequence number: 0

Receiving packet...

Sending ACK for sequence number: 0

Receiving packet...

Sending ACK for sequence number: 0

Receiving packet...

Sending ACK for sequence number: 0

Receiving packet...

Sending ACK for sequence number: 0

Receiving packet...

Sending ACK for sequence number: 0

Receiving packet...

Sending ACK for sequence number: 0

Receiving packet...
Sending ACK for sequence number: 0

Receiving packet...

Sending ACK for sequence number: 0

Receiving packet...

Sending ACK for sequence number: 0

9). Write a C program for Congestion control using leaky bucket algorithm
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

#define BUCKET_SIZE 100 // Maximum bucket size

#define OUTPUT_RATE 10 // Output rate in packets per second

typedef struct {
int size; // Current bucket size
int output_rate; // Output rate in packets per second
} LeakyBucket;

void initializeBucket(LeakyBucket *bucket) {

bucket->size = 0;
bucket->output_rate = OUTPUT_RATE;
}

bool isBucketFull(LeakyBucket *bucket, int packet_size) {

if ((bucket->size + packet_size) > BUCKET_SIZE)
return true;
else
return false;
}

void addToBucket(LeakyBucket *bucket, int packet_size) {

if (!isBucketFull(bucket, packet_size))
bucket->size += packet_size;
}

void removeFromBucket(LeakyBucket *bucket) {

if (bucket->size > 0)
bucket->size--;
}

int main() {
LeakyBucket bucket;
initializeBucket(&bucket);

int total_packets, packet_size;

printf("Enter the total number of packets: ");
scanf("%d", &total_packets);
printf("Enter the size of each packet: ");
scanf("%d", &packet_size);

int i;
for (i = 1; i <= total_packets; i++) {
printf("\nPacket %d\n", i);
printf("Incoming packet size: %d\n", packet_size);

if (isBucketFull(&bucket, packet_size)) {
printf("Packet dropped due to congestion!\n");
} else {
addToBucket(&bucket, packet_size);
printf("Packet added to the bucket.\n");
}

printf("Bucket size after adding packet: %d\n", bucket.size);

int j;
for (j = 1; j <= bucket.output_rate; j++) {
if (bucket.size > 0) {
removeFromBucket(&bucket);
printf("Packet sent.\n");
printf("Bucket size after sending packet: %d\n", bucket.size);
} else {
printf("Bucket is empty.\n");
}
}
}

return 0;
}

OUTPUT:

Enter the total number of packets: 2

Enter the size of each packet: 3

Packet 1

Incoming packet size: 3

Packet added to the bucket.

Bucket size after adding packet: 3

Packet sent.

Bucket size after sending packet: 2

Packet sent.

Bucket size after sending packet: 1

Packet sent.

Bucket size after sending packet: 0

Bucket is empty.

Bucket is empty.

Bucket is empty.

Bucket is empty.

Bucket is empty.

Bucket is empty.

Bucket is empty.

Packet 2

Incoming packet size: 3

Packet added to the bucket.

Bucket size after adding packet: 3

Packet sent.

Bucket size after sending packet: 2

Packet sent.

Bucket size after sending packet: 1

Packet sent.

Bucket size after sending packet: 0

Bucket is empty.

Bucket is empty.

Bucket is empty.

Bucket is empty.

Bucket is empty.

Bucket is empty.

Bucket is empty.
10.Write a C program to implement Dijkstra’s algorithm to compute the shortest path
through the graph.

#include<stdio.h>

#include<stdbool.h>

#include<limits.h>

#define V 9

int minDistance(int dist[], bool visited[]) {

int min = INT_MAX, min_index;

for (int v = 0; v < V; v++)

if (visited[v] == false && dist[v] <= min)

min = dist[v], min_index = v;

return min_index;

void printSolution(int dist[]) {

printf("Vertex \t\t Distance from Source\n");

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

printf("%d \t\t %d\n", i, dist[i]);

void dijkstra(int graph[V][V], int source) {

int dist[V];
bool visited[V];

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

dist[i] = INT_MAX, visited[i] = false;

dist[source] = 0;

for (int count = 0; count < V - 1; count++) {

int u = minDistance(dist, visited);

visited[u] = true;

for (int v = 0; v < V; v++)

if (!visited[v] && graph[u][v] && dist[u] != INT_MAX && dist[u] + graph[u][v] < dist[v])

dist[v] = dist[u] + graph[u][v];

printSolution(dist);

int main() {

int graph[V][V] = {{0, 4, 0, 0, 0, 0, 0, 8, 0},

{4, 0, 8, 0, 0, 0, 0, 11, 0},

{0, 8, 0, 7, 0, 4, 0, 0, 2},

{0, 0, 7, 0, 9, 14, 0, 0, 0},

{0, 0, 0, 9, 0, 10, 0, 0, 0},

{0, 0, 4, 14, 10, 0, 2, 0, 0},

{0, 0, 0, 0, 0, 2, 0, 1, 6},

{8, 11, 0 ,0 ,0 ,0 ,1 ,0 ,7},

{0 ,0 ,2 ,0 ,0 ,6 ,7 ,8 ,9}};

dijkstra(graph, 0);

return 0;

OUTPUT:

Vertex Distance from Source

0 0

1 4

2 12

3 19

4 21

5 11

6 9

7 8

8 14
11. Write a C program to implement Distance vector routing algorithm by obtaining
routing table at each node by taking an example subnet graph with weights indicating
delay between nodes.
#include<stdio.h>
#include<stdlib.h>

#define INFINITY 9999

#define MAX_NODES 10

// Structure to represent a node in the network

typedef struct {
int cost[MAX_NODES]; // Cost to reach each node
int via[MAX_NODES]; // Next hop for each node
} Node;

// Function to initialize a node's routing table

void initNode(Node* node, int numNodes) {
for (int i = 0; i < numNodes; i++) {
node->cost[i] = INFINITY;
node->via[i] = -1;
}
}

// Function to update a node's routing table based on received information

void updateRoutingTable(Node* node, int neighbor, int* costs, int numNodes) {
for (int i = 0; i < numNodes; i++) {
if (costs[i] + node->cost[neighbor] < node->cost[i]) {
node->cost[i] = costs[i] + node->cost[neighbor];
node->via[i] = neighbor;
}
}
}

// Function to print a node's routing table

void printRoutingTable(Node* node, int numNodes) {
printf("Routing table for Node:\n");
printf("Destination\tCost\tNext Hop\n");
for (int i = 0; i < numNodes; i++) {
printf("%d\t\t%d\t%d\n", i, node->cost[i], node->via[i]);
}
}

int main() {
int numNodes = 5; // Number of nodes in the network

// Create an array of nodes

Node network[numNodes];

// Initialize each node's routing table

for (int i = 0; i < numNodes; i++) {
initNode(&network[i], numNodes);
}

// Set the initial costs for each node

network[0].cost[0] = 0;
network[1].cost[1] = 0;
network[2].cost[2] = 0;
network[3].cost[3] = 0;
network[4].cost[4] = 0;

// Simulate the exchange of routing information between nodes

for (int k = 0; k < numNodes; k++) {
for (int i = 0; i < numNodes; i++) {
for (int j = 0; j < numNodes; j++) {
if (network[i].cost[j] > network[i].cost[k] + network[k].cost[j]) {
network[i].cost[j] = network[i].cost[k] + network[k].cost[j];
network[i].via[j] = k;
}
}
}
}

// Print the final routing tables for each node

for (int i = 0; i < numNodes; i++) {
printRoutingTable(&network[i], numNodes);
printf("\n");
}

return 0;
}

OUTPUT:

Routing table for Node:

Destination Cost Next Hop

0 0 -1

1 9999 -1

2 9999 -1
3 9999 -1

4 9999 -1

Routing table for Node:

Destination Cost Next Hop

0 9999 -1

1 0 -1

2 9999 -1

3 9999 -1

4 9999 -1

Routing table for Node:

Destination Cost Next Hop

0 9999 -1

1 9999 -1

2 0 -1

3 9999 -1

4 9999 -1

Routing table for Node:

Destination Cost Next Hop

0 9999 -1

1 9999 -1

2 9999 -1

3 0 -1
4 9999 -1

Routing table for Node:

Destination Cost Next Hop

0 9999 -1

1 9999 -1

2 9999 -1

3 9999 -1

4 0 -1
12. Write a C program to implement Broadcast tree by taking subnet of hosts

#include<stdio.h>

#include<stdlib.h>

#define MAX_HOSTS 100

// Structure to represent a node in the broadcast tree

typedef struct Node {

int data;

struct Node* children[MAX_HOSTS];

int numChildren;

} Node;

// Function to create a new node

Node* createNode(int data) {

Node* newNode = (Node*)malloc(sizeof(Node));

newNode->data = data;

newNode->numChildren = 0;

return newNode;

// Function to add a child node to a parent node

void addChild(Node* parent, Node* child) {

parent->children[parent->numChildren] = child;

parent->numChildren++;

}
// Function to perform breadth-first traversal of the broadcast tree

void broadcast(Node* root) {

if (root == NULL)

return;

// Create a queue for level order traversal

Node* queue[MAX_HOSTS];

int front = 0, rear = 0;

// Enqueue the root node

queue[rear++] = root;

while (front < rear) {

// Dequeue the front node and print its data

Node* currentNode = queue[front++];

printf("%d ", currentNode->data);

// Enqueue all children of the dequeued node

for (int i = 0; i < currentNode->numChildren; i++) {

queue[rear++] = currentNode->children[i];

}
int main() {

// Create the broadcast tree

Node* root = createNode(1);

Node* node2 = createNode(2);

Node* node3 = createNode(3);

Node* node4 = createNode(4);

Node* node5 = createNode(5);

addChild(root, node2);

addChild(root, node3);

addChild(node2, node4);

addChild(node2, node5);

// Perform broadcast traversal

printf("Broadcast Tree: ");

broadcast(root);

return 0;

OUTPUT:

Broadcast Tree: 1 2 3 4 5