//TCP SERVER

#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>

int main()
{
char buf[100];
int k;
socklen_t len;
int sock_desc,temp_sock_desc;
struct sockaddr_in server,client;

sock_desc = socket(AF_INET,SOCK_STREAM,0);

if(sock_desc==-1)
printf("Error in socket creation");

server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = 3003;

k = bind(sock_desc,(struct
sockaddr*)&server,sizeof(server));
if(k==-1)
printf("Error in binding");

k = listen(sock_desc,1);
if(k ==-1)
printf("Error in listening");

len = sizeof(client);
temp_sock_desc = accept(sock_desc,(struct
sockaddr*)&client,&len);

if(temp_sock_desc==-1)
printf("Error in temporary socket
creation");

k=recv(temp_sock_desc,buf,100,0);
printf("Message got from client is :%s",buf);

printf("\n Enter data to be send");

fgets(buf,100,stdin);
k=send(temp_sock_desc,buf,100,0);

close(temp_sock_desc);
return 0;
}
//TCP CLIENT
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>
int main()
{
char buf[100];
int k;
int sock_desc;
struct sockaddr_in client;

sock_desc = socket(AF_INET,SOCK_STREAM,0);

if(sock_desc == -1)
printf("Error in socket creation");

client.sin_family = AF_INET;
client.sin_addr.s_addr = INADDR_ANY;
client.sin_port = 3003;

k = connect(sock_desc,(struct
sockaddr*)&client,sizeof(client));
if(k == -1)
printf("Error in connecting to server");

printf("\n Enter data to be send");

fgets(buf,100,stdin);
k = send(sock_desc,buf,100,0);

k = recv(sock_desc,buf,100,0);
printf("Message got from server is :%s",buf);

close(sock_desc);
return 0;
}
=====OUTPUT===========
Enter data to be sendhi
Message got from server is :helloo

Message got from client is :hi

Enter data to be sendhelloo

//VC_SERVER TCP
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>
int main()
{
char buf[100];
int k,cnt[2];
socklen_t len;
int sock_desc,temp_sock_desc;
struct sockaddr_in server,client;
sock_desc=socket(AF_INET,SOCK_STREAM,0);
if(sock_desc==-1)
printf("Error in socket creation");
server.sin_family=AF_INET;
server.sin_addr.s_addr=INADDR_ANY;
server.sin_port=3003;
 k=bind(sock_desc,(struct
sockaddr*)&server,sizeof(server));
if(k==-1)
printf("Error in binding");
k=listen(sock_desc,1);
if(k==-1)
printf("Error in listening");
len=sizeof(client);
temp_sock_desc=accept(sock_desc,(struct
sockaddr*)&client,&len);
if(temp_sock_desc==-1)
printf("Error in temporary socket
creation");
printf("Enter a word: ");
fgets(buf,100,stdin);
k=send(temp_sock_desc,buf,100,0);
k = recv(temp_sock_desc, cnt, sizeof(cnt), 0);
printf("No. of vowels : %d\n",cnt[0]);
printf("No. of consonants : %d\n",cnt[1]);
close(temp_sock_desc);
return 0;
}
//VC_CLIENT TCP
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>
int main()
{
char buf[100];
int k,l,i,cnt[2]={0,0};
int sock_desc;
struct sockaddr_in client;
sock_desc=socket(AF_INET,SOCK_STREAM,0);
if (sock_desc==-1)
printf("Error in socket creation\n");
client.sin_family=AF_INET;
client.sin_addr.s_addr=INADDR_ANY;
client.sin_port=3003;
k=connect(sock_desc,(struct
sockaddr*)&client,sizeof(client));
if(k==-1)
printf("Error in connecting to server\n");
k = recv(sock_desc, buf, sizeof(buf) - 1, 0);
buf[k] = '\0';
printf("Word received from server : %s\n",buf);
l=strlen(buf);
for (i=0;i<l;i++)
{
if ((buf[i] >= 'A' && buf[i] <= 'Z') ||
(buf[i] >= 'a' && buf[i] <= 'z'))
{
if(buf[i]== 'a'|| buf[i]== 'e'||
buf[i]== 'i'|| buf[i]== 'o'|| buf[i]== 'u'|| buf[i]==
'A'|| buf[i]== 'E'|| buf[i]== 'I'|| buf[i]== 'O'||
buf[i]== 'U')
cnt[0]++;
 else
cnt[1]++;
}
}
printf("No. of vowels : %d\n", cnt[0]);
printf("No. of consonants : %d\n", cnt[1]);
k=send(sock_desc,cnt,sizeof(cnt),0);
close(sock_desc);
return 0;
}
=====OUTPUT===========
Enter a word: Marian
No. of vowels : 3
No. of consonants : 3

Word received from server : Marian

No. of vowels : 3
No. of consonants : 3

//UDP_CLIENT

//UDP_CLIENT
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>
int main()
{
char buf[100];
int k;
int sock_desc;
struct sockaddr_in server,client;
sock_desc=socket(AF_INET,SOCK_DGRAM,0);
if(sock_desc==-1)
printf("Error in socket creation\n");
server.sin_family=AF_INET;
server.sin_addr.s_addr=INADDR_ANY;
server.sin_port=100;
printf("\nEnter data to be send: ");
fgets(buf,100,stdin);
k=sendto(sock_desc,buf,100,0,(struct
sockaddr*)&server,sizeof(server));
char rebuf[100];
struct sockaddr_in from;
socklen_t len = sizeof(server);
k = recvfrom(sock_desc, rebuf, sizeof(rebuf), 0,
(struct sockaddr*)&server, &len);
printf("Message received from server: %s\n",
rebuf);

close(sock_desc);
return 0;
}
//UDP_SERVER
//UDP_SERVER
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>
int main()
{

int sock_desc;
struct sockaddr_in server,client;
sock_desc=socket(AF_INET,SOCK_DGRAM,0);
if(sock_desc==-1)
printf("Error in socketcreation\n");
server.sin_family=AF_INET;
server.sin_addr.s_addr=INADDR_ANY;
server.sin_port=100;
k=bind(sock_desc,(struct
sockaddr*)&server,sizeof(server));
if(k==-1)
printf("Error in binding\n");
len = sizeof(client);
k=recvfrom(sock_desc,buf,100,0,(struct
sockaddr*)&client,&len);
printf("\nMessage got from client is:%s",buf);
char sendbuf[100];
printf("Enter data to be send: ");
fgets(sendbuf,100,stdin);
k=sendto(sock_desc,sendbuf,100,0,(struct
sockaddr*)&client,sizeof(client));
close(sock_desc);
return 0;
}
=====OUTPUT===========
Enter data to be send: hi
Message received from server: hello

Message got from client is:hi

Enter data to be send: hello

//TIME S UDP
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <time.h>

#define MAX_CLIENTS 10

struct client_info {
char ip[20];
int port;
};
struct client_info clients[MAX_CLIENTS];
int client_count = 0;

int main()
{
int sockfd;
char buffer[50];
struct sockaddr_in servaddr, cliaddr;
socklen_t len;
pid_t pid;

sockfd = socket(AF_INET, SOCK_DGRAM, 0);

servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = INADDR_ANY;
servaddr.sin_port = 1234;
bind(sockfd, (struct sockaddr *)&servaddr,
sizeof(servaddr));

printf("UDP Concurrent Time Server started\n");

do
{
len = sizeof(cliaddr);

recvfrom(sockfd, buffer, sizeof(buffer), 0,

(struct sockaddr *)&cliaddr, &len);

int client_number = -1;

char *ip = inet_ntoa(cliaddr.sin_addr);
int port = cliaddr.sin_port;

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

{
if(strcmp(clients[i].ip, ip) == 0 &&
clients[i].port == port)
{
client_number = i + 1;
break;
}
}

if(client_number == -1 && client_count <

MAX_CLIENTS)
{
strcpy(clients[client_count].ip, ip);
clients[client_count].port = port;
client_number = client_count + 1;
client_count++;
}

printf("Message from Client %d : %s\n",

client_number, buffer);

pid = fork();

if (pid == 0)
 {
time_t rawtime;
struct tm *timeinfo;
time(&rawtime);
timeinfo = localtime(&rawtime);

sprintf(buffer, "Time is %02d:%02d:%02d",

timeinfo->tm_hour,
timeinfo->tm_min,
timeinfo->tm_sec);

sendto(sockfd, buffer, strlen(buffer) + 1,

0,
(struct sockaddr *)&cliaddr, len);

printf("Time sent to Client %d\n",

client_number);
}

} while(strcmp(buffer,"stop")!=0);

close(sockfd);
return 0;
}
// TIME C1 UDP
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

int main()
{
int sockfd;
char buffer[50];
struct sockaddr_in addr;
socklen_t s;

sockfd = socket(AF_INET, SOCK_DGRAM, 0);

addr.sin_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = 1234;

s = sizeof(addr);

do
{
printf("Enter message for server: ");
scanf("%s", buffer);

if (strcmp(buffer, "stop") == 0)
break;

sendto(sockfd, buffer, sizeof(buffer), 0,

(struct sockaddr *)&addr, s);
 recvfrom(sockfd, buffer, sizeof(buffer), 0,
(struct sockaddr *)&addr, &s);

printf("Received from server: %s\n", buffer);

} while (strcmp(buffer, "stop") != 0);

close(sockfd);
return 0;
}
// TIME C2 UDP
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

int main()
{
int sockfd;
char buffer[50];
struct sockaddr_in addr;
socklen_t s;

sockfd = socket(AF_INET, SOCK_DGRAM, 0);

addr.sin_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = 1234;

s = sizeof(addr);

do
{
printf("Enter message for server: ");
scanf("%s", buffer);

if (strcmp(buffer, "stop") == 0)
break;

sendto(sockfd, buffer, sizeof(buffer), 0,

(struct sockaddr *)&addr, s);

recvfrom(sockfd, buffer, sizeof(buffer), 0,

(struct sockaddr *)&addr, &s);

printf("Received from server: %s\n", buffer);

} while (strcmp(buffer, "stop") != 0);

close(sockfd);
return 0;
}
=====OUTPUT===========
UDP Concurrent Time Server started
Message from Client 1 : time
Time sent to Client 1
Message from Client 1 : time
Time sent to Client 1
Message from Client 2 : time
Time sent to Client 2
Message from Client 2 : time
Time sent to Client 2
Message from Client 1 : time
Time sent to Client 1
Message from Client 1 : time
Time sent to Client 1
Message from Client 2 : time
Time sent to Client 2
Enter message for server: time
Received from server: Time is 15:02:26
Enter message for server: time
Received from server: Time is 15:02:34
Enter message for server: time
Received from server: Time is 15:31:34
Enter message for server: time
Received from server: Time is 15:02:00
Enter message for server: time
Received from server: Time is 15:02:06
Enter message for server: time
Received from server: Time is 15:02:38
Enter message for server: time
Received from server: Time is 15:31:29

//PALINDROME_SERVER TCP
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>

int main()
{
char buf[100];
int k,result;
socklen_t len;
int sock_desc,temp_sock_desc;
struct sockaddr_in server,client;

sock_desc = socket(AF_INET,SOCK_STREAM,0);

if(sock_desc==-1)
printf("Error in socket creation");

server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = 3003;

k = bind(sock_desc,(struct
sockaddr*)&server,sizeof(server));
 if(k==-1)
printf("Error in binding");

k = listen(sock_desc,1);

if(k==-1)
printf("Error in listening");

len = sizeof(client);

temp_sock_desc = accept(sock_desc,(struct
sockaddr*)&client,&len);

if(temp_sock_desc==-1)
printf("Error in temporary socket creation");

printf("Enter a word: ");

fgets(buf,100,stdin);

k = send(temp_sock_desc,buf,100,0);

k = recv(temp_sock_desc,&result,sizeof(result),0);

if(result==1)
printf("The word is a palindrome\n");
else
printf("The word is not a palindrome\n");

close(temp_sock_desc);
return 0;
}

//PALINDROME_CLIENT TCP
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>

int main()
{
char buf[100];
int k,l,i,flag=1;
int sock_desc;
struct sockaddr_in client;

sock_desc = socket(AF_INET,SOCK_STREAM,0);

if(sock_desc==-1)
printf("Error in socket creation");

client.sin_family = AF_INET;
client.sin_addr.s_addr = INADDR_ANY;
client.sin_port = 3003;
 k = connect(sock_desc,(struct
sockaddr*)&client,sizeof(client));

if(k==-1)
printf("Error in connecting to server");

k = recv(sock_desc,buf,sizeof(buf)-1,0);
buf[k]='\0';

printf("Word received from server : %s\n",buf);

l = strlen(buf)-1;

for(i=0;i<l/2;i++)
{
if(buf[i]!=buf[l-i-1])
{
flag=0;
break;
}
}

if(flag==1)
printf("Palindrome\n");
else
printf("Not Palindrome\n");

k = send(sock_desc,&flag,sizeof(flag),0);

close(sock_desc);
return 0;
}

//STRING_REVERSE_SERVER TCP
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>

int main()
{
char buf[100];
int k;
socklen_t len;
int sock_desc,temp_sock_desc;
struct sockaddr_in server,client;

sock_desc = socket(AF_INET,SOCK_STREAM,0);

if(sock_desc==-1)
printf("Error in socket creation");

server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = 3003;
 k = bind(sock_desc,(struct
sockaddr*)&server,sizeof(server));

if(k==-1)
printf("Error in binding");

k = listen(sock_desc,1);

if(k==-1)
printf("Error in listening");

len = sizeof(client);

temp_sock_desc = accept(sock_desc,(struct
sockaddr*)&client,&len);

if(temp_sock_desc==-1)
printf("Error in temporary socket creation");

printf("Enter a string: ");

fgets(buf,100,stdin);

k = send(temp_sock_desc,buf,100,0);

k = recv(temp_sock_desc,buf,100,0);

printf("Reversed string from client : %s\n",buf);

close(temp_sock_desc);
return 0;
}

//STRING_REVERSE_CLIENT TCP
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>

int main()
{
char buf[100],rev[100];
int k,l,i;
int sock_desc;
struct sockaddr_in client;

sock_desc = socket(AF_INET,SOCK_STREAM,0);

if(sock_desc==-1)
printf("Error in socket creation");

client.sin_family = AF_INET;
client.sin_addr.s_addr = INADDR_ANY;
client.sin_port = 3003;

k = connect(sock_desc,(struct
sockaddr*)&client,sizeof(client));
 if(k==-1)
printf("Error in connecting to server");

k = recv(sock_desc,buf,sizeof(buf)-1,0);
buf[k]='\0';

printf("String received from server : %s\n",buf);

l = strlen(buf);

for(i=0;i<l;i++)
rev[i] = buf[l-i-1];

rev[l] = '\0';

printf("Reversed string : %s\n",rev);

k = send(sock_desc,rev,100,0);

close(sock_desc);
return 0;
}

//TCP FACTORIAL SERVER

#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>

int main()
{
int sock_desc,temp_sock_desc;
int num,fact=1,i,k;
socklen_t len;

struct sockaddr_in server,client;

sock_desc = socket(AF_INET,SOCK_STREAM,0);

if(sock_desc==-1)
printf("Error in socket creation");

server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = 3003;

k = bind(sock_desc,(struct
sockaddr*)&server,sizeof(server));

if(k==-1)
printf("Error in binding");

listen(sock_desc,1);

len = sizeof(client);
 temp_sock_desc = accept(sock_desc,(struct
sockaddr*)&client,&len);

recv(temp_sock_desc,&num,sizeof(num),0);

printf("Number received from client : %d\n",num);

for(i=1;i<=num;i++)
fact = fact * i;

send(temp_sock_desc,&fact,sizeof(fact),0);

printf("Factorial sent to client\n");

close(temp_sock_desc);
close(sock_desc);

return 0;
}

// TCP FACTORIAL CLIENT

#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>

int main()
{
int sock_desc;
int num,fact,k;

struct sockaddr_in client;

sock_desc = socket(AF_INET,SOCK_STREAM,0);

if(sock_desc==-1)
printf("Error in socket creation");

client.sin_family = AF_INET;
client.sin_addr.s_addr = INADDR_ANY;
client.sin_port = 3003;

k = connect(sock_desc,(struct
sockaddr*)&client,sizeof(client));

if(k==-1)
printf("Error in connecting");

printf("Enter a number : ");

scanf("%d",&num);

send(sock_desc,&num,sizeof(num),0);

recv(sock_desc,&fact,sizeof(fact),0);
 printf("Factorial is : %d\n",fact);

close(sock_desc);

return 0;
}
Enter a number : 5
Factorial is : 120

Number received from client : 5

Factorial sent to client

UDP VC

////UDP_VC_SERVER
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>

int main()
{
char buf[100];
int cnt[2];
int k,i,l;
socklen_t len;

int sock_desc;
struct sockaddr_in server,client;

sock_desc=socket(AF_INET,SOCK_DGRAM,0);

if(sock_desc==-1)
printf("Error in socket creation\n");

server.sin_family=AF_INET;
server.sin_addr.s_addr=INADDR_ANY;
server.sin_port=100;

k=bind(sock_desc,(struct
sockaddr*)&server,sizeof(server));

if(k==-1)
printf("Error in binding\n");

len=sizeof(client);

k=recvfrom(sock_desc,buf,100,0,(struct
sockaddr*)&client,&len);

printf("Word received from client: %s\n",buf);

l=strlen(buf);

cnt[0]=0;
cnt[1]=0;
 for(i=0;i<l;i++)
{
if((buf[i]>='A'&&buf[i]<='Z')||
(buf[i]>='a'&&buf[i]<='z'))
{
if(buf[i]=='a'||buf[i]=='e'||buf[i]=='i'||
buf[i]=='o'||buf[i]=='u'||
buf[i]=='A'||buf[i]=='E'||buf[i]=='I'||
buf[i]=='O'||buf[i]=='U')
cnt[0]++;
else
cnt[1]++;
}
}

sendto(sock_desc,cnt,sizeof(cnt),0,(struct
sockaddr*)&client,sizeof(client));

close(sock_desc);
}

////UDP_VC_CLIENT
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>

int main()
{
char buf[100];
int cnt[2];
int k;

int sock_desc;
struct sockaddr_in server;

sock_desc=socket(AF_INET,SOCK_DGRAM,0);

server.sin_family=AF_INET;
server.sin_addr.s_addr=INADDR_ANY;
server.sin_port=100;

printf("Enter a word: ");

fgets(buf,100,stdin);

sendto(sock_desc,buf,100,0,(struct
sockaddr*)&server,sizeof(server));

socklen_t len=sizeof(server);

recvfrom(sock_desc,cnt,sizeof(cnt),0,(struct
sockaddr*)&server,&len);

printf("No. of vowels: %d\n",cnt[0]);

printf("No. of consonants: %d\n",cnt[1]);
 close(sock_desc);
}

UDP PALIND

////UDP_PAL_SERVER
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>

int main()
{
char buf[100];
int flag=1;
int i,l,k;
socklen_t len;

int sock_desc;
struct sockaddr_in server,client;

sock_desc=socket(AF_INET,SOCK_DGRAM,0);

server.sin_family=AF_INET;
server.sin_addr.s_addr=INADDR_ANY;
server.sin_port=100;

bind(sock_desc,(struct
sockaddr*)&server,sizeof(server));

len=sizeof(client);

recvfrom(sock_desc,buf,100,0,(struct
sockaddr*)&client,&len);

printf("Word received: %s\n",buf);

l=strlen(buf)-1;

for(i=0;i<l/2;i++)
{
if(buf[i]!=buf[l-i-1])
{
flag=0;
break;
}
}

sendto(sock_desc,&flag,sizeof(flag),0,(struct
sockaddr*)&client,sizeof(client));

close(sock_desc);
}

////UDP_PAL_CLIENT
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>

int main()
{
char buf[100];
int flag;
int sock_desc;

struct sockaddr_in server;

sock_desc=socket(AF_INET,SOCK_DGRAM,0);

server.sin_family=AF_INET;
server.sin_addr.s_addr=INADDR_ANY;
server.sin_port=100;

printf("Enter a word: ");

fgets(buf,100,stdin);

sendto(sock_desc,buf,100,0,(struct
sockaddr*)&server,sizeof(server));

socklen_t len=sizeof(server);

recvfrom(sock_desc,&flag,sizeof(flag),0,(struct
sockaddr*)&server,&len);

if(flag==1)
printf("Palindrome\n");
else
printf("Not Palindrome\n");

close(sock_desc);
}

UDP REVERSE

//UDP_REV_SERVER
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>

int main()
{
char buf[100],rev[100];
int i,l;
socklen_t len;

int sock_desc;
struct sockaddr_in server,client;

sock_desc=socket(AF_INET,SOCK_DGRAM,0);
 server.sin_family=AF_INET;
server.sin_addr.s_addr=INADDR_ANY;
server.sin_port=100;

bind(sock_desc,(struct
sockaddr*)&server,sizeof(server));

len=sizeof(client);

recvfrom(sock_desc,buf,100,0,(struct
sockaddr*)&client,&len);

printf("String received: %s\n",buf);

l=strlen(buf);

for(i=0;i<l;i++)
rev[i]=buf[l-i-1];

rev[l]='\0';

sendto(sock_desc,rev,100,0,(struct
sockaddr*)&client,sizeof(client));

close(sock_desc);
}

////UDP_REV_CLIENT
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>

int main()
{
char buf[100];
int sock_desc;

struct sockaddr_in server;

sock_desc=socket(AF_INET,SOCK_DGRAM,0);

server.sin_family=AF_INET;
server.sin_addr.s_addr=INADDR_ANY;
server.sin_port=100;

printf("Enter a string: ");

fgets(buf,100,stdin);

sendto(sock_desc,buf,100,0,(struct
sockaddr*)&server,sizeof(server));

socklen_t len=sizeof(server);

recvfrom(sock_desc,buf,100,0,(struct
sockaddr*)&server,&len);
 printf("Reversed string: %s\n",buf);

close(sock_desc);
}

//UDP FACTORIAL SERVER

#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>

int main()
{
int sock_desc;
int num,fact=1,i;

socklen_t len;

struct sockaddr_in server,client;

sock_desc = socket(AF_INET,SOCK_DGRAM,0);

server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = 100;

bind(sock_desc,(struct
sockaddr*)&server,sizeof(server));

len = sizeof(client);

recvfrom(sock_desc,&num,sizeof(num),0,
(struct sockaddr*)&client,&len);

printf("Number received from client : %d\n",num);

for(i=1;i<=num;i++)
fact = fact * i;

sendto(sock_desc,&fact,sizeof(fact),0,
(struct sockaddr*)&client,sizeof(client));

close(sock_desc);

return 0;
}

//UDP FACTORIAL CLIENT

#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>

int main()
{
int sock_desc;
int num,fact;

socklen_t len;

struct sockaddr_in server;

sock_desc = socket(AF_INET,SOCK_DGRAM,0);

server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = 100;

printf("Enter a number : ");

scanf("%d",&num);

sendto(sock_desc,&num,sizeof(num),0,
(struct sockaddr*)&server,sizeof(server));

len = sizeof(server);

recvfrom(sock_desc,&fact,sizeof(fact),0,
(struct sockaddr*)&server,&len);

printf("Factorial is : %d\n",fact);

close(sock_desc);

return 0;
}
Enter a number : 6
Factorial is : 720

Number received from client : 6

//LEAKY BUCKET ALGORITHM

#include <stdio.h>

int main() {
int bucketSize,outputRate,numberOfPackets;
int currentBucket = 0;
int packetSize;

printf("Enter bucket size: ");

scanf("%d", &bucketSize);
printf("Enter output rate: ");
scanf("%d", &outputRate);
printf("Enter number of packets: ");
scanf("%d", &numberOfPackets);

for (int i = 1; i <= numberOfPackets; i++)

{
printf("\nEnter size of packet %d: ", i);
scanf("%d", &packetSize);
 if (currentBucket + packetSize > bucketSize)
{
printf("Packet %d is DROPPED (Bucket
Overflow)\n", i);
} else
{
currentBucket = currentBucket +
packetSize;
printf("Packet %d is ADDED to bucket\n",
i);
}

if (currentBucket > 0)
{
int bytesToSend;

if (currentBucket < outputRate)

{
bytesToSend = currentBucket;
} else
{
bytesToSend = outputRate;
}
currentBucket = currentBucket -
bytesToSend;

printf("Transmitting %d bytes...\n",
bytesToSend);
printf("Bytes remaining in bucket: %d\n",
currentBucket);
}
}
return 0;
}
=====OUTPUT===========
Enter bucket size: 150
Enter output rate: 100
Enter number of packets: 3

Enter size of packet 1: 150

Packet 1 is ADDED to bucket
Transmitting 100 bytes...
Bytes remaining in bucket: 50

Enter size of packet 2: 250

Packet 2 is DROPPED (Bucket Overflow)
Transmitting 50 bytes...
Bytes remaining in bucket: 0

Enter size of packet 3: 100

Packet 3 is ADDED to bucket
Transmitting 100 bytes...
Bytes remaining in bucket: 0

// FILE TRANSFER PROTOCOL

// server_ftp.c
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>

int main() {
char buf[1024]; // Increased buffer for file
content
char filename[100];
int sock_desc, temp_sock_desc;
struct sockaddr_in server, client;
socklen_t len;

sock_desc = socket(AF_INET, SOCK_STREAM, 0);

server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = htons(3003); // Use htons for
proper byte order

bind(sock_desc, (struct sockaddr*)&server,

sizeof(server));
listen(sock_desc, 1);

printf("Server waiting for file request...\n");

len = sizeof(client);
temp_sock_desc = accept(sock_desc, (struct
sockaddr*)&client, &len);

// 1. Receive the filename from client

recv(temp_sock_desc, filename, sizeof(filename),
0);
// Remove newline if fgets was used on client side
filename[strcspn(filename, "\n")] = 0;
printf("Client requested file: %s\n", filename);

// 2. Open and read the file

FILE *fp = fopen(filename, "r");
if (fp == NULL) {
send(temp_sock_desc, "File not found", 15, 0);
} else {
// Read file content into buffer
// Note: For large files, you'd use a loop.
For simplicity, we use one buffer.
int bytes_read = fread(buf, 1, sizeof(buf),
fp);
send(temp_sock_desc, buf, bytes_read, 0);
fclose(fp);
}

close(temp_sock_desc);
close(sock_desc);
return 0;
}
// client_ftp.c
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

int main() {
char buf[1024];
char filename[100];
int sock_desc;
struct sockaddr_in client;

sock_desc = socket(AF_INET, SOCK_STREAM, 0);

client.sin_family = AF_INET;
client.sin_addr.s_addr = INADDR_ANY;
client.sin_port = htons(3003);

if(connect(sock_desc, (struct sockaddr*)&client,

sizeof(client)) == -1) {
printf("Connection failed\n");
return 1;
}

printf("Enter filename to download: ");

fgets(filename, 100, stdin);
send(sock_desc, filename, strlen(filename), 0);

int n = recv(sock_desc, buf, sizeof(buf), 0);

buf[n] = '\0';

if (strcmp(buf, "File not found") == 0) {

printf("Server Error: %s\n", buf);
} else {

FILE *fp = fopen("received_file.txt", "w");

if (fp != NULL) {
fprintf(fp, "%s", buf);
fclose(fp);
printf("File received successfully and
saved as 'received_file.txt'\n");
}
}

close(sock_desc);
return 0;
}
output
----------------------
server
Server waiting for file request...
Client requested file: LINK.c

client
Enter filename to download: LINK.c
File received successfully and saved as
'received_file.txt'
// SLIDING WINDOW PROTOCOL

//sliding window
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <time.h>
#include <unistd.h>
void stopAndWait(int totalFrames);
void goBackN(int totalFrames, int windowSize);
void selectiveRepeat(int totalFrames, int windowSize);
int main() {
int choice, totalFrames = 5, windowSize = 3;
printf("--- Network Flow Control Simulation ---\n");
printf("1. Stop and Wait ARQ\n");
printf("2. Go-Back-N ARQ\n");
printf("3. Selective Repeat ARQ\n");
printf("Enter choice: ");
scanf("%d", &choice);
switch(choice) {
case 1: stopAndWait(totalFrames); break;
case 2: goBackN(totalFrames, windowSize); break;
case 3: selectiveRepeat(totalFrames, windowSize);
break;
default: printf("Invalid choice!\n");
}
return 0;
}
// --- 1. STOP AND WAIT ---
void stopAndWait(int totalFrames)
{
int i = 1;
while (i <= totalFrames)
{
printf("\n[Sender]: Sending Frame %d...", i);
// Simulate random loss (20% chance)
if (rand() % 5 == 0)
{
printf("\n[Error]: Frame %d lost! Retransmitting...",
i);
continue;
}
printf("\n[Receiver]: Frame %d received. Sending ACK
%d...", i, i + 1);
i++;
}
printf("\n\nAll frames sent successfully.\n");
}
// --- 2. GO-BACK-N ---
void goBackN(int totalFrames, int windowSize)
{
int sent = 0, acked = 0;
while (acked < totalFrames)
{
// Send frames within the window
for (int i = sent; i < acked + windowSize && i <
totalFrames; i++)
 {
printf("\n[Sender]: Sending Frame %d", i);
sent++;
}
// Simulate acknowledgment for the first frame in the
window
int randomBit = rand() % 4;
if (randomBit == 0) { // Simulate loss
printf("\n[Error]: Frame %d lost! Window resets.",
acked);
sent = acked; // Go Back to the last unacked frame
} else
{
printf("\n[Receiver]: Received Frame %d. Sending
ACK.", acked);
acked++;
}
}
printf("\n\nAll frames sent successfully.\n");
}
// --- 3. SELECTIVE REPEAT ---
void selectiveRepeat(int totalFrames, int windowSize)
{
bool ackStatus[10] = {false};
int ackedCount = 0;
while (ackedCount < totalFrames)
{
for (int i = 0; i < totalFrames; i++)
{
if (!ackStatus[i])
{
printf("\n[Sender]: Sending Frame %d", i);
if (rand() % 3 != 0) { // 66% success rate
printf(" -> [Receiver]: Frame %d received & ACKed",
i);
ackStatus[i] = true;
ackedCount++;
} else {
printf(" -> [Error]: Frame %d dropped!", i);
}
}
}
printf("\n--- End of Current Window Pass ---\n");
}

output
---------------------------
-- Network Flow Control Simulation ---
1. Stop and Wait ARQ
2. Go-Back-N ARQ
3. Selective Repeat ARQ
Enter choice: 1

[Sender]: Sending Frame 1...

[Receiver]: Frame 1 received. Sending ACK 2...
[Sender]: Sending Frame 2...
[Receiver]: Frame 2 received. Sending ACK 3...
[Sender]: Sending Frame 3...
[Receiver]: Frame 3 received. Sending ACK 4...
[Sender]: Sending Frame 4...
[Error]: Frame 4 lost! Retransmitting...
[Sender]: Sending Frame 4...
[Receiver]: Frame 4 received. Sending ACK 5...
[Sender]: Sending Frame 5...
[Error]: Frame 5 lost! Retransmitting...
[Sender]: Sending Frame 5...
[Receiver]: Frame 5 received. Sending ACK 6...

All frames sent successfully.

--- Network Flow Control Simulation ---

1. Stop and Wait ARQ
2. Go-Back-N ARQ
3. Selective Repeat ARQ
Enter choice: 2

[Sender]: Sending Frame 0

[Sender]: Sending Frame 1
[Sender]: Sending Frame 2
[Receiver]: Received Frame 0. Sending ACK.
[Sender]: Sending Frame 3
[Receiver]: Received Frame 1. Sending ACK.
[Sender]: Sending Frame 4
[Receiver]: Received Frame 2. Sending ACK.
[Receiver]: Received Frame 3. Sending ACK.
[Receiver]: Received Frame 4. Sending ACK.

All frames sent successfully.

-- Network Flow Control Simulation ---

1. Stop and Wait ARQ
2. Go-Back-N ARQ
3. Selective Repeat ARQ
Enter choice: 3

[Sender]: Sending Frame 0 -> [Receiver]: Frame 0

received & ACKed
[Sender]: Sending Frame 1 -> [Receiver]: Frame 1
received & ACKed
[Sender]: Sending Frame 2 -> [Error]: Frame 2 dropped!
[Sender]: Sending Frame 3 -> [Receiver]: Frame 3
received & ACKed
[Sender]: Sending Frame 4 -> [Receiver]: Frame 4
received & ACKed
--- End of Current Window Pass ---

[Sender]: Sending Frame 2 -> [Receiver]: Frame 2

received & ACKed
--- End of Current Window Pass ---

// LINK STATE ROUTING USING DIJKSTRA ALGORITHM

#include <stdio.h>
#include <limits.h>
#define N 10

void dijkstra(int g[N][N], int n, int src)

{
int d[N], vis[N] = {0};

// Initialize distances
for(int i = 0; i < n; i++)
d[i] = INT_MAX;

d[src] = 0;

// Find shortest path

for(int i = 0; i < n - 1; i++)
{
int u = -1, min = INT_MAX;

// Select minimum distance node

for(int j = 0; j < n; j++)
{
if(!vis[j] && d[j] < min)
{
min = d[j];
u = j;
}
}

vis[u] = 1;

// Update distances of adjacent nodes

for(int v = 0; v < n; v++)
{
if(g[u][v] && !vis[v] &&
d[u] + g[u][v] < d[v])
{
d[v] = d[u] + g[u][v];
}
}
}

// Display shortest distances

printf("\nNode\tDistance from Source %d\n", src);

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

{
if(d[i] == INT_MAX)
printf("%d\tUnreachable\n", i);
else
printf("%d\t%d\n", i, d[i]);
}
}

int main()
{
int g[N][N], n, src;

printf("Enter number of nodes (max %d): ", N);

 scanf("%d", &n);

printf("Enter adjacency matrix (0 for no edge):\

n");

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

{
for(int j = 0; j < n; j++)
{
scanf("%d", &g[i][j]);
}
}

printf("Enter source node (0 to %d): ", n - 1);

scanf("%d", &src);

// Display adjacency matrix

printf("\nAdjacency Matrix:\n\n");

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

printf("\n");

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

{
printf("%4d", i);

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

{
printf("%4d", g[i][j]);
}

printf("\n");
}

// Call Dijkstra Function

dijkstra(g, n, src);

return 0;
}

Enter number of nodes (max 10): 5

Enter adjacency matrix (0 for no edge):

0 10 0 30 100
10 0 50 0 0
0 50 0 20 10
30 0 20 0 60
100 0 10 60 0

Enter source node (0 to 4): 2

Adjacency Matrix:

0 1 2 3 4
 0 0 10 0 30 100
1 10 0 50 0 0
2 0 50 0 20 10
3 30 0 20 0 60
4 100 0 10 60 0

Node Distance from Source 2

0 50
1 50
2 0
3 20
4 10

// CONCURRENT FTP SERVER USING TCP

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>

int main()
{
char buf[1024];
char filename[100];

int sock_desc, temp_sock_desc;

int pid;

struct sockaddr_in server, client;

socklen_t len;

// Create Socket
sock_desc = socket(AF_INET, SOCK_STREAM, 0);

// Server Details
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = htons(3003);

// Bind
bind(sock_desc,
(struct sockaddr*)&server,
sizeof(server));

// Listen
listen(sock_desc, 5);

printf("Concurrent FTP Server Started...\n");

while(1)
{
len = sizeof(client);
 // Accept Client Connection
temp_sock_desc = accept(sock_desc,(struct
sockaddr*)&client, &len);

if(temp_sock_desc < 0)
{
printf("Connection failed\n");
continue;
}

pid = fork();

// Child Process
if(pid == 0)
{
close(sock_desc);

// Receive filename
recv(temp_sock_desc,
filename,
sizeof(filename),
0);

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

printf("Client requested file : %s\n",

filename);

FILE *fp;

fp = fopen(filename, "r");

if(fp == NULL)
{
send(temp_sock_desc, "File not found",
15,0);
}
else
{
int bytes_read;

bytes_read = fread(buf, 1,
sizeof(buf), fp);

send(temp_sock_desc,buf,bytes_read,
0);

fclose(fp);

printf("File sent successfully\n");

}

close(temp_sock_desc);

exit(0);
}
 // Parent Process
close(temp_sock_desc);
}

close(sock_desc);

return 0;
}

// CONCURRENT FTP CLIENT USING TCP

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

int main()
{
char buf[1024];
char filename[100];

int sock_desc;

struct sockaddr_in client;

// Create Socket
sock_desc = socket(AF_INET, SOCK_STREAM, 0);

// Client Details
client.sin_family = AF_INET;
client.sin_addr.s_addr = INADDR_ANY;
client.sin_port = htons(3003);

// Connect to Server
if(connect(sock_desc, (struct sockaddr*)&client,
sizeof(client)) == -1)
{
printf("Connection failed\n");
return 1;
}

// Enter filename
printf("Enter filename to download : ");

fgets(filename, 100, stdin);

// Send filename
send(sock_desc,filename,strlen(filename), 0);

// Receive file content

int n;

n = recv(sock_desc,buf,sizeof(buf),0);

buf[n] = '\0';

// Check response
 if(strcmp(buf, "File not found") == 0)
{
printf("Server Error : %s\n", buf);
}
else
{
FILE *fp;

fp = fopen("received_file.txt", "w");

if(fp != NULL)
{
fprintf(fp, "%s", buf);

fclose(fp);

printf("File received successfully\n");

printf("Saved as 'received_file.txt'\n");
}
}

close(sock_desc);

return 0;
}