Você está na página 1de 13

authenticate the client s Username and Password.

Program at Server Side


#include (stdio.h)
#include (stdlib.h)
#include (unistd.h)
#include (errno.h)
#include (string.h)
#include (netdb.h)
#include (sys/types.h)
#include (netinet/in.h)
#include (sys/socket.h)
#include (arpa/inet.h)
int main(int argc, char *argv[])
{
int sock_des,port,n1,n2,s1,s2;
char buffer1[100],buffer2[100],buffer3[100],buffer4[100];
int length,new_des;
struct sockaddr_in server_addr,client_addr;
bzero(buffer3,sizeof(buffer3));
printf( \n Input Authentic Username :\n );
scanf( %s ,buffer3);
bzero(buffer4,sizeof(buffer4));
printf( \n Input Authentic Password :\n );
scanf( %s ,buffer4);
if(argc!=2)
{
printf( Usage: ./server port\n );
exit(1);
}
port= atoi(argv[1]);
if((sock_des=socket(AF_INET,SOCK_STREAM,0))==-1)

{
perror( socket );
exit(1);
}
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(port);
server_addr.sin_addr.s_addr= htonl(INADDR_ANY);
if (bind(sock_des,(const struct sockaddr *)&server_addr,sizeof(struct sockaddr))
==-1)
{
perror( bind );
exit(1);
}
if( listen(sock_des,5)==-1)
{
perror( listen );
exit(1);
}
printf( Server is listening at port %d \n , port);
while(1)
{
if((new_des=accept(sock_des,(struct sockaddr *)&client_addr,&length))==-1)
{
perror( accept );
exit(1);
}
bzero(buffer1,sizeof(buffer1));
n1=read(new_des,buffer1,sizeof(buffer1));
buffer1[n1]= null character ;
if((s1=strcmp(buffer1,buffer3))==0)

{
write(new_des, Username Match!Enter Password ,30);
printf( Username Match !!!\n );
bzero(buffer2,sizeof(buffer2));
n2=read(new_des,buffer2,sizeof(buffer2));
buffer2[n2]= null character ;
if((s2=strcmp(buffer2,buffer4))==0)
{
write(new_des, Password Match ,15);
printf( Password Match !!!\n );
}
else
{
write(new_des, Password NOT Match ,19);
printf( Password NOT Match !!!\n );
}
}
else
{
write(new_des, Username Not Match ,19);
printf( Username Not Match !!!\n );
}
close(new_des);
}
}
OUTPUT:
shaunak@shaunak-desktop:~/networks/exe2$ ./a.out 54204
Input Authentic Username :
shaunak
Input Authentic Password :
shru
Server is listening at port 54204

Username Match !!!


Password Match !!!

Program at Client Side


