#include<stdio.
h>
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<fcntl.h>
#include<string.h>
#include<netdb.h>
#include<stdlib.h>
#include<unistd.h>
void main()
{
struct sockaddr_in serveraddr;
int clientsock,n,rdret,length;
char filename[20],filedata[300];
bzero((char*)&serveraddr,sizeof(serveraddr));
serveraddr.sin_family=AF_INET;
serveraddr.sin_port=2000;
serveraddr.sin_addr.s_addr=inet_addr("127.0.0.1");
clientsock=socket(AF_INET,SOCK_STREAM,0);
if(connect(clientsock,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<0)
{
printf("\nError:Cannot connect...");
exit(0);
}
printf("Enter the name of the file : ");
scanf("%s",filename);
length=strlen(filename);
write(clientsock,filename,length);
rdret=read(clientsock,filedata,300);
printf("\nThe contents of the file: \n\n");
printf("%s",filedata);
close(clientsock);
}
/*
gedit Ftpclient.c
gcc Ftpclient.c
./a.out 127.0.0.1 5678
Enter the name of the file : text.txt
The contents of the file:
Hi!
The file transfer was successful.
*/
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<fcntl.h>
#include<string.h>
#include <unistd.h>
void main()
{
struct sockaddr_in clientaddr,serveraddr;
int serversock,newserversock,clientsize,n,f,rc;
char filename[100],filedata[300];
fflush(stdin);
serversock=socket(AF_INET,SOCK_STREAM,0);
bzero((char*)&serveraddr,sizeof(serveraddr));
serveraddr.sin_family=AF_INET;
serveraddr.sin_port=2000;
serveraddr.sin_addr.s_addr=inet_addr("127.0.0.1");
bind(serversock,(struct sockaddr*)&serveraddr,sizeof(serveraddr));
sizeof(serveraddr);
listen(serversock,5);
while(1)
{
clientsize=sizeof(clientaddr);
newserversock=accept(serversock,(struct
sockaddr*)&clientaddr,&clientsize);
n=read(newserversock,filename,100);
filename[n]=0;
printf("\nThe requested file from the client is %s.\n",filename);
//write(1,filename,n);
f=open(filename,O_RDWR);
n=read(f,filedata,300);
printf("\nThe contents of the file: \n\n");
printf("%s",filedata);
write(newserversock,filedata,n);
}
close(serversock);
close(newserversock);
}
/*
gedit Ftpserver.c
gcc Ftpserver.c
./a.out 5678
The requested file from the client is text.txt.
The contents of the file:
Hi!
The file transfer was successful.
*/
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#define NOF_PACKETS 10
int main()
{
int rand(int a)
{
int rn = (random() % 10) % a;
return rn == 0 ? 1 : rn;
}
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)
packet_sz[i] = rand(6) * 10;
for(i = 0; i<NOF_PACKETS; ++i)
printf("\npacket[%d]:%d bytes\t", i, packet_sz[i]);
printf("\nEnter the Output rate:");
scanf("%d", &o_rate);
printf("Enter the Bucket Size:");
scanf("%d", &b_size);
for(i = 0; i<NOF_PACKETS; ++i)
{
if( (packet_sz[i] + p_sz_rm) > b_size)
if(packet_sz[i] > b_size)
printf("\n\nIncoming packet size (%dbytes) is Greater than bucket capacity (%dbytes)-
PACKET REJECTED", packet_sz[i], b_size);
else
printf("\n\nBucket capacity exceeded-PACKETS REJECTED!!");
else
{
p_sz_rm += packet_sz[i];
printf("\n\nIncoming Packet size: %d", packet_sz[i]);
printf("\nBytes remaining to Transmit: %d", p_sz_rm);
p_time = rand(4) * 10;
printf("\nTime left for transmission: %d units", p_time);
for(clk = 10; clk <= p_time; clk += 10)
{
sleep(1);
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", p_sz_rm);
}
else
{
printf("\nTime left for transmission: %d units", p_time-clk);
printf("\nNo packets to transmit!!");
}
}
}
}
}
/*
gedit Leaky.c
gcc Leaky.c
./a.out
packet[0]:30 bytes
packet[1]:10 bytes
packet[2]:10 bytes
packet[3]:50 bytes
packet[4]:30 bytes
packet[5]:50 bytes
packet[6]:10 bytes
packet[7]:20 bytes
packet[8]:30 bytes
packet[9]:10 bytes
Enter the Output rate:60
Enter the Bucket Size:100
Incoming Packet size: 30
Bytes remaining to Transmit: 30
Time left for transmission: 20 units
Packet of size 30 Transmitted----Bytes Remaining to Transmit: 0
Time left for transmission: 0 units
No packets to transmit!!
Incoming Packet size: 10
Bytes remaining to Transmit: 10
Time left for transmission: 30 units
Packet of size 10 Transmitted----Bytes Remaining to Transmit: 0
Time left for transmission: 10 units
No packets to transmit!!
Time left for transmission: 0 units
No packets to transmit!!
*/
#include<stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include<fcntl.h>
#include <pthread.h>
#include<unistd.h>
#include<stdlib.h>
int sockfd,newsockfd,m,n,s=0,g=0,clilen;
void*senddata()
{
char ch='d';
while(1)
{
write(sockfd,&ch,1);
write(sockfd,&s,1);
printf("Send data %d\n",s);
sleep(1);
s++;
}
}
void*receiveedata()
{
char ca;
while(1)
{
n=read(sockfd,&ca,1);
m=read(sockfd,&g,1);
if(ca=='a')
{
printf("ACK %d received \n",g);
sleep(1);
}
else if(ca=='n')
{
g--;
printf("sending again\n");
s=g;
}
}
}
void main(int argc,char*argv[])
{
pthread_t s,r;
int fd,clilen,len,n,m;
char buf[1024];
struct sockaddr_in cli_addr;
cli_addr.sin_family=AF_INET;
cli_addr.sin_addr.s_addr=inet_addr(argv[1]);
cli_addr.sin_port=htons(atoi(argv[2]));
sockfd=socket(AF_INET,SOCK_STREAM,0);
connect(sockfd,(struct sockaddr*)&cli_addr,sizeof(cli_addr));
printf("connecting to server......................\n");
pthread_create(&s,0,senddata,0);
pthread_create(&r,0,receiveedata,0);
while(1);
}
/*
gedit Nclient.c
gcc -pthread Nclient.c
./a.out 127.0.0.1 3456
connecting to server......................
Send data 0
ACK 0 received
Send data 1
Send data 2
ACK 1 received
Send data 3
Send data 4
sending again
Send data 2
Send data 3
Send data 4
Send data 5
Send data 6
ACK 2 received
Send data 7
Send data 8
Send data 9
ACK 3 received
Send data 10
*/
#include<stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include<fcntl.h>
#include <pthread.h>
#include<unistd.h>
#include<stdlib.h>
void main(int argc, char *argv[])
{
int sockfd,newsockfd,clilen,g=0,n,m,k,p=0,f=-1;
char buf[10];
char ca='a',can='n',ch;
struct sockaddr_in serv_addr,cli_addr;
serv_addr.sin_family= AF_INET;
serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
serv_addr.sin_port=htons(atoi(argv[1]));
sockfd=socket(AF_INET,SOCK_STREAM,0);
bind(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr));
printf(" server is waiting.... ..\n");
listen(sockfd,5);
clilen=sizeof(cli_addr);
newsockfd=accept(sockfd, (struct sockaddr *)&cli_addr,&clilen);
while(1)
{
n=read(newsockfd,&ch,1);
m=read(newsockfd,&g,1);
if(ch='d')
{
k=rand();
if(k%3==0)
{
printf("Data %d Corrupted\n",g);
write(newsockfd,&can, 1);
write(newsockfd,&g, 1);
sleep(2);
}
else
{
p=f+1;
if(g==p)
{
printf("Data%d received\n",g);
write(newsockfd,&ca,1);
write(newsockfd,&g,1);
printf("Data %d Acknowledged \n",g);
f=g;
}
else
printf("Discarded data %d\n",g);
sleep(2);
}
}
}
}
/*
gedit Nserver.c
gcc Nserver.c
./a.out 3456
server is waiting.... ..
Data0 received
Data 0 Acknowledged
Data1 received
Data 1 Acknowledged
Data 2 Corrupted
Discarded data 3
Discarded data 4
Data2 received
Data 2 Acknowledged
Data3 received
Data 3 Acknowledged
Data 4 Corrupted
Data 5 Corrupted
Discarded data 6
Discarded data 7
Discarded data 8
Discarded data 9
*/
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#define RTT 4
#define TIMEOUT 4
#define TOT_FRAMES 7
enum {NO,YES} ACK;
int main()
{
int wait_time,i=1;
ACK=YES;
for(;i<=TOT_FRAMES;)
{
if (ACK==YES && i!=1)
{
printf("\nSENDER: ACK for Frame %d Received.\n",i-1);
}
printf("\nSENDER: Frame %d sent, Waiting for ACK...\n",i);
ACK=NO;
wait_time= rand() % 4+1;
if (wait_time==TIMEOUT)
{
printf("SENDER: ACK not received for Frame %d=>TIMEOUT Resending Frame...",i);
}
else
{
sleep(RTT);
printf("\nRECEIVER: Frame %d received, ACK sent\n",i);
printf("--------------------------------------------");
ACK=YES;
i++;
}
}
return 0;
}
/*
gedit stop.c
gcc stop.c
./a.out
SENDER: Frame 1 sent, Waiting for ACK...
SENDER: ACK not received for Frame 1=>TIMEOUT Resending Frame...
SENDER: Frame 1 sent, Waiting for ACK...
RECEIVER: Frame 1 received, ACK sent
--------------------------------------------
SENDER: ACK for Frame 1 Received.
SENDER: Frame 2 sent, Waiting for ACK...
RECEIVER: Frame 2 received, ACK sent
--------------------------------------------
SENDER: ACK for Frame 2 Received.
SENDER: Frame 3 sent, Waiting for ACK...
SENDER: ACK not received for Frame 3=>TIMEOUT Resending Frame...
SENDER: Frame 3 sent, Waiting for ACK...
RECEIVER: Frame 3 received, ACK sent
--------------------------------------------
SENDER: ACK for Frame 3 Received.
*/
#include<stdio.h>
#include<string.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<unistd.h>
int main()
{
struct sockaddr_in client;
int s;
char buffer[20];
s=socket(AF_INET,SOCK_STREAM,0);
client.sin_family=AF_INET;
client.sin_port=2000;
client.sin_addr.s_addr=inet_addr("127.0.0.1");
connect(s,(struct sockaddr*)&client,sizeof client);
printf("\nEnter the string:");
scanf("%s",buffer);
send(s,buffer,sizeof(buffer),0);
close(s);
}
#include<stdio.h>
#include<string.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include <unistd.h>
void main()
{
struct sockaddr_in client,server;
int s,n,sock;
char b1[20];
s=socket(AF_INET,SOCK_STREAM,0);
server.sin_family=AF_INET;
server.sin_port=2000;
server.sin_addr.s_addr=inet_addr("127.0.0.1");
bind(s,(struct sockaddr*) &server, sizeof(server));
listen(s,1);
n=sizeof(client);
sock=accept(s,(struct sockaddr*)&client,&n);
recv(sock,b1,sizeof(b1),0);
printf("\nThe sring recieved is:%s\n",b1);
close(sock);
close(s);
}
Hi!
The file transfer was successful.
#include<stdio.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
int main()
{
struct sockaddr_in client;
int s, flag;
char buffer[20];
s = socket(AF_INET, SOCK_DGRAM, 0);
client.sin_family = AF_INET;
client.sin_port = 5000;
client.sin_addr.s_addr = inet_addr("127.0.0.1");
printf("\n Enter a string: ");
scanf("%s", buffer);
sendto(s, buffer, strlen(buffer), 0, (struct sockaddr *) &client, sizeof(client));
close(s);
}
#include<stdio.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
void main()
{
struct sockaddr_in client, server;
int s, n, sock, len;
char b1[20];
len = sizeof(client);
s = socket(AF_INET, SOCK_DGRAM, 0);
server.sin_family = AF_INET;
server.sin_port = 5000;
server.sin_addr.s_addr = inet_addr("127.0.0.1");
bind(s, (struct sockaddr *) &server, sizeof(server));
recvfrom(s, b1, sizeof(b1), 0, (struct sockaddr *) &client, &len);
printf("\n The string recieved is : %s\n", b1);
close(sock);
close(s);
}
