An 16

/**************************************************************************
Name : Singal Deepkumar Mansingbhai

Roll no: M.Tech NT 116
Subject: Practical-II(Advanced Networking)
**************************************************************************/
___________________________________________________________________________
// 1) Port Scanner
___________________________________________________________________________
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<error.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#define BUFFER 1024
main(int argc,char **argv)
{
struct sockaddr_in client_c;
int sock,erro,i;
memset(&client_c,0,sizeof(client_c));
for(i=0; i<4000; i++)
{
sock = socket(AF_INET,SOCK_STREAM,0);
client_c.sin_family=AF_INET;
client_c.sin_port=htons(i);
client_c.sin_addr.s_addr=inet_addr(argv[1]);
bzero(&client_c.sin_zero,8);
erro = connect(sock,(struct sockaddr *)&client_c,sizeof(struct s
ockaddr_in));
if(erro >= 0)
{
printf("\nThe Open Port Number is = %d",i);
}
}
close(sock);
}
********************** Output *****************************
[root@station154 ~]# gcc 1an_c.c
[root@station154 ~]#./a.out 127.0.0.1 4343
The
The
The
The
The
Open
Open
Open
Open
Open
Port
Port
Port
Port
Port
Number
Number
Number
Number
Number
is
is
is
is
is
=
=
=
=
=
22
25
111
631
694
*********************************************************************
___________________________________________________________________________
// 2) Echo server (TCP)
___________________________________________________________________________
// Client Code
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<error.h>
#define BUFFER 1024
{
int sock;
int data_len;
char data_in[BUFFER];
char data_out[BUFFER];
if((sock=socket(AF_INET,SOCK_STREAM,0))<0)
{
perror("\nsocket creation error");
}
client_c.sin_port=htons(atoi(argv[2]));
if((connect(sock,(struct sockaddr *)&client_c,sizeof(struct sockaddr_in)
))<0)
{
perror("\nconnection fail");
}
while(1)
{
fgets(data_in,BUFFER,stdin);
send(sock,data_in,strlen(data_in),0);
data_len=recv(sock,data_out,BUFFER,0);
data_out[data_len]='\0';
printf("\necho msg:%s",data_out);
if((strcmp(data_out,"over\n"))==0)
break;
}
printf("\n\nConnection terminated.....\n\n");
close(sock);
}
**********************Client -- Output *****************************

[root@station154 ~]# /a.out 127.0.0.1 3333
hi
echo msg:hi
*********************************************************************
// Server Code
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<error.h>
#define BUFFER
#define MAX_CLIENT
1024
2

{
struct sockaddr_in server;
struct sockaddr_in client;
int sock,new,data_len;
int len=sizeof(struct sockaddr_in);
char data[BUFFER];
{
perror("\nsocket connection fail");
}
memset(&server,0,sizeof(server));
memset(&client,0,sizeof(client));
server.sin_family=AF_INET;
server.sin_port=htons(atoi(argv[1]));
server.sin_addr.s_addr=INADDR_ANY;
bzero(&server.sin_zero,8);
if(bind(sock,(struct sockaddr *)&server,len)<0)
{
perror("\nbind fail");
}
if((listen(sock,MAX_CLIENT))<0)
{
perror("\nlisten fail");
}
while(1)
{
printf("\nWaiting for clients.....\n\n");
if((new=accept(sock,(struct sockaddr *)&client,&len))<0)
{
}
printf("\nnew client is connected with ip %s and port %d\n",inet_ntoa(cl
ient.sin_addr),ntohs(client.sin_port));
while(1)
{
data_len=recv(new,data,BUFFER,0);
data[data_len]='\0';
if(data_len)
{
printf("\nclient msg:%s",data);
send(new,data,data_len,0);
if((strcmp(data,"over\n"))==0)
}
}
close(new);
printf("\nconnection terminated........\n\n");
}
close(sock);
}
**********************Server -- Output *****************************
[root@station154 ~]# gcc 2an_s.c
[root@station154 ~]# ./a.out 3333
Waiting for clients.....
new client is connected with ip 127.0.0.1 and port 36502
client msg:hi
*********************************************************************
___________________________________________________________________________
// 3) Echo server (UDP)

___________________________________________________________________________
// Client Code
#include<stdio.h>
#include<stdlib.h>
#include<error.h>
#include<string.h>
#include<unistd.h>
#define BUFFER 1024
main(int argc, char **argv)
{
int sock,data_in;
char input[BUFFER];
char output[BUFFER];
int len = sizeof(struct sockaddr_in);
if((sock = socket(AF_INET,SOCK_DGRAM,0)) < 0)
{
perror("socket");
exit(-1);
}
server.sin_family = AF_INET;
server.sin_port = htons(atoi(argv[2]));
server.sin_addr.s_addr = inet_addr(argv[1]);
while(1)
{
fgets(input,BUFFER,stdin);
sendto(sock,input,strlen(input),0,(struct sockaddr *)&server,len
);
memset(&output[0],0,sizeof(output));
data_in = recvfrom(sock,output,BUFFER,0,(struct sockaddr *)&ser
ver, &len);
output[len] = '\0';
if(data_in)
{
printf("\necho msg: %s",output);
if((strcmp(output,"over\n"))==0)
break;
}
}
printf("\nconnection terminated...........\n\n");
close(sock);
}
**********************Client -- Output *****************************

[root@station154 ~]# ./a.out 127.0.0.1 3333
hello
echo msg:hello
*********************************************************************
// Server Code
#include<stdio.h>
#include<stdlib.h>
#include<error.h>
#include<string.h>
#include<unistd.h>
#define MAX_CLIENTS
#define MAX_DATA
2
1024