#include (stdio.h)
#include (stdlib.h)
#include (unistd.h)
#include (errno.h)
#include (string.h)
#include (netdb.h)
#include (sys/types.h)
#include (netinet/in.h)
#include (sys/socket.h)
#include (arpa/inet.h)
int main(int argc,char *argv[])
{
int sock_des,port,n;
struct hostent *host;
char buffer1[100],buffer2[100],buffer3[100],buffer4[100];
struct sockaddr_in server_addr;
if(argc!=3)
{
printf( Usage: ./client hostname port\n );
exit(1);
}
if((host=gethostbyname(argv[1]))==NULL)
{
printf( Unknown Host\n );
exit(1);
}

port = atoi(argv[2]);
if((sock_des=socket(AF_INET,SOCK_STREAM,0))==-1)
{
perror( socket );
exit(1);
}
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(port);
server_addr.sin_addr = *((struct in_addr *)host->h_addr);
if(connect(sock_des,(struct sockaddr *)&server_addr,sizeof(struct sockaddr))==-1
)
{
perror( connect );
exit(1);
}
bzero(buffer1,sizeof(buffer1));
printf( Enter the Username :\n );
scanf( %s ,buffer1);
write(sock_des,buffer1,sizeof(buffer1));
bzero(buffer4,sizeof(buffer4));
n=read(sock_des,buffer4,sizeof(buffer4));
buffer4[n]= null character ;
printf( Server Sent : %s\n , buffer4);
bzero(buffer2,sizeof(buffer2));
printf( Enter the Password :\n );
scanf( %s ,buffer2);
write(sock_des,buffer2,sizeof(buffer2));
bzero(buffer3,sizeof(buffer3));
n=read(sock_des,buffer3,sizeof(buffer3));
buffer3[n]= null character ;
printf( Server Sent : %s\n , buffer3);

close(sock_des);
}
OUTPUT:
shaunak@shaunak-desktop:~/networks/exe2$ ./a.out
Enter the Username :
shaunak
Server Sent : Username Match!Enter Password
Enter the Password :
shru
Server Sent : Password Match
File Transfer Using TCP in C
filetransferserver.c
#include<stdio.h>
#include<sys/types.h>
#include<string.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<unistd.h>
#define SA struct sockaddr
#define LISTENQ 5
int main(int argc,char**argv)
{
int fd,sockfd,listenfd,connfd;
pid_t childpid;
socklen_t client;
struct sockaddr_in servaddr,cliaddr;
listenfd=socket(AF_INET,SOCK_STREAM,0);
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
servaddr.sin_port=htons(atoi(argv[1]));
bind(listenfd,(SA*)&servaddr,sizeof(servaddr));
listen(listenfd,LISTENQ);
client=sizeof(cliaddr);
connfd=accept(listenfd,(SA*)&cliaddr,&client);
char buffer[100];
FILE *fp;
read(connfd,buffer,100);
fp=fopen("add1.txt","w");
fprintf(fp,"%s",buffer);
printf("the file was received successfully");
printf("the new file created is add1.txt");
}
filetransferclient.c
#include<arpa/inet.h>
#include<unistd.h>
#define SA struct sockaddr
int main(int argc,char**argv)

shaunak-desktop

54204

{
int sockfd;
char fname[25];
int len;
struct sockaddr_in servaddr,cliaddr;
sockfd=socket(AF_INET,SOCK_STREAM,0);
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
servaddr.sin_port=htons(atoi(argv[1]));
inet_pton(AF_INET,argv[1],&servaddr.sin_addr);
connect(sockfd,(SA*)&servaddr,sizeof(servaddr));
char buffer[100];
FILE *f;
f=fopen("add.txt","r");
fscanf(f,"%s",buffer);
write(sockfd,buffer,100);
printf("the file was sent successfully");
}
CHAT PROGRAM
tcpserver.c
#include"stdio.h"
#include"stdlib.h"
#include"sys/types.h"
#include"sys/socket.h"
#include"string.h"
#include"netinet/in.h"
#include"pthread.h"
#define PORT 4444
#define BUF_SIZE 2000
#define CLADDR_LEN 100
void * receiveMessage(void * socket) {
int sockfd, ret;
char buffer[BUF_SIZE];
sockfd = (int) socket;
memset(buffer, 0, BUF_SIZE);
for (;;) {
ret = recvfrom(sockfd, buffer, BUF_SIZE, 0, NULL, NULL);
if (ret < 0) {
printf("Error receiving data!\n");
} else {
printf("client: ");
fputs(buffer, stdout);
//printf("\n");
}
}
}
void main() {
struct sockaddr_in addr, cl_addr;
int sockfd, len, ret, newsockfd;
char buffer[BUF_SIZE];
pid_t childpid;
char clientAddr[CLADDR_LEN];
pthread_t rThread;
sockfd = socket(AF_INET, SOCK_STREAM, 0);

if (sockfd < 0) {
printf("Error creating socket!\n");
exit(1);
}
printf("Socket created...\n");
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = PORT;
ret = bind(sockfd, (struct sockaddr *) &addr, sizeof(addr));
if (ret < 0) {
printf("Error binding!\n");
exit(1);
}
printf("Binding done...\n");
printf("Waiting for a connection...\n");
listen(sockfd, 5);
len = sizeof(cl_addr);
newsockfd = accept(sockfd, (struct sockaddr *) &cl_addr, &len);
if (newsockfd < 0) {
printf("Error accepting connection!\n");
exit(1);
}
inet_ntop(AF_INET, &(cl_addr.sin_addr), clientAddr, CLADDR_LEN);
printf("Connection accepted from %s...\n", clientAddr);
memset(buffer, 0, BUF_SIZE);
printf("Enter your messages one by one and press return key!\n");
//creating a new thread for receiving messages from the client
ret = pthread_create(&rThread, NULL, receiveMessage, (void *) newsockfd);
if (ret) {
printf("ERROR: Return Code from pthread_create() is %d\n", ret);
exit(1);
}
while (fgets(buffer, BUF_SIZE, stdin) != NULL) {
ret = sendto(newsockfd, buffer, BUF_SIZE, 0, (struct sockaddr *) &cl_addr, len
);
if (ret < 0) {
printf("Error sending data!\n");
exit(1);
}
}
close(newsockfd);
close(sockfd);
pthread_exit(NULL);
return;
}
tcpclient.c
#include"stdio.h"

