UDP.yash

// Iterative UDP Client sending two integer number to server and receive division & reminder of
it.
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<sys/un.h>
#include<unistd.h>
#include<netinet/in.h>
#include<arpa/inet.h>
int main()
{
int client_sockfd;
struct sockaddr_in client;
char a[10],b[10],c[10],d[10];
int buf_size=1000;
client.sin_addr.s_addr=inet_addr("127.0.0.1");
client.sin_family=AF_INET;
client.sin_port=htons(1234);
int len=sizeof(client);
client_sockfd=socket(AF_INET,SOCK_DGRAM,0);
connect(client_sockfd,(struct sockaddr *)&client,len);
printf("nEnter the Frist Number n");
scanf("n %s",a);
int i=sendto(client_sockfd,a,strlen(a)+1,0,(struct sockaddr *)&client,len);
printf("nEnter the Second Number n");
scanf("n %s",b);
int j=sendto(client_sockfd,b,strlen(b)+1,0,(struct sockaddr *)&client,len);
int k=recvfrom(client_sockfd,c,buf_size,0,(struct sockaddr *)&client,&len);
int l=recvfrom(client_sockfd,d,buf_size,0,(struct sockaddr *)&client,&len);
c[k]='0';
d[l]='0';
printf("nDivision of two Number is ==> %sn",c);
printf("nReminder given Number is ==> %sn",d);
close(client_sockfd);
}

