C Codes: code

Showing posts with label code. Show all posts

Thursday, 21 March 2013

udp server client

#include<stdio.h>

#include<sys/types.h>

#include<sys/socket.h>

#include<netinet/in.h>

#include<string.h>

int main(int argc,char **argv){

if(argc<2)

{

printf("insuffcient parameters");

exit(0);

}

struct sockaddr_in servsock;

int sockfd,size;

char msg[1024],str[1024];

if((sockfd=socket(AF_INET,SOCK_DGRAM,0))<0) {

perror("");

exit(0); }

printf("socket created\n");

size=sizeof(struct sockaddr);

socklen_t len=sizeof(servsock);

bzero(&servsock,size);

servsock.sin_port=htons(3000);

servsock.sin_family=AF_INET;

servsock.sin_addr.s_addr=inet_addr(argv[1]);

if(strcmp(msg,"bye")==0)

exit(0);

while(strcmp(msg,"bye")!=0)

{ printf("\n client: ");

scanf("%s",msg);

if((sendto(sockfd,msg,sizeof(msg),0,(struct sockaddr*)&servsock,len))<0)

{perror("not send");

exit(0); }

if(strcmp(msg,"bye")==0)

exit(0);

printf("\n from server: ");

if((recvfrom(sockfd,str,1024,0,NULL,NULL))<0)

{

perror("not received");

exit(0); }

printf("%s",str);

}

close(sockfd);

return 0;

}

Server Side:-

//server program

#include<stdio.h>

#include<sys/types.h>

#include<sys/socket.h>

#include<netinet/in.h>

#include<string.h>

int main(int argc,char **argv)

{

struct sockaddr_in mysock,newsock;

int sockfd;

char buf[1024];

int size,val;

if((sockfd=socket(AF_INET,SOCK_DGRAM,0))<0){

perror("no socket");

exit(0);}

size=sizeof(struct sockaddr);

socklen_t len=sizeof(newsock);

bzero(&mysock,size);

mysock.sin_family=AF_INET;

mysock.sin_port=htons(3000);

mysock.sin_addr.s_addr=htonl(INADDR_ANY);

if((bind(sockfd,(struct sockaddr*)&mysock,size))<0){

perror("no bind");

exit(0);}

if(strcmp(buf,"bye")==0)

exit(0);

while(strcmp(buf,"bye")!=0)

{

if((val=recvfrom(sockfd,buf,1024,0,(struct sockaddr*)&newsock,&len))<0){

perror(" ");

exit(0);}

printf("\n from client: ");

printf("%s",buf);

if(strcmp(buf,"bye")==0){

printf("\nserver: ");

scanf("%s",buf);

exit(0);}

printf("\n server: ");

scanf("%s",buf);

if((sendto(sockfd,buf,val,0,(struct sockaddr*)&newsock,len))<0){

perror("\n no send");

exit(0);}

}

close(sockfd);

return 0;

}

ping using tcp ip

Server.c

#include <unistd.h>

#include <stdio.h>

#include <sys/socket.h>

#include <netinet/ip.h>

#include <netinet/tcp.h>

// Packet length

#define PCKT_LEN 8192

// May create separate header file (.h) for all

// headers' structures

// IP header's structure

struct ipheader {

unsigned char iph_ihl:5,

iph_ver:4;

unsigned char iph_tos;

unsigned short int iph_len;

unsigned short int iph_ident;

unsigned char iph_flags;

unsigned short int iph_offset;

unsigned char iph_ttl;

unsigned char iph_protocol;

unsigned short int iph_chksum;

unsigned int iph_sourceip;

unsigned int iph_destip;

};

/* Structure of a TCP header */