#include"stdlib.h"
#include"sys/types.h"
#include"sys/socket.h"
#include"string.h"
#include"netinet/in.h"
#include"netdb.h"
#include"pthread.h"
#define PORT 4444
#define BUF_SIZE 2000
void * receiveMessage(void * socket) {
int sockfd, ret;
char buffer[BUF_SIZE];
sockfd = (int) socket;
memset(buffer, 0, BUF_SIZE);
for (;;) {
ret = recvfrom(sockfd, buffer, BUF_SIZE, 0, NULL, NULL);
if (ret < 0) {
printf("Error receiving data!\n");
} else {
printf("server: ");
fputs(buffer, stdout);
//printf("\n");
}
}
}
int main(int argc, char**argv) {
struct sockaddr_in addr, cl_addr;
int sockfd, ret;
char buffer[BUF_SIZE];
char * serverAddr;
pthread_t rThread;
if (argc < 2) {
printf("usage: client < ip address >\n");
exit(1);
}
serverAddr = argv[1];
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
printf("Error creating socket!\n");
exit(1);
}
printf("Socket created...\n");
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = inet_addr(serverAddr);
addr.sin_port = PORT;
ret = connect(sockfd, (struct sockaddr *) &addr, sizeof(addr));
if (ret < 0) {
printf("Error connecting to the server!\n");
exit(1);
}
printf("Connected to the server...\n");

memset(buffer, 0, BUF_SIZE);
printf("Enter your messages one by one and press return key!\n");
//creating a new thread for receiving messages from the server
ret = pthread_create(&rThread, NULL, receiveMessage, (void *) sockfd);
if (ret) {
printf("ERROR: Return Code from pthread_create() is %d\n", ret);
exit(1);
}
while (fgets(buffer, BUF_SIZE, stdin) != NULL) {
ret = sendto(sockfd, buffer, BUF_SIZE, 0, (struct sockaddr *) &addr, sizeof(ad
dr));
if (ret < 0) {
printf("Error sending data!\n\t-%s", buffer);
}
}
close(sockfd);
pthread_exit(NULL);
return 0;
}
terminal 1
gcc tcpserver.c -o server -pthread
./server
terminal 2
gcc tcpclient.c -o client -pthread
./client 192.168.0.4
ECHO UDP
SERVER
#include
#include
#include
#include
#include
#include

<arpa/inet.h>
<netinet/in.h>
<stdio.h>
<sys/types.h>
<sys/socket.h>
<unistd.h>

#define BUFLEN 512