{
struct sockaddr_in server,client;
int sock,data_len;
char data[MAX_DATA];
if((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
{
perror("server socket: ");
exit(-1);
}
server.sin_addr.s_addr = INADDR_ANY;
bzero(&server.sin_zero, 8);
if((bind(sock, (struct sockaddr *)&server, len)) < 0)
{
perror("bind : ");
exit(-1);
}
while(1)
{
data_len = recvfrom(sock, data, MAX_DATA, 0,(struct socka
ddr *)&client,&len);
data[data_len] = '\0';
if(data_len)
{
printf("\nclient msg: %s\n",data);
sendto(sock,data,strlen(data),0,(struct sockaddr
*)&client,len);
break;
}
}
printf("\nClient disconnected...........\n\n");
close(sock);
}
**********************Server -- Output *****************************
client msg:hello
*********************************************************************
___________________________________________________________________________
// 4) Date & Time server (TCP)
___________________________________________________________________________
// Client Code
#include<stdio.h>
#include<stdlib.h>
#include<error.h>
#include<string.h>
#include<unistd.h>
#define BUFFER 1024
{
int sock;
char input[BUFFER];
int len;
if((sock = socket(AF_INET,SOCK_STREAM,0))== -1)
{
perror("socket");
exit(-1);
}
if((connect(sock, (struct sockaddr *)&server, sizeof(struct sockaddr_in)
)) == -1)
{
perror("connect");
exit(-1);
}
len = recv(sock,output,BUFFER,0);
output[len] = '\0';
printf("\n%s\n",output);
close(sock);
}
**********************Client -- Output *****************************
time
Tue 2011-05-24 17:30:34 IST
*********************************************************************
// Server Code
#include<stdio.h>
#include<stdlib.h>
#include<error.h>
#include<string.h>
#include<unistd.h>
#include<time.h>
#define MAX_CLIENTS
#define BUFFER 1024

{
int sock;
int new;
int sockaddr_len = sizeof(struct sockaddr_in);
int data_len;
char data[BUFFER];
time_t
now;
struct tm *ts;
char repl[BUFFER];
if((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
exit(-1);
}
if((bind(sock, (struct sockaddr *)&server, sockaddr_len)) == -1)
{
perror("bind : ");
exit(-1)
;
}
if((listen(sock, MAX_CLIENTS)) == -1)
{
perror("listen");
exit(-1);
}
if((new = accept(sock, (struct sockaddr *)&client, &sockaddr_len)) == -1

)
{
perror("accept");
exit(-1);
}
printf("New Client connected from port no %d and IP %s\n", ntohs(client.
sin_port), inet_ntoa(client.sin_addr));
/* Get the current time */
now = time(NULL);
/* Format and print the time, "ddd yyyy-mm-dd hh:mm:ss zzz" */
ts = localtime(&now);
strftime(repl, sizeof(repl), "%a %Y-%m-%d %H:%M:%S %Z", ts);
send(new, repl, strlen(repl), 0);
close(new);
close(sock);
}
**********************Server -- Output *****************************
New Client connected from port no 44100 and IP 127.0.0.1
*********************************************************************
___________________________________________________________________________
// 5) Date & Time server (UDP)
___________________________________________________________________________
// Client Code
#include<stdio.h>
#include<stdlib.h>
#include<error.h>
#include<string.h>
#include<unistd.h>
#define BUFFER 1024
{
int sock,data_in;
char input[BUFFER];
{
perror("socket");
exit(-1);
}
while(1)
{
);
ver, &len);
output[len] = '\0';
if(data_in)
{
printf("\necho msg: %s",output);
break;
}
}
close(sock);
}
**********************Client -- Output *****************************

[root@station154 ~]#./a.out 127.0.0.1 3333
time
echo msg: Tue 2011-05-24 1
*********************************************************************
// Server Code
#include<stdio.h>
#include<stdlib.h>
#include<error.h>
#include<string.h>
#include<unistd.h>
#include<time.h>
#define MAX_CLIENTS
#define MAX_DATA
#define BUFFER 85
2
1024

{

int sock,data_len;
time_t
now;
struct tm *ts;
char repl[BUFFER];
{
exit(-1);
}
{
perror("bind : ");
exit(-1);
}
while(1)
{
if(data_len)
{
/* Get the current time */
now = time(NULL);
/* Format and print the time, "ddd yyyy-mm-dd hh:mm:ss zzz" */
strftime(repl, sizeof(repl), "%a %Y-%m-%d %H
:%M:%S %Z", ts);
printf("\nclient msg: %s\n",data);
sendto(sock,repl,strlen(repl),0,(struct sockaddr
*)&client,len);
break;
}
close(sock);
}
**********************Server -- Output *****************************
[root@station154 ~]#./a.out 3333
client msg: time
*********************************************************************
___________________________________________________________________________
// 6) Random Number Generator (TCP)
___________________________________________________________________________
// Client Code
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<error.h>
#define BUFFER 1024
{
int sock;
int data_len;
{
}
client.sin_family=AF_INET;
client.sin_port=htons(atoi(argv[2]));
client.sin_addr.s_addr=inet_addr(argv[1]);
bzero(&client.sin_zero,8);
if((connect(sock,(struct sockaddr *)&client,sizeof(struct sockaddr_in)))
<0)
{
}
while(1)
{
printf("\n\n\nEnter \"over\" for termination");
printf("\nEnter \"random\" for getting Random number:");
if((strcmp(data_in,"over\n"))==0)
break;
memset(&data_out,0,sizeof(data_out));
if(data_len)
printf("\nServer:%s\n\n",data_out);
}
close(sock);
}
**********************Client -- Output *****************************

Enter "over" for termination
Enter "random" for getting Random number:random
Server:398771428
*********************************************************************
// Server Code
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<error.h>
#include<time.h>
#define BUFFER
#define MAX_CLIENT
1024
2

{
char data[BUFFER];
unsigned int iseed;
int i;
{
}
{
}
{
}
while(1)
{
{
}
while(1)
{
memset(&data,0,sizeof(data));
if(data_len)
{
break;
if((strcmp(data,"random\n"))==0)
{
iseed = (unsigned int)time(NULL);
srand (iseed);
i=rand();
printf ("\nrandom number=%u\n",i);
sprintf(data,"%d",i);
}
else
{
strcpy(data,"enter proper command");
}
send(new,data,strlen(data),0);
}
}
close(new);
}
close(sock);
}
**********************Server -- Output *****************************
client msg:random
random number=398771428
*********************************************************************
___________________________________________________________________________
// 7) Random Number Generator (UDP)
___________________________________________________________________________
// Client Code
#include<stdio.h>
#include<stdlib.h>
#include<error.h>
#include<string.h>
#include<unistd.h>
#define ERROR -1
#define MAX_DATA
#define BUFFER 1024
1024
{
int sock;
char input[BUFFER];
int n;
if((sock = socket(AF_INET,SOCK_DGRAM,0))==ERROR)
{
perror("socket");
exit(-1);
}
client.sin_family = AF_INET;
client.sin_port = htons(atoi(argv[2]));
client.sin_addr.s_addr = inet_addr(argv[1]);
n=1;
while(1)
{
sendto(sock,input,strlen(input),0,(struct sockaddr *)&client,len
);
n = recvfrom(sock,output,BUFFER,0,(struct sockaddr *)&server, &l
en);
printf("\nRandom Number is = %s\n",output);
output[n]='\0';
}
close(sock);
}
**********************Client -- Output *****************************
random
Random Number is = 1214252602
*********************************************************************
// Server Code
#include<stdio.h>
#include<stdlib.h>
#include<error.h>
#include<string.h>
#include<unistd.h>
#include<time.h>
#define MAX_CLIENTS
#define MAX_DATA
2
1024
#define BUFFER 85
{
int sock,data_len,i=0;
time_t
now;
struct tm *ts;
char repl[BUFFER];
unsigned int iseed;
{
exit(-1);
}
{
perror("bind : ");
exit(-1);
}
while(1)
{
if(data_len)
{
srand(iseed);
i = rand();
printf("\n Random Number = %u\n", i);
sprintf(data,"%d",i);
sendto(sock,data,strlen(data),0,(struct sockaddr
*)&client,len);
}
}
close(sock);
}
**********************Server -- Output *****************************
Random Number = 1214252602
*********************************************************************
___________________________________________________________________________
// 8) Basic Calculator (TCP)
___________________________________________________________________________
// Client Code
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<error.h>
#define BUFFER 1024
{
int sock;
int data_len;
char equ[BUFFER];
char result[BUFFER];
{
}
<0)
{
}
while(1)
{

printf("\nEnter the Equation:");
fgets(equ,BUFFER,stdin);
send(sock,equ,strlen(equ),0);
if((strcmp(equ,"over\n"))==0)
break;
memset(&result,0,sizeof(result));
data_len=recv(sock,result,BUFFER,0);
result[data_len]='\0';
if(data_len)
printf("\nthe result is:%s\n\n",result);
}
close(sock);
}
**********************Client -- Output *****************************
Enter the Equation:12 - 5
the result is:7.00000
*********************************************************************
// Server Code
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<error.h>
#define BUFFER
#define MAX_CLIENT
1024
2

{
char data[BUFFER];
char ex,no1[BUFFER],no2[BUFFER];
int i,count,i1,i3,cntr;
float val1,val2,answer;
{
}
{
}
{
}
while(1)
{
{
}
while(1)
{
memset(&no1,0,sizeof(no1));
memset(&no2,0,sizeof(no2));
i1=0;
i3=0;
count=0;
cntr=0;
if(data_len)
{
break;
for(i=0;i<strlen(data);i++)
{
if(data[i] == ' ')
{
count++;
}
else
{
if(count==0)
{
no1[i1]=data[i];
i1++;
}
else if(count==1)
{
ex=data[i];
}
else
{
no2[i3]=data[i];
i3++;
}
}
}
val1 = atoi(no1);
val2 = atoi(no2);
switch(ex)
{
case '+':
{
answer = val1 + val2;
break;
}
case '-':
{
answer = val1 - val2;
break;
}
case '*':
{
answer = val1 * val2;
break;
}
case '/':
{
answer = val1 / val2;
break;
}
default:
{
strcpy(data,"syntex error.....");
cntr++;
}
}
if (cntr == 0)
sprintf(data,"%f",answer);
send(new,data,data_len,0);
}
}
close(new);
}
close(sock);
}
**********************Server -- Output *****************************
client msg:12 - 5
*********************************************************************
___________________________________________________________________________
// 9) Basic Calculator (UDP)
___________________________________________________________________________
// Client Code
#include<stdio.h>
#include<stdlib.h>
#include<error.h>
#include<string.h>
#include<unistd.h>
#define BUFFER 1024
{
int sock,data_in,i=0;
int temp=0;
char input[BUFFER];
char ciper[BUFFER];
{
perror("socket");
exit(-1);
}
while(1)
{
printf("\nEnter Expression = ");

);
ver, &len);
output[len] = '\0';
if(data_in)
{
printf("\nCalculated Result = %s",output);
/*
for(i=0; i<strlen(output); i++)
{
printf("%c", output[i]);
}*/
break;
}
}
close(sock);
}
**********************Client -- Output *****************************

Enter Expression = 22 / 2
Calculated Result = 11
Enter Expression =
*********************************************************************
// Server Code
#include<stdio.h>
#include<stdlib.h>
#include<error.h>
#include<string.h>
#include<unistd.h>
#include<time.h>
#define MAX_CLIENTS
#define MAX_DATA
#define BUFFER 85
2
1024

{
int sock,data_len;
char data[BUFFER];
char delims[] = " ";
time_t
now;
struct tm *ts;
char repl[BUFFER];
int i=0,op=0;
char *token = NULL;
int final=0,*result;
{
exit(-1);
}
// memset(&result,0,sizeof(result));
{
perror("bind : ");
exit(-1);
}
while(1)
{
data_len = recvfrom(sock,data, MAX_DATA, 0,(struct sockaddr
*)&client,&len);
printf("Client Expression = %s\n",data);
token = strtok(data,delims);
while(token != NULL)
{
strcpy(repl,token);
printf("The token is = %s\n", token);
if(strcmp(repl,"+")==0)
{
op=1;
i--;
}
else if(strcmp(repl,"-")==0)
{
op=2;
i--;
}
else if(strcmp(repl,"*")==0)
{
op=3;
i--;
}
else if(strcmp(repl,"/")==0)
{
op=4;
i--;
}
else
{
result[i] = atoi(repl);
}
token = strtok(NULL,delims);
i++;
}
if(op == 1)
final
if(op == 2)
final
if(op == 3)
final
if(op == 4)
final
= result[0]+result[1];
= result[0]-result[1];
= result[0]*result[1];
= result[0]/result[1];
i = 0;
if(data_len)
{
//printf("\nCipertext = %s\n",data);
printf("Expression Result = %d\n",final);
sprintf(data,"%d",final);
sendto(sock,data,strlen(data),0,(struct sockadd
r *)&client,len);
break;
}
}
close(sock);
}
**********************Server -- Output *****************************
Client Expression = 22 / 2
The token is = 22
The token is = /
The token is = 2
Expression Result = 11
*********************************************************************
___________________________________________________________________________
// 10) Quote server (TCP)
___________________________________________________________________________
// Client Code
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<error.h>
#define BUFFER 1024
{
int sock;
int data_len,counter=1;
{
}
<0)
{
}
while(1)
{
printf("\nEnter \"qotd\" for getting Quote Of The Day:");
if((strcmp(data_in,"over\n"))==0)
break;
if(data_len)
printf("\nServer: %s\n\n",data_out);
}
close(sock);
}
**********************Client -- Output *****************************