struct tcpheader {

unsigned short int tcph_srcport;

unsigned short int tcph_destport;

unsigned int tcph_seqnum;

unsigned int tcph_acknum;

unsigned char tcph_reserved:4, tcph_offset:4;

// unsigned char tcph_flags;

unsigned int

tcp_res1:4, /*little-endian*/

tcph_hlen:4, /*length of tcp header in 32-bit words*/

tcph_fin:1, /*Finish flag "fin"*/

tcph_syn:1, /*Synchronize sequence numbers to start a connection*/

tcph_rst:1, /*Reset flag */

tcph_psh:1, /*Push, sends data to the application*/

tcph_ack:1, /*acknowledge*/

tcph_urg:1, /*urgent pointer*/

tcph_res2:2;

unsigned short int tcph_win;

unsigned short int tcph_chksum;

unsigned short int tcph_urgptr;

};

// Simple checksum function, may use others such as Cyclic Redundancy Check, CRC

unsigned short csum(unsigned short *buf, int len)

{

unsigned long sum;

for(sum=0; len>0; len--)

sum += *buf++;

sum = (sum >> 16) + (sum &0xffff);

sum += (sum >> 16);

return (unsigned short)(~sum);

}

int main(int argc, char *argv[])

{

int sd;

// No data, just datagram

char buffer[PCKT_LEN];

// The size of the headers

struct ipheader *ip = (struct ipheader *) buffer;

struct tcpheader *tcp = (struct tcpheader *) (buffer + sizeof(struct ipheader));

struct sockaddr_in sin, din;

int one = 1;

const int *val = &one;

memset(buffer, 0, PCKT_LEN);

if(argc != 5)

{

printf("- Invalid parameters!!!\n");

printf("- Usage: %s <source hostname/IP> <source port> <target hostname/IP> <target port>\n", argv[0]);

exit(-1);

}

sd = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);

if(sd < 0)

{

perror("socket() error");

exit(-1);

}

else

printf("socket()-SOCK_RAW and tcp protocol is OK.\n");

// The source is redundant, may be used later if needed

// Address family

sin.sin_family = AF_INET;

din.sin_family = AF_INET;

// Source port, can be any, modify as needed

sin.sin_port = htons(atoi(argv[2]));

din.sin_port = htons(atoi(argv[4]));

// Source IP, can be any, modify as needed

sin.sin_addr.s_addr = inet_addr(argv[1]);

din.sin_addr.s_addr = inet_addr(argv[3]);

// IP structure

ip->iph_ihl = 5;

ip->iph_ver = 4;

ip->iph_tos = 16;

ip->iph_len = sizeof(struct ipheader) + sizeof(struct tcpheader);

ip->iph_ident = htons(54321);

ip->iph_offset = 0;

ip->iph_ttl = 64;

ip->iph_protocol = 6; // TCP

ip->iph_chksum = 0; // Done by kernel

// Source IP, modify as needed, spoofed, we accept through command line argument

ip->iph_sourceip = inet_addr(argv[1]);

// Destination IP, modify as needed, but here we accept through command line argument

ip->iph_destip = inet_addr(argv[3]);

// The TCP structure. The source port, spoofed, we accept through the command line

tcp->tcph_srcport = htons(atoi(argv[2]));

// The destination port, we accept through command line

tcp->tcph_destport = htons(atoi(argv[4]));

tcp->tcph_seqnum = htonl(1);

tcp->tcph_acknum = 0;

tcp->tcph_offset = 5;

tcp->tcph_syn = 1;

tcp->tcph_ack = 0;

tcp->tcph_win = htons(32767);

tcp->tcph_chksum = 0; // Done by kernel

tcp->tcph_urgptr = 0;

// IP checksum calculation

ip->iph_chksum = csum((unsigned short *) buffer, (sizeof(struct ipheader) + sizeof(struct tcpheader)));

// Inform the kernel do not fill up the headers' structure, we fabricated our own

if(setsockopt(sd, IPPROTO_IP, IP_HDRINCL, val, sizeof(one)) < 0)

{

perror("setsockopt() error");

exit(-1);

}

else

printf("setsockopt() is OK\n");