#define NPACK 10
#define PORT 9930
void diep(char *s)
{
perror(s);
exit(1);
}
int main(void)
{
struct sockaddr_in si_me, si_other;
int s, i, slen=sizeof(si_other);
char buf[BUFLEN];
if ((s=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1)
diep("socket");

memset((char *) &si_me, 0, sizeof(si_me));


si_me.sin_family = AF_INET;
si_me.sin_port = htons(PORT);
si_me.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(s, &si_me, sizeof(si_me))==-1)
diep("bind");
for (i=0; i<NPACK; i++) {
if (recvfrom(s, buf, BUFLEN, 0, &si_other, &slen)==-1)
diep("recvfrom()");
printf("Received packet from %s:%d\nData: %s\n\n",
inet_ntoa(si_other.sin_addr), ntohs(si_other.sin_port), buf);
}
close(s);
return 0;
}
CLIENT
#define SRV_IP "999.999.999.999"
/* diep(), #includes and #defines like in the server */
int main(void)
{
struct sockaddr_in si_other;
int s, i, slen=sizeof(si_other);
char buf[BUFLEN];
if ((s=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1)
diep("socket");
memset((char *) &si_other, 0, sizeof(si_other));
si_other.sin_family = AF_INET;
si_other.sin_port = htons(PORT);
if (inet_aton(SRV_IP, &si_other.sin_addr)==0) {
fprintf(stderr, "inet_aton() failed\n");
exit(1);
}
for (i=0; i<NPACK; i++) {
printf("Sending packet %d\n", i);
sprintf(buf, "This is packet %d\n", i);
if (sendto(s, buf, BUFLEN, 0, &si_other, slen)==-1)
diep("sendto()");
}
close(s);
return 0;
}
message transfer from client to server process using UDP
SERVER
#include
#include
#include
#include
#include

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

int main(){
int udpSocket, nBytes;
char buffer[1024];
struct sockaddr_in serverAddr, clientAddr;
struct sockaddr_storage serverStorage;
socklen_t addr_size, client_addr_size;
int i;
/*Create UDP socket*/
udpSocket = socket(PF_INET, SOCK_DGRAM, 0);
/*Configure settings in address struct*/
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(7891);
serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
memset(serverAddr.sin_zero, '\0', sizeof serverAddr.sin_zero);
/*Bind socket with address struct*/
bind(udpSocket, (struct sockaddr *) &serverAddr, sizeof(serverAddr));
/*Initialize size variable to be used later on*/
addr_size = sizeof serverStorage;
while(1){
/* Try to receive any incoming UDP datagram. Address and port of
requesting client will be stored on serverStorage variable */
nBytes = recvfrom(udpSocket,buffer,1024,0,(struct sockaddr *)&serverStorage,
&addr_size);
/*Convert message received to uppercase*/
for(i=0;i<nBytes-1;i++)
buffer[i] = toupper(buffer[i]);
/*Send uppercase message back to client, using serverStorage as the address*
/
sendto(udpSocket,buffer,nBytes,0,(struct sockaddr *)&serverStorage,addr_size
);
}
return 0;
}
CLIENT
#include
#include
#include
#include

<stdio.h>
<sys/socket.h>
<netinet/in.h>
<string.h>

int main(){
int clientSocket, portNum, nBytes;
char buffer[1024];
struct sockaddr_in serverAddr;
socklen_t addr_size;
/*Create UDP socket*/
clientSocket = socket(PF_INET, SOCK_DGRAM, 0);
/*Configure settings in address struct*/

serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(7891);
serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
memset(serverAddr.sin_zero, '\0', sizeof serverAddr.sin_zero);
/*Initialize size variable to be used later on*/
addr_size = sizeof serverAddr;
while(1){
printf("Type a sentence to send to server:\n");
fgets(buffer,1024,stdin);
printf("You typed: %s",buffer);
nBytes = strlen(buffer) + 1;
/*Send message to server*/
sendto(clientSocket,buffer,nBytes,0,(struct sockaddr *)&serverAddr,addr_size
);
/*Receive message from server*/
nBytes = recvfrom(clientSocket,buffer,1024,0,NULL, NULL);
printf("Received from server: %s\n",buffer);
}
return 0;
}

Você também pode gostar