// Itrative UDP Server to receive two numbers seperated by space from client and seperate it.send
Addition/Substraction/ Multiplication/ Division of those numbers to client.
#include<stdio.h>
#include<sys/un.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>
int main()
{
int server_sockfd;
struct sockaddr_in client,server;
char str[100],strone[100],strtwo[100];
server.sin_addr.s_addr=inet_addr("127.0.0.1");
server.sin_family=AF_INET;
server.sin_port=htons(1234);
int len=sizeof(server);
server_sockfd=socket(AF_INET,SOCK_DGRAM,0);
bind(server_sockfd,(struct sockaddr*) &server,len);
printf("n Server is waiting............... n");
int f=recvfrom(server_sockfd,str,100,0,(struct sockaddr *)&server,&len);
str[f]='0';
printf("n Data raceived From Client is ==> %s",str);
int i=0,j=0,k=0;
char buffer[1000];
// for seperation
while(str[i]!=' ')
{
strone[j]=str[i];
j++;
i++;
}
i++;
while(str[i]!='0')
{
strtwo[k]=str[i];
k++;
i++;
}
strtwo[k]='0';
// convert to integer
int a=atoi(strone);
int b=atoi(strtwo);

//printf("n nom1 is ==> %d",a);
//printf("n nom2 is ==> %d",b);
int c=a*b;
// convert the result into string
sprintf(buffer,"%d",c);
sendto(server_sockfd,buffer,strlen(buffer)+1,0,(struct sockaddr *)&server,len);
printf("n Result to client is ==> %dn",c);
printf("n Data send succefully!!!!! n ");
close(server_sockfd);
}
// Itrative UDP client to send two numbers seperated by space to server.Receive
Addition/Substraction/ Multiplication/Division from client
#include<stdio.h>
#include<sys/un.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>
int main()
{
int client_sockfd;
char a[10],b[10],b_test[1000];
int buf_size=1000;
client_sockfd=socket(AF_INET, SOCK_DGRAM,0);
printf("n Enter The Frist String(Number) ==> ");
scanf("%s",a);
strcat(a," ");
printf("n Enter The Second String(Number) ==> ");
scanf("%s",b);
strcat(a,b);
printf("n String is ==> %s n",a);

int i=sendto(client_sockfd,a,strlen(a),0,(struct sockaddr*) &client,len);
int j=recvfrom(client_sockfd,b_test,buf_size,0,(struct sockaddr*) &client,&len);
b_test[j]='0';
printf("n Data Received from Server is %s n",b_test);
}
// Iterative UDP Server for factorial
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/un.h>
#include<unistd.h>
int main()
{
int server_sockfd;
struct sockaddr_in server;
// int bytes_read;
char buffer[1000];
char fact_str[1000];
int buf_size=1024;
int len=sizeof(server);
bind(server_sockfd,(struct sockaddr *)&server,len);
int i=recvfrom(server_sockfd,buffer,buf_size,0,(struct sockaddr *)&server,&len);
printf("Data Received from Client is %s ",buffer);
int n=atoi(buffer);
int x =0;
long int fact=1;
for(x=1;x<=n;x++)
{
fact=fact*x;
}
sprintf(fact_str,"%d",fact);

printf("nFactorial of given no is %s n ",fact_str);
sendto(server_sockfd,fact_str,strlen(fact_str)+1,0,(struct sockaddr *)&server,len);
}
// Iterative UDP Client for factorial
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/un.h>
#include<unistd.h>
int main()
{
int client_sockfd;
char buffer[1000],b_test[1000];
int buf_size=1000;
printf("nEnter the Number n");
scanf("n %s",buffer);
int i=sendto(client_sockfd,buffer,strlen(buffer)+1,0,(struct sockaddr *)&client,len);
int j=recvfrom(client_sockfd,b_test,buf_size,0,(struct sockaddr *)&client,&len);
printf("nFactorial of given Number is ==> %sn",b_test);
}
// Program for Iterative UDP Server. Program accepting string from client and reply in all
uppercase.
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#include<sys/un.h>
#include<unistd.h>
void alltolower(char* s)
{
while(*s!=0)
*s++=tolower(*s);
}
int main()
{
int server_sockfd,len;
int bytes_read,buf_size=1000;
char buffer[1000];
len=sizeof(server);
bind(server_sockfd,(struct sockaddr*)&server,len);
do
{
printf("server is waiting..........n ");
bytes_read=recvfrom(server_sockfd,buffer,buf_size,0,(struct sockaddr
*)&server,&len);
printf("nRecieved String from Client is %s",buffer);
if(bytes_read>0)
{
alltolower(buffer);
sendto(server_sockfd,buffer,bytes_read,0,(struct sockaddr *)&server,len);
printf("nReply to Client is : '%s'n",buffer);
}
else
perror("nRecvfrom");
}while(bytes_read>0);
}
/* Program for Iterative UDP Client. Program sending string to server and return string in all
uppercase.
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/un.h>

#include<unistd.h>
int main()
{
int client_sockfd,len;
char buffer[1000];
int buf_size=1000;
len=sizeof(client);
printf("nEnter the String to Process : ");
scanf("%s",buffer);
sendto(client_sockfd,buffer,strlen(buffer)+1,0,(struct sockaddr*)&client,len);
recvfrom(client_sockfd,buffer,buf_size,0,(struct sockaddr*)&client,&len);
printf("Reply from server: '%s'n",buffer);
}
/* Program for Iterative UDP Server */
/* Program accepting string from client and reply in all lowercaseor uppercase*/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/un.h>
#include<unistd.h>

void alllowup(char* s)
{
int i=0;
while(s[i]!=0)
{
if(s[i]>=97)
s[i]=s[i]-32;
else
s[i]=s[i]+32;
i++;
}
}
int main()
{
int bytes_read,buf_size=1000;
char buffer[1000];
len=sizeof(server);
bind(server_sockfd,(struct sockaddr*)&server,len);
do
{
printf("server is waiting..........n ");
bytes_read=recvfrom(server_sockfd,buffer,buf_size,0,(struct sockaddr *)&server,&len);
printf("nRecieved String from Client is %s",buffer);
if(bytes_read>0)
{
alllowup(buffer);
sendto(server_sockfd,buffer,strlen(buffer)+1,0,(struct sockaddr *)&server,len);
printf("nReply to Client is : '%s'n",buffer);
}
else
perror("nRecvfrom");
}while(bytes_read>0);
}
/* Program for Iterative UDP Client */
/* Program sending string to server and return string in all lowercase or uppercase*/

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/un.h>
#include<unistd.h>
int main()
{
char buffer[1000];
int buf_size=1000;
len=sizeof(client);
printf("nEnter the String to Process : ");
scanf("%s",buffer);
recvfrom(client_sockfd,buffer,buf_size,0,(struct sockaddr*)&client,&len);
printf("Reply from server: '%s'n",buffer);
}

