1. Implement the data link layer framing methods such as character, character-stuffing and bit stuffing.

program:-

#include <stdio.h>

#include <string.h>

int main() {

char a[30], fs[50] = "", t[3], sd, ed, x[3], s[3], d[3], y[3];

int i, j;

printf("Enter characters to be stuffed: ");

scanf("%s", a);

printf("\nEnter a character that represents starting delimiter: ");

scanf(" %c", &sd);

printf("\nEnter a character that represents ending delimiter: ");

scanf(" %c", &ed);

x[0] = s[0] = s[1] = sd;

x[1] = s[2] = '\0';

y[0] = d[0] = d[1] = ed;

d[2] = y[1] = '\0';

strcat(fs, x);

for (i = 0; i < strlen(a); i++) {

t[0] = a[i];

t[1] = '\0';

if (t[0] == sd) {

strcat(fs, s);

} else if (t[0] == ed) {

strcat(fs, d);

} else {

strcat(fs, t);

strcat(fs, y);

printf("\nAfter stuffing: %s\n", fs);

return 0;

}
output:-

Enter characters to be stuffed: goodday

Enter a character that represents starting delimiter: d

Enter a character that represents ending delimiter: g

After stuffing: dggooddddayg

program:-

#include <stdio.h>

#include <string.h>

main() {

char a[20], fs[50] = "", t[6], r[5];

int i, j, p = 0, q = 0;

printf("Enter bit string: ");

scanf("%s", a);

strcat(fs, "01111110");

if (strlen(a) < 5) {

strcat(fs, a);

} else {

for (i = 0; i < strlen(a) - 4; i++) {

for (j = i; j < i + 5; j++) {

t[p++] = a[j];

t[p] = '\0';

if (strcmp(t, "11111") == 0) {

strcat(fs, "111110");

i = j - 1;

} else {

r[0] = a[i];

r[1] = '\0';

strcat(fs, r);

p = 0;

for (q = i; q < strlen(a); q++) {

 t[p++] = a[q];

t[p] = '\0';

strcat(fs, t);

strcat(fs, "01111110");

printf("After stuffing: %s\n", fs);

output:-

Enter bit string: 10101111110

After stuffing: 0111111010101111101001111110

2. Write a program to compute CRC code for the polynomials CRC-12, CRC-16 and CRC CCIP

program:-

3. Develop a simple data link layer that performs the flow control using the sliding window protocol,

and loss recovery using the Go-Back-N mechanism.

program:-

#include <stdio.h>

int main() {

int window_size, sent = 0, ack, i;

printf("Enter window size: ");

scanf("%d", &window_size);

while(1) {

for(i = 0; i < window_size; i++) {

printf("Frame %d has been transmitted.\n", sent);

sent++;

if (sent == window_size) break;

printf("\nPlease enter the last Acknowledgement received: ");

scanf("%d", &ack);

if(ack == sent) break;

else sent = ack;

return 0;
}

output:-

Enter window size: 8

Frame 0 has been transmitted.

Frame 1 has been transmitted.

Frame 2 has been transmitted.

Frame 3 has been transmitted.

Frame 4 has been transmitted.

Frame 5 has been transmitted.

Frame 6 has been transmitted.

Frame 7 has been transmitted.

Please enter the last Acknowledgement received: 2

Frame 2 has been transmitted.

Frame 3 has been transmitted.

Frame 4 has been transmitted.

Frame 5 has been transmitted.

Frame 6 has been transmitted.

Frame 7 has been transmitted.

Please enter the last Acknowledgement received: 8

4. Implement Dijsktra’s algorithm to compute the shortest path through a network

program:-

#include <stdio.h>

void sort(void);

static int dsp[10][10], nodes;

struct {

char src;

char dest;

int length;

} stemp, permanent[10] = {' ', ' ', 0}, temp[10] = {' ', ' ', -1};

static int perm, tem;

int main() {

int i, j, k, l, m, n = 0, point;

char initial, dest, path[10] = {' '};

printf("\t\t Shortest Path (Dijkstra's algorithm)");

printf("\nEnter the number of nodes:");

scanf("%d", &nodes);

printf("\nEnter the adjacency matrix for the graph:\n");

for (i = 0; i < nodes; i++) {

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

scanf("%d", &dsp[i][j]);

printf("\nEnter the source node:");

scanf(" %c", &initial);

printf("\nEnter the destination node:");

scanf(" %c", &dest);

permanent[perm].src = initial;

permanent[perm].dest = initial;

permanent[perm++].length = 0;

i = permanent[perm - 1].dest - 97;

for (j = 0; j < nodes; j++) {

if (i != j) {

if (dsp[i][j] > 0) {

temp[tem].src = permanent[perm - 1].src;

temp[tem].dest = j + 97;

temp[tem++].length = dsp[i][j];

sort();

while (tem >= 0) {

j = permanent[perm - 1].dest - 97;

for (i = 0; i < nodes; i++) {

if (i != initial - 97) {

if (dsp[j][i] > 0) {

l = -1;
 for (k = 0; k < perm; k++) {

if (permanent[k].dest == (i + 97))

l = k;

for (k = 0; k <= tem; k++) {

if (temp[k].dest == (i + 97))

l = k;

if (l < 0) {

temp[tem].src = j + 97;

temp[tem].dest = i + 97;

for (m = 0; m < perm; m++) {

if (permanent[m].dest == temp[tem].src)

n = permanent[m].length;

temp[tem++].length = dsp[j][i] + n;

} else {

for (m = 0; m < perm; m++) {

if (permanent[m].dest == j + 97) {

n = permanent[m].length + dsp[j][i];

break;

} else {

n = dsp[j][i];

if ((n < temp[l].length)) {

temp[l].length = n;

temp[l].src = j + 97;

temp[l].dest = i + 97;

}
 }

sort();

printf("\nShortest path:\n");

printf("From %c to %c is:", initial, dest);

for (i = 0; i < perm - 1; i++) {

if (permanent[i].dest == dest) {

point = i;

n = i;

break;

i = 0;

for (j = perm; j > 0; j--) {

if (permanent[j - 1].dest == permanent[point].src) {

path[i++] = permanent[point].dest;

point = j - 1;

path[i] = initial;

for (j = i; j >= 0; j--)

printf("%c ", path[j]);

printf("\t length=%d", permanent[n].length);

void sort() {

int i, j, k;

for (i = 0; i <= tem; i++) {

k = 1;

for (j = 0; j <= tem; j++) {

if (temp[j].length <= temp[j + 1].length) {

stemp = temp[j];

temp[j] = temp[j + 1];

temp[j + 1] = stemp;
 k = 0;

if (k)

break;

permanent[perm++] = temp[tem - 1];

temp[tem - 1].src = ' ';

temp[tem - 1].dest = ' ';

temp[tem - 1].length = -1;

tem--;

output:-

Shortest Path (Dijkstra's algorithm)

*******************************************************

Enter the number of nodes:6

Enter the adjacency matrix for the graph:

0 1 -1 2 -1 -1

1 0 1 -1 -1 -1

-1 1 0 1 1 -1

2 -1 1 0 2 -1

-1 -1 1 2 0 3

-1 -1 -1 -1 3 0

Enter the source node:a

Enter the destination node:f

Shortest path:

From a to f is:a b c e f length=6

5. Take an example subnet of hosts and obtain a broadcast tree for the subnet.

program:-

#include <stdio.h>

int min();

int distance[20];
int n;

int main() {

int adj[20][20], adj1[20][20] = {0}, flag[30];

int i, j, root, x;

int source, count = 1, y = 0;

printf("Enter number of nodes: ");

scanf("%d", &n);

printf("Enter the adjacency matrix:\n");

for(i = 0; i < n; i++) {

for(j = 0; j < n; j++) {

scanf("%d", &adj[i][j]);

printf("Enter the source for broadcasting: ");

scanf("%d", &source);

for(i = 0; i < n; i++) {

flag[i] = 0;

for(root = 0; root < n; root++) {

for(i = 0; i < n; i++) {

distance[i] = adj[root][i];

x = min();

for(i = 0; i < n; i++) {

if(distance[i] == x) {

adj1[root][i] = x;

adj1[i][root] = x;

} else {

adj1[root][i] = 0;

for(i = 0; i < n; i++) {

 for(j = 0; j < n; j++) {

if(adj1[i][j] != 0) {

adj1[j][i] = adj[i][j];

printf("Given adjacency matrix is:\n");

for(i = 0; i < n; i++) {

for(j = 0; j < n; j++) {

printf("%d ", adj[i][j]);

printf("\n");

printf("Minimal spanning tree:\n");

for(i = 0; i < n; i++) {

for(j = 0; j < n; j++) {

printf("%d ", adj1[i][j]);

printf("\n");

root = source;

flag[root] = 1;

while(count != y) {

for(i = 0; i < n; i++) {

if(adj1[root][i] != 0 && flag[root] == 1 && flag[i] != 1) {

printf("%d sends message to %d\n", root, i);

flag[i] = 1;

if(root < n - 1) {

root++;

} else {

root = 0;
 }

for(i = 0; i < n; i++) {

if(flag[i] == 0) {

break;

if(i == n) {

count = y;

return 0;

int min() {

int i, j = 0;

int mini;

int distance1[10];

for(i = 0; i < n; i++) {

if(distance[i] != 0) {

distance1[j] = distance[i];

j++;

mini = distance1[0];

for(i = 1; i < j; i++) {

if(distance1[i] < mini) {

mini = distance1[i];

return mini;

output:-

Enter number of nodes: 2

Enter the adjacency matrix:

02

20

Enter the source for broadcasting: 1

Given adjacency matrix is:

02

20

Minimal spanning tree:

02

20

1 sends message to 0

6. Implement distance vector routing algorithm for obtaining routing tables at each node.

program:-

#include <stdio.h>

#define MAX 10

int n;

class router {

char adj_new[MAX], adj_old[MAX];

int table_new[MAX], table_old[MAX];

public:

router() {

for(int i = 0; i < MAX; i++) table_old[i] = table_new[i] = 99;

void copy() {

for(int i = 0; i < n; i++) {

adj_old[i] = adj_new[i];

table_old[i] = table_new[i];

int equal() {

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

if(table_old[i] != table_new[i] || adj_new[i] != adj_old[i]) return 0;

return 1;

}
 void input(int j) {

printf("Enter 1 if the corresponding router is adjacent to router (%c) else enter 99: ", 'A' + j);

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

if(i != j) printf("%c ", 'A' + i);

printf("\nEnter matrix:\n");

for(int i = 0; i < n; i++) {

if(i == j)

table_new[i] = 0;

else

scanf("%d", &table_new[i]);

adj_new[i] = 'A' + i;

void display() {

printf("\nDestination Router: ");

for(int i = 0; i < n; i++) printf("%c ", 'A' + i);

printf("\nOutgoing Line: ");

for(int i = 0; i < n; i++) printf("%c ", adj_new[i]);

printf("\nHop Count: ");

for(int i = 0; i < n; i++) printf("%d ", table_new[i]);

void build(int j, router r[]) {

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

for(int k = 0; i != j && k < n; k++)

if(table_old[i] != 99)

if((table_new[i] + r[i].table_new[k]) < table_new[k]) {

table_new[k] = table_new[i] + r[i].table_new[k];

adj_new[k] = 'A' + i;

};

void build_table(router r[]) {

int i = 0, j = 0;
 while(i != n) {

for(i = j; i < n; i++) {

r[i].copy();

r[i].build(i, r);

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

if(!r[i].equal()) {

j = i;

break;

int main() {

printf("Enter the number of routers: ");

scanf("%d", &n);

router r[10];

for(int i = 0; i < n; i++) r[i].input(i);

build_table(r);

for(int i = 0; i < n; i++) {

printf("Router Table entries for router %c\n", 'A' + i);

r[i].display();

return 0;

output:-

Enter the number of routers: 5

Enter 1 if the corresponding router is adjacent to router (A) else enter 99: B C D E

Enter matrix:

1 1 99 99

Enter 1 if the corresponding router is adjacent to router (B) else enter 99: A C D E

Enter matrix:

1 99 99 99

Enter 1 if the corresponding router is adjacent to router (C) else enter 99: A B D E
Enter matrix:

1 99 1 1

Enter 1 if the corresponding router is adjacent to router (D) else enter 99: A B C E

Enter matrix:

99 99 1 99

Enter 1 if the corresponding router is adjacent to router (E) else enter 99: A B C D

Enter matrix:

99 99 1 99

Router Table entries for router A

Destination Router: A B C D E

Outgoing Line: A B C C C

Hop Count: 0 1 1 2 2 Router Table entries for router B

Destination Router: A B C D E

Outgoing Line: A B A A A

Hop Count: 1 0 2 3 3 Router Table entries for router C

Destination Router: A B C D E

Outgoing Line: A A C D E

Hop Count: 1 2 0 1 1 Router Table entries for router D

Destination Router: A B C D E

Outgoing Line: C C C D C

Hop Count: 2 3 1 0 2 Router Table entries for router E

Destination Router: A B C D E

Outgoing Line: C C C C E

Hop Count: 2 3 1 2 0

7. Implement data encryption and data decryption

program:-

#include <stdio.h>

#include <string.h>

void encrypt(char *message) {

for (int i = 0; i < strlen(message); i++) {

message[i]++; // Increment each character

}
void decrypt(char *message) {

for (int i = 0; i < strlen(message); i++) {

message[i]--; // Decrement each character

int main() {

char message[100];

printf("Enter the message to be encrypted: ");

fgets(message, sizeof(message), stdin);

message[strcspn(message, "\n")] = '\0';

encrypt(message);

printf("Encrypted message: %s\n", message);

decrypt(message);

printf("Decrypted message: %s\n", message);

return 0;

output:-

Enter the message to be encrypted: HelloWorld

Encrypted message: IfmmpXpsme

Decrypted message: HelloWorld

8. Write a program for congestion control using Leaky bucket algorithm.

program:-

#include <stdlib.h>

#include <time.h>

#include <stdio.h>

#include <string.h>

#define bucketSize 512

void delay(int milliseconds) {

clock_t start_time = clock();

while (clock() < start_time + milliseconds);

void bktInput(int a, int b) {

if (a > bucketSize) {
 printf("\n\t\tBucket overflow");

} else {

delay(500);

while (a > b) {

printf("\n\t\t%d bytes outputed.", b);

a -= b;

delay(500);

if (a > 0) {

printf("\n\t\tLast %d %d ", &a,&b);

printf("bytes sent\t");

printf("\n\t\tBucket output successful");

int main() {

int op, pktSize;

srand(time(0));

printf("Enter output rate : ");

scanf("%d", &op);

for (int i = 1; i <= 5; i++) { // Start from packet 0

delay(rand() % 1000);

pktSize = rand() % 1000;

printf("\nPacket no %d", i);

printf("\tPacket size = %d", pktSize);

bktInput(pktSize, op);

return 0;

output:-

Enter output rate : 100

Packet no 1 Packet size = 579

Bucket overflow
Packet no 2 Packet size = 246

100 bytes outputed.

100 bytes outputed.

Last 6487536 6487544 bytes sent

Bucket output successful

Packet no 3 Packet size = 313

100 bytes outputed.

100 bytes outputed.

100 bytes outputed.

Last 6487536 6487544 bytes sent

Bucket output successful

Packet no 4 Packet size = 382

100 bytes outputed.

100 bytes outputed.

100 bytes outputed.

Last 6487536 6487544 bytes sent

Bucket output successful

Packet no 5 Packet size = 622

Bucket overflow

9. Write a program for frame sorting technique used in buffers.

program:-

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#define FSize 3

typedef struct packet {

int SeqNum;

char Data[FSize + 1];

} packet;

packet *readdata, *transdata;

int divide(char *msg) {

 int msglen = strlen(msg);

int NoOfPacket = (msglen + FSize - 1) / FSize;

int i, j;

readdata = (packet *)malloc(sizeof(packet) * NoOfPacket);

for (i = 0; i < NoOfPacket; i++) {

readdata[i].SeqNum = i + 1;

for (j = 0; j < FSize && *msg != '\0'; j++, msg++) {

readdata[i].Data[j] = *msg;

readdata[i].Data[j] = '\0';

printf("\nThe Message has been divided as follows:\n");

printf("Packet No. Data\n");

for (i = 0; i < NoOfPacket; i++) {

printf("%9d %s\n", readdata[i].SeqNum, readdata[i].Data);

return NoOfPacket;

void shuffle(int NoOfPacket) {

int *Status = (int *)calloc(NoOfPacket, sizeof(int));

int i, trans;

srand(time(NULL));

transdata = (packet *)malloc(sizeof(packet) * NoOfPacket);

for (i = 0; i < NoOfPacket;) {

trans = rand() % NoOfPacket;

if (Status[trans] != 1) {

transdata[i].SeqNum = readdata[trans].SeqNum;

strcpy(transdata[i].Data, readdata[trans].Data);

i++;

Status[trans] = 1;

}
 free(Status);

void sortframes(int NoOfPacket) {

int i, j;

packet temp;

for (i = 0; i < NoOfPacket - 1; i++) {

for (j = 0; j < NoOfPacket - i - 1; j++) {

if (transdata[j].SeqNum > transdata[j + 1].SeqNum) {

temp = transdata[j];

transdata[j] = transdata[j + 1];

transdata[j + 1] = temp;

void receive(int NoOfPacket) {

int i;

printf("\nPackets received in the following order:\n");

for (i = 0; i < NoOfPacket; i++) {

printf("%4d", transdata[i].SeqNum);

sortframes(NoOfPacket);

printf("\n\nPackets in order after sorting:\n");

for (i = 0; i < NoOfPacket; i++) {

printf("%4d", transdata[i].SeqNum);

printf("\n\nMessage received is:\n");

for (i = 0; i < NoOfPacket; i++) {

printf("%s", transdata[i].Data);

printf("\n");

int main() {
 char msg[100];

int NoOfPacket;

printf("\nEnter the message to be transmitted: ");

scanf(" %[^\n]s", msg); // Read message with spaces

NoOfPacket = divide(msg);

shuffle(NoOfPacket);

receive(NoOfPacket);

free(readdata);

free(transdata);

return 0;

output:-

Enter the message to be transmitted: hi, it was nice meeting u on sunday

The Message has been divided as follows:

Packet No. Data

1 hi,

2 it

3 wa

4 sn

5 ice

6 me

7 eti

8 ng

9 uo

10 n s

11 und

12 ay

Packets received in the following order:

11 2 5 3 12 8 1 10 9 7 6 4

Packets in order after sorting:

1 2 3 4 5 6 7 8 9 10 11 12

Message received is:

hi, it was nice meeting u on sunday