Enter "qotd" for getting Quote Of The Day:qotd
Server: G
*********************************************************************
// Server Code
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<error.h>
#include<time.h>
#define BUFFER
#define MAX_CLIENT
1024
2

{
char data[BUFFER];
unsigned int iseed;
int i,ans;
char quote[10][200]={"A","B","C","D","E","F","G","H","I","K"};
{
}
{
}
{
}
while(1)
{
{
}
while(1)
{
if(data_len)
{
break;
if((strcmp(data,"qotd\n"))==0)
{
srand (iseed);
i=rand();
ans=i%10;
printf ("\nrandom number=%u\n",ans);
strcpy(data,quote[ans]);
}
else
{
strcpy(data,"enter proper command");
}
send(new,data,strlen(data),0);
}
}
close(new);
}
close(sock);
}
**********************Server -- Output *****************************
[root@station154 ~]#gcc 10an_s.c
[root@station154 ~]#./a.out 3333
client msg:1
client msg:qotd
random number=6
*********************************************************************
___________________________________________________________________________
// 11) Quote server (UDP)
___________________________________________________________________________
// Client Code
#include<stdio.h>
#include<stdlib.h>
#include<error.h>
#include<string.h>
#include<unistd.h>
#define ERROR -1
#define MAX_DATA
#define BUFFER 1024
1024

{
int sock;
char input[BUFFER];
int n;
{
perror("socket");
exit(-1);
}
//memset(&input,0,sizeof(input));
//memset(&output,0,sizeof(output));
n=1;
while(1)
{
memset(&output,0,sizeof(output));
printf("\nEnter the Number = ");
sendto(sock,input,strlen(input),0,(struct sockaddr *)&client,len
);
n = recvfrom(sock,output,BUFFER,0,(struct sockaddr *)&server, &l
en);
printf("\n Thought is = %s\n",output);
output[n]='\0';
}
close(sock);
}
**********************Client -- Output *****************************
Enter the Number = 3
Thought is = GIH
Enter the Number =

*********************************************************************
// Server Code
#include<stdio.h>
#include<stdlib.h>
#include<error.h>
#include<string.h>
#include<unistd.h>
#include<time.h>
#define MAX_CLIENTS
#define MAX_DATA
#define BUFFER 85
2
1024

{
int sock,data_len,i=0;
char repl[100][100]={"ABC","DEF","GIH","JKL","MNO","PQR","STU","VWX","XY
Z","HELLO"};
{
exit(-1);
}
{
perror("bind : ");
exit(-1);
}
while(1)
{
printf("Client Request for Thought Number = %s\n",data);
if(atoi(data) > 0 && atoi(data) < 11)
{
for(i=1; i<=10; i++)

{
if(i == (atoi(data)))
{
i--;
printf("The thought is = %s\n",r
epl[i]);
break;
}
}
if(data_len)
{
sendto(sock,repl[i],strlen(repl[i]),0,(s
truct sockaddr *)&client,len);
}
}
else
{
printf("Invalid Request\n");
sendto(sock,"Invalid Request",15,0,(struct socka
ddr *)&client,len);
}
}
close(sock);
}
**********************Server -- Output *****************************
Client Request for Thought Number = 3
The thought is = GIH
*********************************************************************
___________________________________________________________________________
// 12) Identification of Network Address from IP address and Subnet mask (TCP)
___________________________________________________________________________
// Client Code
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<error.h>
#define BUFFER 1024

{
int sock,i=0;
char ip[BUFFER];
char mask[BUFFER];
int data_out[BUFFER];
{
}
))<0)
{
}
while(1)
{
memset(&ip,0,sizeof(ip));
memset(&mask,0,sizeof(mask));
memset(&data_in,0,sizeof(data_in));
printf("\nEnter the IP address = ");

fgets(ip,BUFFER,stdin);
send(sock,ip,strlen(ip),0);
printf("\nEnter the MASK address = ");
fgets(mask,BUFFER,stdin);
send(sock,mask,strlen(mask),0);
if((strcmp(data_in,"exit\n"))==0)
{
printf("\nclient is disconnected\n\n");
break;
}
printf("The network address = ");
for(i=0;i<7;i++)
{
if(data_out[i] == 256)
{
printf("%c",46);
}
else
{
printf("%d",data_out[i]);
}
}
}
close(sock);
}
**********************Client -- Output *****************************
Enter the IP address = 192.168.12.3
Enter the MASK address = 255.255.255.0
The network address = 192.168.12.0
Enter the IP address = 134.123.34.8
Enter the MASK address = 255.255.0.0
The network address = 134.123.0.0
Enter the IP address =
*********************************************************************
// Server Code
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<error.h>
#define BUFFER
#define MAX_CLIENT
#define MAX_DATA
1024
2
1024

{
int sock;
int new;
int i,count=0,j=0,k=0;
int data_len;
char *token, *repl;
char data[BUFFER];
char ip[BUFFER];
char mask[BUFFER];
int ip_token[10];
int mask_token[10];
int net[7];
{
}
{
}
{
}
while(1)
{
{
}
while(1)
{
memset(&ip_token,0,sizeof(ip_token));
memset(&mask_token,0,sizeof(mask_token));
memset(&net,0,sizeof(net));
memset(&ip,0,sizeof(ip));
memset(&mask,0,sizeof(mask));
while(data_len)
{
data_len = recv(new,ip,MAX_DATA, 0);
printf("Client IP address = %s\n",ip);
token = strtok(ip,".");
i=0;
{
strcpy(repl,token);
printf("The token for ip is = %s\n", token);
ip_token[i] = atoi(repl);
token = strtok(NULL,".");
i++;
}
ip[data_len] = '\0';
data_len = recv(new,mask,MAX_DATA, 0);

printf("Client MASK address = %s\n",mask);
token = strtok(mask,".");
i=0;
{
strcpy(repl,token);
mask_token[i] = atoi(repl);
token = strtok(NULL,".");
i++;
}
if(data_len)
{
k=0;
for(j=0; j<i; j++)
{
if(mask_token[j] == 255)
{
continue;
}
else
{
ip_token[j] = 0;
}
}
for(i=0;i<4;i++)
{
net[k] = ip_token[i];
k++;
if(i != 3)
{
net[k] = 256;
k++;
}
}
send(new,net,sizeof(net),0);
break;
}
}
}
close(new);
}
close(sock);
}
**********************Server -- Output *****************************
Client IP address = 192.168.12.3
The token for ip is = 192

Client MASK address = 255.255.255.0
Client IP address = 134.123.34.8
The
The
The
The
token
token
token
token
for
for
for
for
ip
ip
ip
ip
is
is
is
is
=
=
=
=
134
123
34
8
Client MASK address = 255.255.0.0