// Iterative UDP Server to receive one number from client and check it is
palindrome or not? and send result back to client.
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/un.h>
#include<unistd.h>
int main()
{
char a[10],b[10];
int buf_size=1024,flag=0;
len=sizeof(server);
recvfrom(server_sockfd,a,buf_size,0,(struct sockaddr *)&server,&len);
printf("Data Received from Client is %s n",a);
int n=atoi(a);
int no=n;
int rem=0,rev=0;
while(n>0)
{
rem=n%10;
rev=rev*10+rem;
n=n/10;
}
if(no==rev)
{
printf("n Reply To Client is Number is Palindromen");
printf("n Reverse is : %d ",rev);
}
else
{
printf("n Reply To Client is Number is Not Palindromen");
printf("n Reverse is : %d ",rev);
}

sprintf(b,"%d",rev);
sendto(server_sockfd,b,strlen(b)+1,0,(struct sockaddr *)&server,len);
}
// Iterative UDP Client to send one number to server (to check palimdrome or not??)
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/un.h>
#include<unistd.h>
int main()
{
char a[10],b[10];
int buf_size=1000;
len=sizeof(client);
scanf("n %s",a);
int j=recvfrom(client_sockfd,b,buf_size,0,(struct sockaddr *)&client,&len);
int no=atoi(a);
int rev=atoi(b);
if(no==rev)
{
printf("n Reply From Server is Number is Palindromen");
}
else
{
printf("n Reply From Server is Number is Not Palindromen");
}
}

// Iterative UDP Server to receive one number from client and check it is rime or not?and
// send result back to client
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/un.h>
#include<unistd.h>
int main()
{
char a[10],b[10];
int buf_size=1024,flag=0;
len=sizeof(server);
recvfrom(server_sockfd,a,buf_size,0,(struct sockaddr *)&server,&len);
printf("Data Received from Client is %s n",a);
int n=atoi(a);
int i;
for(i=2;i<n;i++)
{
if(n%i==0)
{
flag=1;
break;
}
}
printf("number is is %d n",flag);
sprintf(b,"%d",flag);
sendto(server_sockfd,b,strlen(b)+1,0,(struct sockaddr *)&server,len);
}

// Iterative UDP Client to send one number to server (to check prime or not??)
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/un.h>
#include<unistd.h>
int main()
{
char a[10],b[10];
int buf_size=1000;
len=sizeof(client);
scanf("n %s",a);
int j=recvfrom(client_sockfd,b,buf_size,0,(struct sockaddr *)&client,&len);
printf("nThe flag is%s n",b);
int flag=atoi(b);
if(flag==0)
printf("nThe Number is Prime Number n");
else
printf("nThe Number is not Prime Number n");
}

// Iterative UDP Server for Reverse of String. Sending Reverse String to Client
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/un.h>
#include<unistd.h>
int main()
{
char buffer[1000];
char rev_str[1000];
int i=0,j;
int buf_size=1000;
len=sizeof(server);
printf("nServer is waiting ..............n");
recvfrom(server_sockfd,buffer,buf_size,0,(struct sockaddr*)&server,&len);
printf("nReceived string is : '%s' ",buffer);
printf("nLength of received string is : %dn",strlen(buffer));
int length=strlen(buffer);
length--;
j=0;
for(i=length;i>=0;i--)
{
rev_str[j]=buffer[i];
j++;
}
rev_str[j]='0';
printf("nReverse of string is : '%s' n ",rev_str);
// Now sending reverse string to clinet
sendto(server_sockfd,rev_str,strlen(rev_str)+1,0,(struct sockaddr*)&server,len);
printf("nString send successfullyn");
}