printf("Using:::::Source IP: %s port: %u, Target IP: %s port: %u.\n", argv[1], atoi(argv[2]), argv[3], atoi(argv[4]));

// sendto() loop, send every 2 second for 50 counts

unsigned int count;

for(count = 0; count < 20; count++)

{

if(sendto(sd, buffer, ip->iph_len, 0, (struct sockaddr *)&sin, sizeof(sin)) < 0)

// Verify

{

perror("sendto() error");

exit(-1);

}

else

printf("Count #%u - sendto() is OK\n", count);

sleep(2);

}

close(sd);

return();
}

oprand aperator result server client

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <errno.h>

#include <string.h>

#include <sys/types.h>

//#include <time.h>

#include <pthread.h>

int main(int argc, char *argv[])

{

int listenfd = 0, connfd = 0, i = 0;

struct sockaddr_in serv_addr;

listenfd = socket(AF_INET, SOCK_STREAM, 0);

memset(&serv_addr, '0', sizeof(serv_addr));

serv_addr.sin_family = AF_INET;

serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);

serv_addr.sin_port = htons(atoi(argv[1]));

if(bind(listenfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1)

{

printf("bind error\n");

close(listenfd);

return 1;

}

listen(listenfd, 10);

while(1)

{

if((connfd = accept(listenfd,(struct sockaddr *)NULL, NULL))==-1)

{

printf("Invalid connection\n");

continue;

}

printf("accepted connection\n");

char sendBuff[10],op,op1[4],op2[4];

//time_t ticks;

int a=0,b=0;

//sleep(5);

read(connfd, sendBuff, sizeof(sendBuff));

op = sendBuff[0];

//printf("%c",op);

read(connfd, op1, sizeof(op1));

a = atoi(op1);

read(connfd, op2, sizeof(op2));

b = atoi(op2);

printf("%d %c %d\n",a,op,b);

//ticks = time(NULL);

switch(op)

{

case '+': a = a + b;

break;

case '-': a = a - b;

break;

case '*': a = a * b;

break;

case '/': a = a / b;

break;

case '%': a = a % b;

}

snprintf(sendBuff, sizeof(sendBuff), "%d", a);

write(connfd, sendBuff, strlen(sendBuff));

close(connfd);

}

close(listenfd);

return 0;

}

Client Side:

#include <sys/socket.h>

#include <sys/types.h>

#include <netinet/in.h>

#include <netdb.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <unistd.h>

#include <errno.h>

#include <arpa/inet.h>

int main(int argc, char *argv[])

{

int sockfd = 0, n = 0;

char recvBuff[1024],op,op1[4],op2[4];

struct sockaddr_in serv_addr;

if(argc != 3)

{

printf("\n Usage: %s <ip of server> <port>\n",argv[0]);

return 1;

}

memset(recvBuff, '0',sizeof(recvBuff));

if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)

{

printf("\n Error : Could not create socket \n");

return 1;

}

memset(&serv_addr, '0', sizeof(serv_addr));

serv_addr.sin_family = AF_INET;

serv_addr.sin_port = htons(atoi(argv[2]));

if(inet_pton(AF_INET, argv[1], &serv_addr.sin_addr)<=0)

{

printf("\n inet_pton error occured\n");

return 1;

}

if( connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)

{

printf("\n Error : Connect Failed \n");

return 1;

}

printf("Enter operator : ");

scanf("%c", &op);

write(sockfd, &op,1);

printf("Enter operands : ");

scanf("%s%s",op1,op2);

write(sockfd, op1, strlen(op1));

write(sockfd, op2, strlen(op2));

printf("Result : ");

while ( (n = read(sockfd, recvBuff, sizeof(recvBuff)-1)) > 0)

{

recvBuff[n] = 0;

if(fputs(recvBuff, stdout) == EOF)

{

printf("\n Error : Fputs error\n");

}

printf("\n");

}

if(n < 0)

{

printf("\n Read error \n");

}

return 0;

}