*********************************************************************
___________________________________________________________________________
// 13) Concurrent Echo Server (TCP)
___________________________________________________________________________
// Client_1 Code
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<errno.h>
#define BUFFER 1024
struct packet
{
char data_in[25];
}client_s;
{
int sock;
int data_len;
if((sock=socket(AF_INET,SOCK_STREAM,0)) == -1)
{
exit(-1);
server.sin_addr.s_addr=inet_addr(argv[1]);
if((connect(sock,(struct sockaddr *)&server,sizeof(struct sockaddr_in)))

== -1)
{
exit(-1);
}
while(1)
{
printf("Enter your Packet:");

scanf("%s",client_s.data_in);
send(sock,(struct sockaddr *)&client_s,sizeof(client_s),0);
memset(&client_s,0,sizeof(client_s));
data_len=recv(sock,(struct sockaddr *)&client_s,BUFFER,0);
if(data_len)
{
if (strcmp(client_s.data_in,"over")== 0)
{
printf("\nterminated....\n\n");
close (sock);
break;
}
printf("\n\nEcho msg :%s\n\n",client_s.data_in);

}
}
}
**********************Client_1 -- Output *****************************
[root@station154 ~]# gcc 13an_c_1.c
Enter your Packethi
Echo msg :hi
Enter your Packet
*********************************************************************
// Client_1 Code
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<errno.h>
#define BUFFER 1024
struct packet
{
char data_in[25];
}client_s;
{

int sock;
int data_len;
{
exit(-1);
}

== -1)
{
exit(-1);
}
while(1)
{
printf("Enter your Packet:");

scanf("%s",client_s.data_in);
if(data_len)
{
if (strcmp(client_s.data_in,"over")== 0)
{
printf("\nterminated....\n\n");
close (sock);
break;
}
printf("\n\nEcho msg :%s\n\n",client_s.data_in);

}
}
}
**********************Client_2 -- Output *****************************
[root@station154 ~]# gcc 13an_c_2.c
Enter your Packet:hello
Echo msg :hello
Enter your Packet
*********************************************************************
// Server Code
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
#include<errno.h>
#include<pthread.h>
#define BUFFER
1024
#define MAX_CLIENT 5
struct packet
{
char data[25];
}server_s;
void echo(int);
{
int sock,new;
int fd;
pthread_t thread;
int iret;
{
exit(-1);
}
if(bind(sock,(struct sockaddr *)&server,len) == -1)

{
exit(-1);
}
if((listen(sock,MAX_CLIENT)) == -1)
{
exit(-1);
}
while(1)
{
if((new=accept(sock,(struct sockaddr *)&client,&len)) == -1)
{
perror("\naccept fail");
exit(-1);
}
iret = pthread_create(&thread, NULL, echo, new);
printf("The new client connected on %s this ip and port no is: %d\n",ine

t_ntoa(client.sin_addr),ntohs(client.sin_port));
memset(&stdin,0,sizeof(stdin));
//
close(new);
}
close(sock);
}
void echo(int sd)
{
int data_len,ret,i,j=0;
while(1)
{
memset(&server_s,0,sizeof(server_s));
data_len=recv(sd,(struct sockaddr *)&server_s,BUFFER,0);
if (data_len)
{
if(strcmp(server_s.data,"over")== 0)
{
strcpy(server_s.data,"over");
printf("\nclient terminated....\n");
send(sd,(struct sockaddr *)&server_s,sizeof(server_s),0)
;
break;
}
else
{
send(sd,(struct sockaddr *)&server_s,sizeof(serv
er_s),0);
}
}
ret = pthread_detach(pthread_self());
close(sd);
}
**********************Server -- Output *****************************
[root@station154 ~]# gcc -lpthread 13an_s.c
13an_s.c: In function main :
13an_s.c:150: warning: passing argument 3 of pthread_create
ter type
13an_s.c:150: warning: passing argument 4 of pthread_create
eger without a cast
from incompatible poin

makes pointer from int

The new client connected on 127.0.0.1 this ip and port no is: 40566
*********************************************************************
___________________________________________________________________________
// 14) DHCP (UDP)
___________________________________________________________________________
// Client Code
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<errno.h>
#define BUFFER 1024
struct packet
{
char ip[25];
char mac[25];
}client_s;
{
int sock;
int data_len;
{
exit(0);
}
<0)
{
exit(0);
}
printf("\nEnter the Mac : ");
scanf("%s",client_s.mac);
if(data_len)
{
printf("\n\nclient ip :%s\n\n",client_s.ip);
}
close(sock);
}
**********************Client -- Output *****************************
Enter your Mac : abc
client ip :192.168.1.1
*********************************************************************
// Server Code
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
#include<errno.h>
#define BUFFER
#define MAX_CLIENT
1024
2
struct packet
{
char ip[25];
char mac[25];
}server_s;
{
int sock,new,data_len,i,j=0;
char mac_table[5][25]={"abc","def","gih","jkl","mno"};
char ip_table[5][25]={"192.168.1.1",
"192.168.1.2",
"192.168.1.3",
"192.168.1.4",
"192.168.1.5"};
{
exit(0);
}
{
exit(0);
}
{
exit(0);
}
while(1)
{

{
exit(0);
}
memset(&server_s,0,sizeof(server_s));
data_len=recv(new,(struct sockaddr *)&server_s,BUFFER,0);
for(i=0;i<5;i++)
{
if(strcmp(server_s.mac,mac_table[i])==0)
{
strcpy(server_s.ip,ip_table[i]);
j=i;
}
}
send(new,(struct sockaddr *)&server_s,sizeof(server_s),0);
printf("%s ip is assign to %s client",ip_table[j],mac_table[j]);
close(new);
}
close(sock);
}
**********************Server -- Output *****************************
192.168.1.1 ip is assign to abc client
*********************************************************************
___________________________________________________________________________
// 15) DNS (UDP)
___________________________________________________________________________
// Client Code
#include<stdio.h>
#include<stdlib.h>
#include<error.h>
#include<string.h>
#include<unistd.h>
#define ERROR -1
#define MAX_DATA
#define BUFFER 1024
1024
struct packet
{
char input[BUFFER];
char op[BUFFER];
}p1,p2;
{
int sock;
// char input[BUFFER];
//char output[BUFFER];
int n;
{
perror("socket");
exit(-1);
}
//memset(&input,0,sizeof(input));
//memset(&output,0,sizeof(output));
n=1;
while(1)
{
memset(&p1.output,0,sizeof(p1.output));
printf("\nEnter the 1 for DNS lookup and 2 for reverse DNS looku
p = ");
fgets(p1.op,BUFFER,stdin);
sendto(sock,p1.op,strlen(p1.op),0,(struct sockaddr *)&client, le
n);
if(strcmp(p1.op,"1\n")==0)
{
printf("\nEnter the Host name = ");
fgets(p2.input,BUFFER,stdin);
}
if(strcmp(p1.op,"2\n")==0)
{
printf("\Enter the Ip address = ");
fgets(p2.input,BUFFER,stdin);
}
sendto(sock,p2.input,strlen(p2.input),0,(struct sockaddr *)&clie
nt,len);
n = recvfrom(sock,p2.output,BUFFER,0,(struct sockaddr *)&server,
&len);
printf("\n Answer from the server is = %s\n",p2.output);
p2.output[n]='\0';
if(strcmp(p2.output,"quit\n")==0)
break;
}
close(sock);
printf("\n Client terminated................");
}
**********************Client -- Output *****************************
Enter the 1 for DNS lookup and 2 for reverse DNS lookup = 1
Enter the Host name = guj.edu
Answer from the server is = 121.0.0.2
Enter the 1 for DNS lookup and 2 for reverse DNS lookup = 2
ter the Ip address = 121.0.0.2
Answer from the server is = guj.edu
Enter the 1 for DNS lookup and 2 for reverse DNS lookup =
*********************************************************************
// Server Code
#include<stdio.h>
#include<stdlib.h>
#include<error.h>
#include<string.h>
#include<unistd.h>
#include<time.h>
#define MAX_CLIENTS
#define MAX_DATA
#define BUFFER 85
2
1024
struct packet
{
char data[BUFFER];
char op[BUFFER];
}s1,s2;
{
int sock,data_len,i=0,op_len,index=5;
//char data[MAX_DATA];
char host[3][100]={"rollwala.org","guj.edu","telnet.rcc"};
char ip[3][100]={"121.0.0.1","121.0.0.2","121.0.0.3"};
{
exit(-1);
}
{
perror("bind : ");
exit(-1);
}
while(1)
{
op_len = recvfrom(sock,s1.op,MAX_DATA,0,(struct sockaddr
*)&client,&len);
data_len = recvfrom(sock, s2.data, MAX_DATA, 0,(struct so
ckaddr *)&client,&len);
s2.data[data_len] = '\0';
printf("Client Operation Request = %s\n",s1.op);
printf("Client Data = %s\n",s2.data);
// Host to Ip logic //
index = 5;
if(strcmp(s1.op,"1\n")==0)
{
if(strcmp(s2.data,"rollwala.org\n")==0)
{
index = 0;
}
if(strcmp(s2.data,"guj.edu\n")==0)
{
index = 1;
}
if(strcmp(s2.data,"telnet.rcc\n")==0)
{
index = 2;
}
if(index == 5)
{
sendto(sock,"INVALID REQUEST",15,0,(stru
ct sockaddr *)&client,len);
}
if(index != 5)
{
sendto(sock,ip[index],strlen(ip[index]),
0,(struct sockaddr *)&client,len);
}
}
///// Ip to Host logic /////////////
{
if(strcmp(s2.data,"121.0.0.1\n")==0)
{
index = 0;
}
if(strcmp(s2.data,"121.0.0.2\n")==0)
{
index = 1;
}
if(strcmp(s2.data,"121.0.0.3\n")==0)
{
index = 2;
}
if(index == 5)
{
sendto(sock,"INVALID REQUEST",15,0,(stru
ct sockaddr *)&client,len);
}
if(index != 5)
{
sendto(sock,host[index],strlen(host[inde
x]),0,(struct sockaddr *)&client,len);
}
}
if(strcmp(s2.data,"quit\n")==0)
break;
}
close(sock);
}
**********************Server -- Output *****************************
Client Operation Request = 1
Client Data = guj.edu
Client Operation Request = 2
Client Data = 121.0.0.2
*********************************************************************
___________________________________________________________________________
// 16) TELNET (TCP)
___________________________________________________________________________
// Client Code
#include<stdio.h>
#include<stdlib.h>
#include<error.h>
#include<string.h>
#include<unistd.h>
#include<time.h>
#define ERROR -1
#define MAX_DATA
1024
#define BUFFER 1024
struct packet
{
char uname[BUFFER];
char pwd[BUFFER];
char cmd[BUFFER];
//char data[BUFFER];
}c1,c2,c3;
{
struct sockaddr_in remote_server;
int sock;
int len,i=0;
char data[BUFFER];
if((sock = socket(AF_INET,SOCK_STREAM,0))==ERROR)
{
perror("socket");
exit(-1);
}
//memset(&remote_server,0,sizeof(remote_server));
remote_server.sin_family = AF_INET;
remote_server.sin_port = htons(atoi(argv[2]));
remote_server.sin_addr.s_addr = inet_addr(argv[1]);
bzero(&remote_server.sin_zero,8);
if((connect(sock, (struct sockaddr *)&remote_server, sizeof(struct socka
ddr_in))) == ERROR)
{
perror("connect");
exit(-1);
}
while(1)
{
printf("Enter the Username = ");
fgets(c1.uname,BUFFER,stdin);
send(sock,c1.uname,sizeof(c1.uname),0);
printf("Enter the Password = ");
fgets(c2.pwd,BUFFER,stdin);
send(sock,c2.pwd,sizeof(c2.pwd),0);
len = recv(sock,data,BUFFER,0);
data[len] = '\0';
printf("Server Replay=%s\n",data);
while(len)
{
if(strcmp(data,"SUCCESS")==0)
{
printf("\nAuthentication = %s",data);
while(1)
{
memset(&c3.cmd,0,sizeof(c3.cmd));
printf("\nEnter your Command = ");
fgets(c3.cmd,BUFFER,stdin);
send(sock,c3.cmd,sizeof(c3.cmd),0);
if(strcmp(c3.cmd,"logout\n")==0)
{
printf("\nLogout Successfully");
exit(-1);
}
len = 1;
while(len)
{
len = recv(sock,data,BUFFER,0);
if(strcmp(data,"COMPLETE")==0)
break;
printf("\nReply = %s",data);
}
if(strcmp(data,"IMPROPER")==0)
{
printf("\nCommand not in a LIST"
);
}
}
}
if(strcmp(data,"FAIL")==0)
{
printf("\nAuthentication = %s",data);
break;
}
}
//len = recv(sock,output,BUFFER,0);
//output[len] = '\0';
//printf("Server Replay=%s\n",output);
}
close(sock);
}
**********************Client -- Output *****************************
[root@station154 ~]# gcc telnet_c.c
connect: Connection refused
[root@station154 ~]# gcc telnet_c.c
Enter the Username = Deep
Enter the Password = 123
Server Replay=SUCCESS
Authentication = SUCCESS
Enter your Command = date
Reply = Tue 2011-05-24 17:41:12 IST
Enter your Command = logout
Logout Successfully[root@station154 ~]#
*********************************************************************
// Server Code
#include<stdio.h>
#include<stdlib.h>
#include<error.h>
#include<string.h>
#include<unistd.h>
#include<dirent.h>
#include<time.h>
#define ERROR -1
#define MAX_CLIENTS
2
#define MAX_DATA
1024
#define BUFFER 1024
struct packet
{
char uname[BUFFER];
char pwd[BUFFER];
//char data[BUFFER];
char cmd[BUFFER];
}s1,s2,s3;

{
int sock,new,i=0;
char data[BUFFER];
int un_index = 5, pass_index = 10;
int sockaddr_len = sizeof(struct sockaddr_in);
int data_un,data_pass,data_len;
char un[3][100] = {"Deep\n","ketan\n","rajan\n"};
char pass[3][100] = {"123\n","456\n","789\n"};
char count[BUFFER];
DIR *d;
struct dirent *dir;
time_t
now;
struct tm *ts;
if((sock = socket(AF_INET, SOCK_STREAM, 0)) == ERROR)
{
exit(-1);
}
if((bind(sock, (struct sockaddr *)&server, sockaddr_len)) == ERROR)

{
perror("bind : ");
exit(-1);
}
if((listen(sock, MAX_CLIENTS)) == ERROR)
{
perror("listen");
exit(-1);
}
while(1) // Better signal handling required
{
if((new = accept(sock, (struct sockaddr *)&client, &sockaddr_len
)) == ERROR)
{
perror("accept");
exit(-1);
}
printf("News Client connected from port no %d and IP %s\n", ntohs(client

.sin_port), inet_ntoa(client.sin_addr));
data_un = 1;
data_pass = 1;
while(data_un)
{
memset(&s1.uname,0,sizeof(s1.uname));
memset(&s2.pwd,0,sizeof(s2.pwd));
un_index = 5;
pass_index = 10;
//// Logic for Authentication start here ////
data_un = recv(new,s1.uname, MAX_DATA,0);
//printf("Username = %s\n",s1.uname);
s1.uname[data_un]='\0';
data_pass = recv(new,s2.pwd, MAX_DATA,0);
//printf("Password = %s\n",s2.pwd);
s2.pwd[data_pass]='\0';
while(data_pass)
{
for(i=0; i<3; i++)
{
if(strcmp(un[i],s1.uname)==0)
{
un_index = i;
}
if(strcmp(pass[i],s2.pwd)==0)
{
pass_index = i;
}
}
if(un_index != pass_index)
{
send(new,"FAIL",4,0);
break;
}
if(un_index == pass_index)
{
send(new,"SUCCESS",7,0);
//printf("\nClient Usernam = : %s", s1.u
name);
//printf("\nClient Password = I can't di
spaly it sorry !");

//data_len = recv(new,s3.cmd,MAX_DATA,0)
;
while(1)
{
data_len = recv(new,s3.cmd,MAX_D
ATA,0);
if(strcmp(s3.cmd,"ls\n")==0)
{
d=opendir(".");
if(d)
{
i=0;
while((dir=readd
ir(d))!=NULL)
{
printf("
%s\n",dir->d_name);
strcpy(d
ata,dir->d_name);
i++;
send(new
,data,sizeof(data),0);
memset(&
data,0,sizeof(data));
}
}
send(new,"COMPLETE",8,0)
;
}
if(strcmp(s3.cmd,"date\n")==0)
{
/* Get the current time
*/
now = time(NULL);
/* Format and print the
time, "ddd yyyy-mm-dd hh:mm:ss zzz" */
strftime(data, sizeof(da
ta), "%a %Y-%m-%d %H:%M:%S %Z", ts);
//printf("\nclient msg:
%s\n",data);
send(new,data,strlen(dat
a),0);
send(new,"COMPLETE",8,0)
;
}
if(strcmp(s3.cmd,"logout\n")==0)
{
send(new,"logout",6,0);
exit(-1);
}
if((strcmp(s3.cmd,"ls\n")!=0) &&
(strcmp(s3.cmd,"date\n")!=0))
{
send(new,"IMPROPER",8,0)
;
}
}
}
}
//// Authentication ends here ////////////////////
}
printf("\nClient disconnected");
close(new);
}
close(sock);
}
**********************Server -- Output *****************************
[root@station154 ~]# gcc telnet_s.c
News Client connected from port no 55810 and IP 127.0.0.1
*********************************************************************
___________________________________________________________________________
// 17) FTP (TCP)
___________________________________________________________________________
// Client Code
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include<string.h>
struct packet
{
char op[1024];
char un[1024];
char pwd[1024];
}c1,c2,u,p;
{
int sock1,len;
FILE *fp;
sock1 = socket(AF_INET,SOCK_STREAM,0);
struct sockaddr_in serv;

serv.sin_port = htons(atoi(argv[1]));
serv.sin_family = AF_INET;
serv.sin_addr.s_addr = inet_addr("127.0.0.1");
printf("client connecting\n");
connect(sock1, (struct sockaddr*)&serv,sizeof(serv));
char buf[50];
while(1)
{
memset(&buf,0,sizeof(buf));
memset(&c1.op,0,sizeof(c1.op));
memset(&u.un,0,sizeof(u.un));
memset(&p.pwd,0,sizeof(u.pwd));
printf("Enter Username = ");
fgets(u.un,1024,stdin);
send(sock1,u.un,strlen(u.un),0);
printf("Enter Password = ");
gets(p.pwd,1024,stdin);
send(sock1,p.pwd,strlen(p.pwd),0);
len = recv(sock1,buf,1024,0);
if(strcmp(buf,"SUCCESS")==0)
{
printf("\nAUTHENTICATION SUCCESS");
while(1)
{
printf("\nPress 1 for StoC, 2 for CtoS and quit for termination=
");
//scanf("%s\n",&c1.op);
fgets(c1.op,1024,stdin);
if((send(sock1,c1.op,strlen(c1.op),0))<0)
{
printf("\nSend error");
break;
}
//printf("\nOP = %s\n",c1.op);
if(strcmp(c1.op,"1\n")==0)
{
//printf("\nOP 1 coming");
fp = fopen("c.txt","w");
while(1)
{
read(sock1,buf,50);
fprintf(fp,"%s",buf);
break;
}
printf("\n File transfer from Server to Client\n");
fclose(fp);
}
if(strcmp(c1.op,"2\n")==0)
{
fp = fopen("c.txt","r");
while(!feof(fp))
{
fread(buf,sizeof(char),50,fp);
write(sock1,buf,50);
}
printf("\n File transfer from Client to Server\n");
fclose(fp);
}
if(strcmp(c1.op,"quit\n")==0)
{
break;
}
}
}}
if(strcmp(buf,"FAIL")==0)
{
printf("\nAUTHENTICATION FAIL try again!");
}
}
**********************Client -- Output *****************************
[root@station154 ~]# gcc ftp_c.c
client connecting
Enter Username = Deep
Enter Password = 123
AUTHENTICATION SUCCESS
Press 1 for StoC, 2 for CtoS and quit for termination = 1
File transfer from Server to Client
Press 1 for StoC, 2 for CtoS and quit for termination = 2
File transfer from Client to Server
Press 1 for StoC, 2 for CtoS and quit for termination = quit
Enter Username = niraj
Enter Password = 789
AUTHENTICATION SUCCESS
Press 1 for StoC, 2 for CtoS and quit for termination =
*********************************************************************
// Server Code
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include<string.h>
struct packet
{
char op[1024];
char un[1024];
char pwd[1024];
}s1,u,p;
{
int sock1,sock2, clength,data_len=0;
int un_index = 5, pass_index = 10, un_len,pass_len;
char
char
char
FILE
uname[3][100] = {"Deep\n","ketan\n","niraj\n"};
pass[3][100] = {"123\n","456\n","789\n"};
acl[3][100] = {"read","write","anything"}
*fp;
sock1= socket(AF_INET,SOCK_STREAM,0);
struct sockaddr_in serv,cli;
serv.sin_family = AF_INET;
serv.sin_port = htons(atoi(argv[1]));
serv.sin_addr.s_addr = inet_addr("127.0.0.1");
bind(sock1,(struct sockaddr *)&serv, sizeof(serv));
listen(sock1,5);
clength = sizeof(cli);
int i=0;
char buf[50];
sock2 = accept(sock1,(struct sockaddr *)&cli,&clength);
printf("\n Client Connected\n");
while(1)
{
memset(&buf,0,sizeof(buf));
memset(&s1.op,0,sizeof(buf));
memset(&u.un,0,sizeof(u.un));
memset(&p.pwd,0,sizeof(p.pwd));
un_len = recv(sock2,u.un,1024,0);
pass_len = recv(sock2,p.pwd,1024,0);
un_index = 5;
pass_index = 10;
for(i=0; i<3; i++)
{
if(strcmp(u.un,uname[i])==0)
{
un_index = i;
}
if(strcmp(p.pwd,pass[i])==0)
{
pass_index = i;
}
}
if(un_index != pass_index)
{
send(sock2,"FAIL",4,0);
}
if(un_index == pass_index)
{
send(sock2,"SUCCESS",7,0);
while(1)
{
if((data_len = recv(sock2,s1.op,1024,0))<0)
{
printf("RECV error\n");
break;
}
s1.op[data_len] = '\0';
{
fp = fopen("s.txt","r");
while(!feof(fp))
{
fread(buf,sizeof(char),50,fp);
write(sock2,buf,50);
}
printf("\nFile transfer from Server to Client");
fclose(fp);
}
{
fp = fopen("s.txt","w");
while(1)
{
read(sock2,buf,50);
fprintf(fp,"%s",buf);
break;
}
printf("\nFile transfer from Client to Server");
fclose(fp);
}
if(strcmp(s1.op,"quit\n")==0)
{
break;
}
}
}
}
return 0;
}
**********************Server -- Output *****************************
[root@station154 ~]# gcc ftp_s.c
Client Connected
File transfer from Server to Client

*********************************************************************
___________________________________________________________________________
// 18) TFTP (UDP)
___________________________________________________________________________
// Client Code
#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<unistd.h>
#include<fcntl.h>
#define BUFFER 10000
{
struct packet
{
char opcode[10];
char filename[10];
char msg[50];
char file[5000];
}data;
int tl_pkt,sen,ans=0,length;
struct sockaddr_in server,server_control,server_data,client;
FILE *fd;
int sock,data_len,i,dackno;
char pktc_no[10];
int pkt_no;
char file_trans[BUFFER],val[10]; //data file_trans
int MTU=1500;
char ackno[50];
if((sock = socket(AF_INET,SOCK_DGRAM,0)) == -1)
{
perror("socket error");
exit(-1);
}
memset(&server_control,0,sizeof(server_control));
server_control.sin_family = AF_INET;
server_control.sin_port = htons(atoi(argv[2]));
server_control.sin_addr.s_addr = inet_addr(argv[1]);
bzero(&server_control.sin_zero,8);
while(1)
{
again: printf("\nEnter opcode(RRQ/WRQ/over):");
scanf("%s",data.opcode);
if(strcmp(data.opcode,"over") == 0)
break;
if(strcmp(data.opcode,"RRQ") == 0 || strcmp(data.opcode,"WRQ") =
= 0)
{
printf("\nEnter the file name:");
scanf("%s",data.filename);
}
else
goto again;
sendto(sock,(struct sockaddr *)&data,sizeof(data),0,(struct sock
addr *)&server_control,len);
if(strcmp(data.opcode,"RRQ")==0)
{
recvfrom(sock,pktc_no,BUFFER,0,(struct sockaddr *)&serve
r,&len);
pkt_no=atoi(pktc_no);
printf("Total no of pkts are :%d",pkt_no);
for(i=0;i<pkt_no;i++)
{
printf("\npkt no : %d\n",i);
data_len = recvfrom(sock,(struct sockaddr *)&data,BUFFE
R,0,(struct sockaddr *)&server_data, &len);
if(data_len)
{
printf("\n%s\n",data.msg);
if(strcmp(data.msg,"Server:can't open such file.
..")==0)
{
strcpy(data.msg,"Client:OK...It was my m
istake...");
sendto(sock,(struct sockaddr *)&data,siz
eof(data),0,(struct sockaddr *)&server_data,len);
goto again;
}
fd=fopen(data.filename,"aw+");
fputs(data.file,fd);
printf("\n%s\n",data.file);
sprintf(ackno,"%d",i+1);
sendto(sock,ackno,sizeof(ackno),0,(struct sockad
dr *)&server_data,len);
memset(&ackno,0,sizeof(ackno));
fclose(fd);
}
}
strcpy(data.msg,"Client:File Fragment no successfully written on
client...");
sendto(sock,(struct sockaddr *)&data,sizeof(data),0,(struct sock
addr *)&server_data,len);
}
if(strcmp(data.opcode,"WRQ")==0)
{
goback: data_len=recvfrom(sock,(struct sockaddr *)&data,BUFFER,0,(struct sockad
dr *)&server_data, &len);
if(data_len)
{
if(strcmp(data.msg,"Server:You can write the fil
e...")==0)
{
fd = fopen(data.filename,"r+" );
printf("\nFile name is %s\n",data.filen
ame);
fseek(fd,0L,SEEK_END);
length=ftell(fd);
if(length%MTU==0)
tl_pkt=length/MTU;
else
tl_pkt=(length/MTU)+1;
printf("%d",tl_pkt);
sprintf(val,"%d",tl_pkt);
sendto(sock,val,strlen(val),0,(struct so
ckaddr *)&server_data,len);
printf("\nfile length is:%d\n",length);
ans=0;
for(i=0;i<tl_pkt;i++)
{
fseek(fd,ans,SEEK_SET);
fread(data.file,MTU,1,fd);
give:
sendto(sock,(struct sockaddr *)&
data,sizeof(data),0,(struct sockaddr *)&server_data,len);
memset(&data.file,0,sizeof(data.
file));
recvfrom(sock,ackno,BUFFER,0,(st
ruct sockaddr *)&server_data,&len);
dackno=atoi(ackno);
printf("\nAcknowledgement from s
erver is %d\n",dackno);
ans=ans+MTU;
}
fclose(fd);
}
}
}
}
printf("\nclient terminated...........\n\n");
close(sock);
}
// Server Code
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
#include<errno.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<pthread.h>
#define BUFFER
10000
struct packet
{
char opcode[10];
char filename[10];
char msg[50];
char file[5000];
}data;
struct sockaddr_in server_control,server_data,client;
void service(int);
{
int sockc,datac,dataport;
pthread_t thread;
int ret;
if((sockc = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
{
perror("socket error ");
exit(-1);
}
memset(&server_control,0,sizeof(server_control));
server_control.sin_family = AF_INET;
server_control.sin_port = htons(atoi(argv[1]));
server_control.sin_addr.s_addr = INADDR_ANY;
bzero(&server_control.sin_zero, 8);
if((bind(sockc, (struct sockaddr *)&server_control, len)) == -1)
{
perror("bind : ");
exit(-1);
}
while(1)
{
printf("\nServer Ready.....\n\n");
datac = recvfrom(sockc,(struct sockaddr *)&data, BUFFER, 0,(stru
ct sockaddr *)&client,&len);
if (datac)
{
printf("\nopcode:%s\n",data.opcode);
printf("\nFile Name:%s\n",data.filename);
memset(&stdin,0,sizeof(stdin));
dataport=atoi(argv[2]);
ret=pthread_create(&thread,NULL,service,dataport);
}
}
close(sockc);
}
void service(int port)
{
int iret,sockd,datad,dataw;
FILE *fd;
int MTU=1500,pkt_no;
char val[10],pktc_no[10];
struct stat stat_buf;
int length,data_l,dackno;
int tl_pkt,i,ans=0;
char ackno[50];
if((sockd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
{
perror("socket error ");
exit(-1);
}
memset(&server_data,0,sizeof(server_data));
server_data.sin_family = AF_INET;
server_data.sin_port = htons(port);
server_data.sin_addr.s_addr = INADDR_ANY;
bzero(&server_data.sin_zero, 8);
if((bind(sockd, (struct sockaddr *)&server_data, len)) == -1)
{
perror("bind : ");
exit(-1);
}
if(strcmp(data.opcode,"RRQ") == 0)
{
fd = fopen(data.filename,"r+" );
if(fd==NULL)
{
printf("\ncan't open %s for reading\n",data);

strcpy(data.msg,"Server:can't open such file...");
}
else
{
fd=fopen(data.filename,"r+");
fseek(fd,0L,SEEK_END);
length=ftell(fd);
if(length%MTU==0)
tl_pkt=length/MTU;
else
tl_pkt=(length/MTU)+1;
printf("%d",tl_pkt);
sprintf(val,"%d",tl_pkt);
sendto(sockd,val,strlen(val),0,(struct sockaddr *)&clien
t,len);
printf("\nfile length is:%d\n",length);
ans=0;
for(i=0;i<tl_pkt;i++)
{
fseek(fd,ans,SEEK_SET);
fread(data.file,MTU,1,fd);
sendto(sockd,(struct sockaddr *)&data,sizeof(dat
a),0,(struct sockaddr *)&client,len);
memset(&data.file,0,sizeof(data.file));
aack: dataw=recvfrom(sockd,ackno,BUFFER,0,(struct sock
addr *)&client,&len);
if(dataw)
{
dackno=atoi(ackno);
printf("\nAcknowledgement from client is
%d\n",dackno);
if(dackno==i+1)
{
ans=ans+MTU;
}
else goto aack;
}
else printf("\n\ndata not recvd for ack...\n\n")
;
}
fclose(fd);
strcpy(data.msg,"Server:file is transfered....");
}
goback:
datad = recvfrom(sockd,(struct sockaddr *)&data, BUFFER, 0,(stru
ct sockaddr *)&client,&len);
if(datad)
else
goto goback;
}
if(strcmp(data.opcode,"WRQ") == 0)
{
strcpy(data.msg,"Server:You can write the file...");
sendto(sockd,(struct sockaddr *)&data,sizeof(data),0,(struct soc
kaddr *)&client,len);
dataw=recvfrom(sockd,pktc_no,BUFFER,0,(struct sockaddr *)&client
,&len);
if(dataw)
{
pkt_no=atoi(pktc_no);
printf("Total no of pkts are :%d",pkt_no);
for(i=0;i<pkt_no;i++)
{
printf("\npkt no : %d\n",i+1);
recvfrom(sockd,(struct sockaddr *)&data,BUFFER,0
,(struct sockaddr *)&client,&len);
fd=fopen(data.filename,"aw+");
fputs(data.file,fd);
printf("\n%s\n",data.file);
sprintf(ackno,"%d",i+1);
sendto(sockd,ackno,sizeof(ackno),0,(struct socka
ddr *)&client,len);
fclose(fd);
}
}
}
iret=pthread_detach(pthread_self());
close(sockd);
}
___________________________________________________________________________
// 19) Firewall (content based)
___________________________________________________________________________
// Client Code
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<error.h>
#define BUFFER 1024
{
int sock,len=0;
char reply[BUFFER];
{
}
))<0)
{
}
while(1)
{
printf("\nEnter the Packet = ");
{
break;
}
if(strcmp(data_out,"PACKET IS FORWARDED")==0)
{
len = recv(sock,reply,BUFFER,0);
reply[len] = '\0';
printf("\nReply from firewall = %s",data_out);
printf("\nReply from Server = %s",reply);
memset(&reply,0,sizeof(reply));
}
if(strcmp(data_out,"PACKET IS DISCARDED")==0)
{
}
}
close(sock);
}
**********************Client -- Output *****************************

[root@station154 ~]# gcc -o c firewall_content_c.c
[root@station154 ~]# ./c 127.0.0.1 9999
Enter the Packet = Deep
Reply from firewall = PACKET IS FORWARDED

Reply from Server = YOUR REQUEST IS ACCEPTED
Enter the Packet =
*********************************************************************
// Server Code
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<error.h>
#include<time.h>
#define BUFFER
#define MAX_CLIENT
1024
2

{
unsigned int iseed;
int sock;
int new;
int i=0,rule_index=15;
int data_len;
char data[BUFFER];
char discard[5][100] = {"attack\n","target\n","murder\n","plan\n","fire\
n"};
{
}
{
}
{
}
while(1)
{

{
}
while(1)
{
i=0;
rule_index = 15;
if(data_len)
{
printf("\nClient's Packet = %s",data);
/// Rule Server Logic start here ////
for(i=0; i<5;i++)
{
if(strcmp(data,discard[i])==0)
{
rule_index = i;
}
}
if(rule_index != 15)
{
send(new,"PACKET IS DISCARDED",19,0);
}
if(rule_index == 15)
{
send(new,"PACKET IS FORWARDED",19,0);
send(new,"YOUR REQUEST IS ACCEPTED",24,0);
}
/// Rule Server Logic ends here ////
if((strcmp(data,"exit\n"))==0)
{
printf("\nclient disconnected");
break;
}
}
}
close(new);
}
close(sock);
}
**********************Server -- Output *****************************

[root@station154 ~]# gcc -o s firewall_content_s.c
[root@station154 ~]# ./s 9999

Client's Packet = Deep
*********************************************************************
___________________________________________________________________________
// 20) Firewall (Port based)
___________________________________________________________________________
// Client Code
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<error.h>
#define BUFFER 1024
{
int sock,len=0;
char reply[BUFFER];
{
}
))<0)
{
}
while(1)
{
printf("\nEnter the Packet = ");
{
break;
}
if(strcmp(data_out,"PACKET IS FORWARDED")==0)
{
len = recv(sock,reply,BUFFER,0);
reply[len] = '\0';
printf("\nReply from Server = %s",reply);
memset(&reply,0,sizeof(reply));
}
if(strcmp(data_out,"PACKET IS DISCARDED")==0)
{
}
}
close(sock);
}
**********************Client -- Output *****************************

[root@station154 ~]# gcc -o c firewall_client.c
[root@station154 ~]# ./c 127.0.0.1 8888
Enter the Packet = Deep
Reply from firewall = PACKET IS DISCARDED
Enter the Packet =
*********************************************************************
// Server Code
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<error.h>
#include<time.h>
#define BUFFER
#define MAX_CLIENT
1024
2

{
unsigned int iseed;

int sock;
int new;
int i=0,rule_index=15;
int data_len;
char data[BUFFER];
{
}
{
}
{
}
printf("\n I am firewall My port range is 10000 to 55000");
while(1)
{
{
}
while(1)
{
i=0;
rule_index = 15;
if(data_len)
{
printf("\nClient's Packet = %s",data);
/// Rule Server Logic start here ////
for(i=10000; i<55000; i++)
{
if(i == ntohs(client.sin_port))
{
rule_index = i;
}
}
if(rule_index != 15)
{
send(new,"PACKET IS DISCARDED",19,0);
}
if(rule_index == 15)
{
send(new,"PACKET IS FORWARDED",19,0);
send(new,"YOUR REQUEST IS ACCEPTED",24,0);
}
/// Rule Server Logic ends here ////
if((strcmp(data,"exit\n"))==0)
{
printf("\nclient disconnected");
break;
}
}
}
close(new);
}
close(sock);
}
**********************Server -- Output *****************************
[root@station154 ~]# gcc -o s firewall_sever.c
[root@station154 ~]# ./s 8888
I am firewall My port range is 10000 to 55000
Client's Packet = Deep
*********************************************************************
___________________________________________________________________________
// 21) Web Server
___________________________________________________________________________
// Client Code
#include
#include
#include
#include
#include
#include
#include
<stdio.h>
<stdlib.h>
<unistd.h>
<sys/types.h>
<sys/socket.h>
<netinet/in.h>
<arpa/inet.h>
#define PORT
8181
/* port number as an integer */
#define IP_ADDRESS "9.137.62.23"
/* IP address as a string */
#define BUFSIZE 8196

pexit(char * msg)
{
perror(msg);
exit(1);
}
main()
{
int i,sockfd;
char buffer[BUFSIZE];
static struct sockaddr_in serv_addr;
printf("client trying to connect to %s and port %d\n",IP_ADDRESS,PORT);
if((sockfd = socket(AF_INET, SOCK_STREAM,0)) <0)
pexit("socket() failed");
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = inet_addr(IP_ADDRESS);
serv_addr.sin_port = htons(PORT);
if(connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) <0)
pexit("connect() failed");
/* now the sockfd can be used to communicate to the server */
write(sockfd, "GET /index.html \r\n", 18);
/* note second space is a delimiter and important */
/* this displays the raw HTML file as received by the browser */
while( (i=read(sockfd,buffer,BUFSIZE)) > 0)
write(1,buffer,i);
}
// Server Code
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define
#define
#define
#define
<stdio.h>
<stdlib.h>
<unistd.h>
<errno.h>
<string.h>
<fcntl.h>
<signal.h>
<sys/types.h>
<sys/socket.h>
<netinet/in.h>
<arpa/inet.h>
BUFSIZE 8096
ERROR 42
SORRY 43
LOG 44
struct {
char *ext;
char *filetype;
} extensions [] = {
{"gif", "image/gif" },
{"jpg", "image/jpeg"},
{"jpeg","image/jpeg"},
{"png", "image/png" },
{"zip", "image/zip" },
{"gz", "image/gz" },
{"tar", "image/tar" },
{"htm", "text/html" },
{"html","text/html" },
{0,0} };
void log(int type, char *s1, char *s2, int num)
{
int fd ;
char logbuffer[BUFSIZE*2];
switch (type) {
case ERROR: (void)sprintf(logbuffer,"ERROR: %s:%s Errno=%d exiting pid=%
d",s1, s2, errno,getpid()); break;
case SORRY:
(void)sprintf(logbuffer, "<HTML><BODY><H1>nweb Web Server Sorry:
%s %s</H1></BODY></HTML>\r\n", s1, s2);
(void)write(num,logbuffer,strlen(logbuffer));
(void)sprintf(logbuffer,"SORRY: %s:%s",s1, s2);
break;
case LOG: (void)sprintf(logbuffer," INFO: %s:%s:%d",s1, s2,num); break;
}
/* no checks here, nothing can be done a failure anyway */
if((fd = open("nweb.log", O_CREAT| O_WRONLY | O_APPEND,0644)) >= 0) {
(void)write(fd,logbuffer,strlen(logbuffer));
(void)write(fd,"\n",1);
(void)close(fd);
}
if(type == ERROR || type == SORRY) exit(3);
}
/* this is a child web server process, so we can exit on errors */
void web(int fd, int hit)
{
int j, file_fd, buflen, len;
long i, ret;
char * fstr;
static char buffer[BUFSIZE+1]; /* static so zero filled */
ret =read(fd,buffer,BUFSIZE); /* read Web request in one go */
if(ret == 0 || ret == -1) {
/* read failure stop now */
log(SORRY,"failed to read browser request","",fd);
}
if(ret > 0 && ret < BUFSIZE)
/* return code is valid chars */
buffer[ret]=0;
/* terminate the buffer */
else buffer[0]=0;
for(i=0;i<ret;i++)
/* remove CF and LF characters */
if(buffer[i] == '\r' || buffer[i] == '\n')
buffer[i]='*';
log(LOG,"request",buffer,hit);
if( strncmp(buffer,"GET ",4) && strncmp(buffer,"get ",4) )
log(SORRY,"Only simple GET operation supported",buffer,fd);
for(i=4;i<BUFSIZE;i++) { /* null terminate after the second space to ign

ore extra stuff */
if(buffer[i] == ' ') { /* string is "GET URL " +lots of other st
uff */
buffer[i] = 0;
break;
}
}
for(j=0;j<i-1;j++)
/* check for illegal parent directory use .. */
if(buffer[j] == '.' && buffer[j+1] == '.')
log(SORRY,"Parent directory (..) path names not supporte
d",buffer,fd);
if( !strncmp(&buffer[0],"GET /\0",6) || !strncmp(&buffer[0],"get /\0",6)
) /* convert no filename to index file */
(void)strcpy(buffer,"GET /index.html");
/* work out the file type and check we support it */
buflen=strlen(buffer);
fstr = (char *)0;
for(i=0;extensions[i].ext != 0;i++) {
len = strlen(extensions[i].ext);
if( !strncmp(&buffer[buflen-len], extensions[i].ext, len)) {
fstr =extensions[i].filetype;
break;
}
}
if(fstr == 0) log(SORRY,"file extension type not supported",buffer,fd);
if(( file_fd = open(&buffer[5],O_RDONLY)) == -1) /* open the file for re
ading */
log(SORRY, "failed to open file",&buffer[5],fd);
log(LOG,"SEND",&buffer[5],hit);
(void)sprintf(buffer,"HTTP/1.0 200 OK\r\nContent-Type: %s\r\n\r\n", fstr
);
(void)write(fd,buffer,strlen(buffer));
/* send file in 8KB block - last block may be smaller */
while ( (ret = read(file_fd, buffer, BUFSIZE)) > 0 ) {
(void)write(fd,buffer,ret);
}
#ifdef LINUX
sleep(1);
/* to allow socket to drain */
#endif
exit(1);
}
int main(int argc, char **argv)
{
int i, port, pid, listenfd, socketfd, hit;
size_t length;
static struct sockaddr_in cli_addr; /* static = initialised to zeros */
static struct sockaddr_in serv_addr; /* static = initialised to zeros */
if( argc < 3 || argc > 3 || !strcmp(argv[1], "-?") ) {
(void)printf("hint: nweb Port-Number Top-Directory\n\n"
"\tnweb is a small and very safe mini web server\n"

"\tnweb only servers out file/web pages with extensions named below\n"
"\t and only from the named directory or its sub-directories.\n"
"\tThere is no fancy features = safe and secure.\n\n"
"\tExample: nweb 8181 /home/nwebdir &\n\n"
"\tOnly Supports:");
for(i=0;extensions[i].ext != 0;i++)
(void)printf(" %s",extensions[i].ext);
(void)printf("\n\tNot Supported: URLs including \"..\", Java, Ja
vascript, CGI\n"
"\tNot Supported: directories / /etc /bin /lib /tmp /usr /dev /sbin \n"
"\tNo warranty given or implied\n\tNigel Griffiths nag@uk.ibm.com\n"
);
exit(0);
}
if( !strncmp(argv[2],"/" ,2 ) || !strncmp(argv[2],"/etc", 5 ) ||
!strncmp(argv[2],"/bin",5 ) || !strncmp(argv[2],"/lib", 5 ) ||
!strncmp(argv[2],"/tmp",5 ) || !strncmp(argv[2],"/usr", 5 ) ||
!strncmp(argv[2],"/dev",5 ) || !strncmp(argv[2],"/sbin",6) ){
(void)printf("ERROR: Bad top directory %s, see nweb -?\n",argv[2
]);
exit(3);
}
if(chdir(argv[2]) == -1){
(void)printf("ERROR: Can't Change to directory %s\n",argv[2]);
exit(4);
}
/* Become deamon + unstopable and no zombies children (= no wait()) */
if(fork() != 0)
return 0; /* parent returns OK to shell */
(void)signal(SIGCLD, SIG_IGN); /* ignore child death */
(void)signal(SIGHUP, SIG_IGN); /* ignore terminal hangups */
for(i=0;i<32;i++)
(void)close(i);
/* close open files */
(void)setpgrp();
/* break away from process group */
log(LOG,"nweb starting",argv[1],getpid());
/* setup the network socket */
if((listenfd = socket(AF_INET, SOCK_STREAM,0)) <0)
log(ERROR, "system call","socket",0);
port = atoi(argv[1]);
if(port < 0 || port >60000)
log(ERROR,"Invalid port number (try 1->60000)",argv[1],0);
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(port);
if(bind(listenfd, (struct sockaddr *)&serv_addr,sizeof(serv_addr)) <0)
log(ERROR,"system call","bind",0);
if( listen(listenfd,64) <0)
log(ERROR,"system call","listen",0);
for(hit=1; ;hit++) {
length = sizeof(cli_addr);
if((socketfd = accept(listenfd, (struct sockaddr *)&cli_addr, &l
ength)) < 0)
log(ERROR,"system call","accept",0);
if((pid = fork()) < 0) {
log(ERROR,"system call","fork",0);
}
else {
if(pid == 0) { /* child */
(void)close(listenfd);
web(socketfd,hit); /* never returns */
} else {
/* parent */
(void)close(socketfd);
}
}
}
}

An 16

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

An 16

Transféré par

Droits d'auteur :

Formats disponibles

/**************************************************************************

Name : Singal Deepkumar Mansingbhai

**********************Client -- Output *****************************

main(int argc,char **argv)

// 3) Echo server (UDP)

**********************Client -- Output *****************************

main(int argc, char **argv)

main(int argc, char **argv)

if((new = accept(sock, (struct sockaddr *)&client, &sockaddr_len)) == -1

/* Get the current time */

**********************Client -- Output *****************************

main(int argc, char **argv)

struct sockaddr_in server,client;

**********************Client -- Output *****************************

main(int argc,char **argv)

main(int argc, char **argv)

printf("\n\n\nEnter \"over\" for termination");

main(int argc,char **argv)

printf("\nEnter Expression = ");

**********************Client -- Output *****************************

main(int argc, char **argv)

**********************Client -- Output *****************************

main(int argc,char **argv)

main(int argc, char **argv)

Enter the Number =

main(int argc, char **argv)

for(i=1; i<=10; i++)

#define BUFFER 1024

printf("\nEnter the IP address = ");

main(int argc,char **argv)

data_len = recv(new,mask,MAX_DATA, 0);

The token for ip is = 168

Client MASK address = 255.255.0.0

if((connect(sock,(struct sockaddr *)&server,sizeof(struct sockaddr_in)))

printf("Enter your Packet:");

send(sock,(struct sockaddr *)&client_s,sizeof(client_s),0);

data_len=recv(sock,(struct sockaddr *)&client_s,BUFFER,0);

printf("\n\nEcho msg :%s\n\n",client_s.data_in);

struct sockaddr_in server;

if((connect(sock,(struct sockaddr *)&server,sizeof(struct sockaddr_in)))

printf("Enter your Packet:");

send(sock,(struct sockaddr *)&client_s,sizeof(client_s),0);

data_len=recv(sock,(struct sockaddr *)&client_s,BUFFER,0);

printf("\n\nEcho msg :%s\n\n",client_s.data_in);

if(bind(sock,(struct sockaddr *)&server,len) == -1)

printf("The new client connected on %s this ip and port no is: %d\n",ine

data_len=recv(sd,(struct sockaddr *)&server_s,BUFFER,0);

from incompatible poin

Waiting for clients.....

printf("\nWaiting for clients.....\n\n");

main(int argc, char **argv)

if((bind(sock, (struct sockaddr *)&server, sockaddr_len)) == ERROR)

printf("News Client connected from port no %d and IP %s\n", ntohs(client

spaly it sorry !");

struct sockaddr_in serv;

File transfer from Server to Client

printf("\ncan't open %s for reading\n",data);

**********************Client -- Output *****************************

Reply from firewall = PACKET IS FORWARDED

main(int argc,char **argv)

if((new=accept(sock,(struct sockaddr *)&client,&len))<0)

**********************Server -- Output *****************************

[root@station154 ~]# ./s 9999

Client -- Output *******

Client -- Output *******

Client -- Output *******

Client -- Output *******

Client -- Output *******

Client -- Output *******

Client -- Output *******

Server -- Output *******

Client -- Output *******