// Iterative UDP Client (Send String and get Reverse String from Server)
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/un.h>
#include<unistd.h>
int main()
{
char buffer[1000];
char buffer_test[1000];
int buf_size=1000;
len=sizeof(client);
printf("nEnter the string send to server : ");
scanf("%s",buffer);
printf("nReceived reverse string from server is : ");
recvfrom(client_sockfd,buffer_test,buf_size,0,(struct sockaddr*)&client,&len);
printf("'%s'n",buffer_test);
}
// Iterative UDP Server for Reverse of String
// Sending Reverse String to Client
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#include<sys/un.h>
#include<unistd.h>
int main()
{
char buffer[1000];
char rev_str[1000];
int i=0,j;
int buf_size=1000;
len=sizeof(server);
printf("nServer is waiting ..............n");
recvfrom(server_sockfd,buffer,buf_size,0,(struct sockaddr*)&server,&len);
printf("nReceived string is : '%s' ",buffer);
printf("nLength of received string is : %dn",strlen(buffer));
int length=strlen(buffer);
length--;
j=0;
for(i=length;i>=0;i--)
{
rev_str[j]=buffer[i];
j++;
}
rev_str[j]='0';
printf("nReverse of string is : '%s' n ",rev_str);
// Now sending reverse string to clinet
sendto(server_sockfd,rev_str,strlen(rev_str)+1,0,(struct sockaddr*)&server,len);
printf("nString send successfullyn");
}

// Iterative UDP Client (Send String and get Reverse String from Server)
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/un.h>
#include<unistd.h>
int main()
{
char buffer[1000],buffer1[1000];
char buffer_test[1000];
int buf_size=1000;
len=sizeof(client);
printf("nEnter the string send to server : ");
scanf("%s",buffer);
printf("nReceived reverse string from server is : ");
recvfrom(client_sockfd,buffer_test,buf_size,0,(struct sockaddr*)&client,&len);
printf("'%s'n",buffer_test);
if(strcmp(buffer,buffer1))
printf("n String is Palindromen");
else
printf("n String is not Palindromen");
}

// Itrative UDP Server Sum of Digit
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/un.h>
#include<unistd.h>
int main()
{
int server_sockfd;
// int bytes_read;
char buffer[1000];
char fact_str[1000];
int buf_size=1024;
bind(server_sockfd,(struct sockaddr *)&server,sizeof(server));
int i=recvfrom(server_sockfd,buffer,buf_size,0,(struct sockaddr *)&server,&buf_size);
printf("Data Received from Client is %s ",buffer);
int no=atoi(buffer);
int sum=0,rem=0;
while(no>0)
{
rem=no%10;
sum=sum+rem;
no=no/10;
}
printf("n Sum of Digit is ==> %d n", sum);
sprintf(fact_str,"%d",sum);
sendto(server_sockfd,fact_str,strlen(fact_str)+1,0,(struct sockaddr *)&server,sizeof(server));
}

// Itrative UDP client Sum of Digit
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/un.h>
#include<unistd.h>
int main()
{
char buffer[1000],b_test[1000];
int buf_size=1000;
len=sizeof(client);
scanf("n %s",buffer);
int i=sendto(client_sockfd,buffer,strlen(buffer)+1,0,(struct sockaddr *)&client,len);
int j=recvfrom(client_sockfd,b_test,buf_size,0,(struct sockaddr *)&client,&len);
printf("nSum of Digits of given Number is ==> %sn",b_test);
}

//UDP Client Chargen
#include<stdio.h>
#include<netdb.h>
#include<string.h>
int main()
{
int sd,i=0;
char buf[72],msg[100];
struct sockaddr_in cl;
sd=socket(PF_INET,SOCK_DGRAM,0);
if(sd<0)
printf("Error in socket");
cl.sin_family=AF_INET;
cl.sin_port=3000;
cl.sin_addr.s_addr=inet_addr("127.0.0.1");
printf("Enter the msg=>");
scanf("%s",&msg);
int len=sizeof(cl);
sendto(sd,msg,sizeof(msg),0,(struct sockaddr *)&cl,len);
while(read(sd,&buf,sizeof(buf),0)>0)
{
fputs(buf,stdout);
}
close(sd);
}

//UDP Server Chargen
#include<stdio.h>
#include<netdb.h>
int main()
{
int sd,i;
char buf[72],a[100];
buf[0]='n';
char c=' ';
struct sockaddr_in sr,cl;
if(sd<0)
printf("Error in socket");
sr.sin_family=AF_INET;
sr.sin_port=3000;
sr.sin_addr.s_addr=inet_addr("127.0.0.1");
bind(sd,(struct sockaddr *)&sr,sizeof(sr));
listen(sd,2);
int len=sizeof(cl);
recvfrom(sd,&a,sizeof(a),0,(struct sockaddr *)&cl,&len);
printf("Msg from client=%s",a);
for(i=1;i<=73;i++)
{
buf[i]=c++;
//fputs(buf,stdout);
sendto(sd,buf,sizeof(buf),0,(struct sockaddr *)&cl,len);
}
fputs(buf,stdout);
close(sd);
}

// Daytime Client UDP
#include<stdio.h>
#include<netdb.h>
int main()
{
int sd;
char buf[500];
char r[50];
struct sockaddr_in ser;
ser.sin_family=AF_INET;
ser.sin_port=6767;
ser.sin_addr.s_addr=inet_addr("127.0.0.1");
int l=sizeof(ser);
sendto(sd,"hello",10,0,(struct sockaddr *)&ser,l);
recvfrom(sd,buf,sizeof(buf),0,(struct sockaddr *)&ser,&l);
fputs(buf,stdout);
close(sd);
}

//Daytime server UDP
#include<stdio.h>
#include<netdb.h>
#include<string.h>
int main()
{
int sd;
time_t now;
char buf[500];
char r[50];
struct sockaddr_in ser;
ser.sin_family=AF_INET;
ser.sin_port=6767;
ser.sin_addr.s_addr=inet_addr("127.0.0.1");
bind(sd,(struct sockaddr *)&ser,sizeof(ser));
listen(sd,3);
int l=sizeof(ser);
recvfrom(sd,buf,sizeof(buf),0,(struct sockaddr *)&ser,&l);
printf("n client msg:%s",buf);
time(&now);
fputs(ctime(&now),stdout);
strcpy(r,ctime(&now));
sendto(sd,r,50,0,(struct sockaddr *)&ser,l);
close(sd);
}

//UDP Palindrome Server
#include<stdio.h>
#include<netdb.h>
#include<string.h>
int main()
{
int sd,csd;
int i,f=0;
char buf[100];
struct sockaddr_in server,client;
sd=socket(PF_INET,SOCK_STREAM,0);
if(sd<0)
printf("n Error in Socket ");
server.sin_port=4545;
bind(sd,(struct sockaddr *)&server,sizeof(server));
listen(sd,3);
int len1=sizeof(server);
csd=accept(sd,(struct sockaddr *)&client,&len1);
recv(csd,buf,100,0);
printf("n String is recieved from client => %s n ",buf);
int len=strlen(buf);
for(i=0;i<len;i++)
{
if(buf[i]!= buf[len-i-1])
{
f=1;
break;
}
}
if(f==0)
{
send(csd,"String is pallindrom",100,0);
}
else
{
send(csd,"String is not pallindrom",100,0);
}
close(csd);
}

//UDP Palindrome Client
#include<stdio.h>
#include<netdb.h>
int main()
{
int sd;
char buf[100];
char buf1[100];
struct sockaddr_in_server;
sd=socket(PF_INET,SOCK_STREAM,0);
if(sd<0)
printf("n Error in Socket ");
server.sin_port=4545;
connect(sd,(struct sockaddr *)&server,sizeof(server));
if(sd==0)
printf("n Connect..... ");
printf("n Enter the String => ");
scanf("%s" , &buf1);
send(sd,buf1,100,0);
recv(sd,buf,100,0);
printf(" %s", buf);
close(sd);
}

UDP.yash

Recommended

Recommended

More Related Content

Similar to UDP.yash

Similar to UDP.yash (20)

More from Yashpatel821746

More from Yashpatel821746 (6)

Recently uploaded

Recently uploaded (20)

UDP.yash