Networks

OSI

#include<stdio.h>
#include<string.h>
int main()
{
    char temp[20],str[20];
    printf("Enter the string");
    scanf("%s",&str);
    printf("transmitter");
    strcpy(temp,str);
    printf("Application layer: ");
    strcpy(temp,"AL");
    strcat(temp,str);
    printf("%s",temp);
    printf("Presentation Layer");
    strcpy(temp,"PL");
    strcat(temp,str);
    printf("%s\nSession Layer",temp);
    strcpy(temp,"SL");
    strcat(temp,str);
    printf("%s\ntransport layer",temp);
    strcpy(temp,"TL");
    strcat(temp,str);
    printf("%s\nNetwork layer",temp);
    strcpy(temp,"NL");
    strcat(temp,str);
    printf("%s\nData Link Layer",temp);
    strcpy(temp,"DLL");
    strcat(temp,str);
    printf("%s\nReceiver",temp);
    int i;
    printf("\nData Link Layer: ");
    for(i=0;i<strlen(str);i++)
    {printf("%c",str[i]);
    }
    printf("\nNetwork layer: ");
    for(i=4;i<strlen(str);i++)
    printf("%c",str[i]);
    printf("\nTransport layer: ");
        for(i=6;i<strlen(str);i++)
        {

    printf("%c",str[i]);}
    printf("\nSession layer: ");
    for(i=8;i<strlen(str);i++)
        {

    printf("%c",str[i]);}
    printf("\nPresentation layer: ");
        for(i=10;i<strlen(str);i++)
        {

    printf("%c",str[i]);}
    printf("\nApplication layer: ");
    for(i=12;i<strlen(str);i++)
    {printf("%c",str[i]);
    }
}

HAMMING CODE

#include<stdio.h>
int main() {
    int data[7],rec[7],i,c1,c2,c3,c;
    printf("this works for message of 4bits in size \nenter message bit one by one:  ");
    scanf("%d%d%d%d",&data[0],&data[1],&data[2],&data[4]);
    data[6]=data[0]^data[2]^data[4];
    data[5]=data[0]^data[1]^data[4];
    data[3]=data[0]^data[1]^data[2];
    printf("\nthe encoded bits are given below: \n");
    for (i=0;i<7;i++) {
        printf("%d ",data[i]);
    }
    printf("\nenter the received data bits one by one: ");
    for (i=0;i<7;i++) {
        scanf("%d",&rec[i]);
    }
    c1=rec[6]^rec[4]^rec[2]^rec[0];
    c2=rec[5]^rec[4]^rec[1]^rec[0];
    c3=rec[3]^rec[2]^rec[1]^rec[0];
    c=c3*4+c2*2+c1 ;
    if(c==0) {
        printf("\ncongratulations there is no error: ");
    } else {
        printf("\nerron on the postion: %d\nthe correct message is \n",c);
        if(rec[7-c]==0)
                    rec[7-c]=1; else
                    rec[7-c]=0;
        for (i=0;i<7;i++) {
            printf("%d ",rec[i]);
        }
    }
return 0;
}

CHARACTER COUNT

#include<stdio.h>
#include<string.h>
int main()
{
    int t[50],i,n;
    char s[50][50];
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        scanf("%s",s[i]);
    }
    for(i=0;i<n;i++)
    t[i]=strlen(s[i]);
    printf("The transmitted data is \n");
    for(i=0;i<n;i++)
    {
        printf("%d",t[i]+1);
        printf("%s",s[i]);
    }
}

BIT STUFFING

#include<stdio.h>
#include<conio.h>
#include<string.h>
void main() {
    int i, j,count=0,nl;
    char str[100];
    clrscr();
    printf("enter the bit string:  ");
    gets(str);
    for (i=0;i<strlen(str);i++) {
        count=0;
        //the following code search the six ones in given string
        for (j=i;j<=(i+5);j++) {
            if(str[j]=='1') {
                count++;
            }
        }
        //if there is six ones then folling code execute to bit stuffing after five ones
        if(count==6) {
            nl=strlen(str)+2;
            for (;nl>=(i+5);nl--) {
                str[nl]=str[nl-1];
            }
            str[i+5]='0';
            i=i+7;
        }
    }
    puts(str);
    getch();
}

BYTE STUFFING

#include<stdio.h>
#include<conio.h>
void main()
{
char frame[100],str[50][50];
char flag='z';
char esc='x';
int i,j,k=0,n;
frame[k++]='z';
printf("Enter no.of String ::\t");
scanf("%d",&n);
printf("Enter String \n");
for(i=0;i<=n;i++)
  {
gets(str[i]);
  }
printf("You entered ::\n");
for(i=0;i<=n;i++)
   {
puts(str[i]);
   }

printf("\n");
for(i=1;i<=n;i++)
  {
for(j=0;j<strlen(str[i]);j++)
      {
    if(str[i][j]!=flag&&str[i][j]!=esc)
    {
        frame[k++]=str[i][j];
    }
    else{
        frame[k++]='x';
        frame[k++]=str[i][j];
    }
      }
  }

frame[k++]='z';
frame[k++]='\0';
printf("------------------------------\n");
printf("Byte stuffing at sender side:\n\n");
printf("------------------------------\n");
for(i=0;i<k;i++)
  {
printf("%c",frame[i]);
  }
printf("\n------------------------------");
printf("\nByte stuffing at receiver side\n\n");
printf("------------------------------\n");
for(i=0;i<k;i++)
  {
if(frame[i]=='x'|| frame[i]=='z')
     {
i++;
     }
printf("%c",frame[i]);
  }
getch();
}

CHECKSUM

#include<stdio.h>
#include<math.h>

 int sender(int b[10],int k)
 {
            int checksum,sum=0,i;
            printf("\n****SENDER****\n");

            for(i=0;i<k;i++)
            sum+=b[i];
            printf("SUM IS: %d",sum);

        checksum=~sum;
        printf("\nSENDER's CHECKSUM IS:%d",checksum);
        return checksum;
}

int receiver(int c[10],int k,int scheck)
{
            int checksum,sum=0,i;
        printf("\n\n****RECEIVER****\n");
        for(i=0;i<k;i++)
            sum+=c[i];
        printf(" RECEIVER SUM IS:%d",sum);
        sum=sum+scheck;
        checksum=~sum;
        printf("\nRECEIVER's CHECKSUM IS:%d",checksum);
            return checksum;
  }
   main()
   {
        int a[10],i,m,scheck,rcheck;
        printf("\nENTER SIZE OF THE STRING:");
        scanf("%d",&m);
        printf("\nENTER THE ELEMENTS OF THE ARRAY:");
        for(i=0;i<m;i++)
        scanf("%d",&a[i]);
        scheck=sender(a,m);
        rcheck=receiver(a,m,scheck);
        if(rcheck==0)
            printf("\n\nNO ERROR IN TRANSMISSION\n\n");
        else
            printf("\n\nERROR DETECTED");
   }


CRC

#include <conio.h>
 #include <string.h>
 #include<stdio.h>
 void main()
 {
 int i,j,keylen,msglen;
 char input[100], key[30],temp[30],quot[100],rem[30],key1[30];
 printf("Enter Data: ");
 gets(input);
 printf("Enter Key: ");
 gets(key);
 keylen=strlen(key);
 msglen=strlen(input);
 strcpy(key1,key);
 for(i=0;i<keylen-1;i++)
 {
 input[msglen+i]='0';
 }
 for(i=0;i<keylen;i++)
 temp[i]=input[i];
 for(i=0;i<msglen;i++)
 {
 quot[i]=temp[0];
 if(quot[i]=='0')
 for(j=0;j<keylen;j++)
 key[j]='0';
 else
 for(j=0;j<keylen;j++)
 key[j]=key1[j];
 for(j=keylen-1;j>0;j--)
 {
 if(temp[j]==key[j])
 rem[j-1]='0';
 else
 rem[j-1]='1';
 }
 rem[keylen-1]=input[i+keylen];
 strcpy(temp,rem);
 }
 strcpy(rem,temp);
 printf("\nQuotient is ");
 for(i=0;i<msglen;i++)
 printf("%c",quot[i]);
 printf("\nRemainder is ");
 for(i=0;i<keylen-1;i++)
 printf("%c",rem[i]);
 printf("\nFinal data is: ");
 for(i=0;i<msglen;i++)
 printf("%c",input[i]);
 for(i=0;i<keylen-1;i++)
 printf("%c",rem[i]);
 getch();
 }

SLIDING WINDOW

#include<stdio.h>
#include<conio.h>
void main()
{
char sender[50],receiver[50];
int i,winsize;
 printf("\n ENTER THE WINDOWS SIZE : ");
scanf("%d",&winsize);
 printf("\n SENDER WINDOW IS EXPANDED TO STORE MESSAGE OR WINDOW \n");
 printf("\n ENTER THE DATA TO BE SENT: ");
fflush(stdin);
gets(sender);
for(i=0;i<winsize;i++)
receiver[i]=sender[i];
receiver[i]=NULL;
 printf("\n MESSAGE SEND BY THE SENDER:\n");
 puts(sender);
 printf("\n WINDOW SIZE OF RECEIVER IS EXPANDED\n");
 printf("\n ACKNOWLEDGEMENT FROM RECEIVER \n");
for(i=0;i<winsize;i++);
printf("\n ACK:%d",i);
 printf("\n MESSAGE RECEIVED BY RECEIVER IS : ");
 puts(receiver);
 printf("\n WINDOW SIZE OF RECEIVER IS SHRINKED \n");
getch();
}

CHAT APPLICATION

//server
#include<sys/types.h>
#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>
int main(int argc, char *argv[]){
int sockfd,newsockfd,clilen;
int port,n;
char buffer[256];
struct sockaddr_in serv_addr,cli_addr;
if(argc < 2){
 printf("No port provided!");
 exit(1);
}
sockfd = socket(AF_INET,SOCK_STREAM,0);
if(sockfd < 0){
 perror("Error during socet creation!");
 exit(2);
}
bzero((char*) &serv_addr, sizeof(serv_addr));
port = atoi(argv[1]);
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(port);
if(bind(sockfd,(struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0){
 perror("Error during binding!");
 exit(3);
}
listen(sockfd,5);
clilen = sizeof(cli_addr);
newsockfd = accept(sockfd,(struct sockaddr *) &cli_addr, &clilen);
if(newsockfd < 0){
 perror("Error on accept!");
 exit(4);
}
do{
 bzero(buffer,256);
 n = read(newsockfd,buffer,255);
 if(n < 0){
 perror("Error reading!");
 exit(5);
 }
 printf("Message is %s \n", buffer);
 bzero(buffer,256);
 fgets(buffer,255,stdin);
 n = write(newsockfd,buffer,255);
 if(n < 0){
 perror("Error in writing");
 exit(6);
 }
}while(1);
return 0;
}

//client
#include<sys/types.h>
#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<netdb.h>
int main(int argc, char *argv[]){
int sockfd,port,n;
struct sockaddr_in serv_addr;
struct hostent *server;
char buffer[256];
if(argc < 3){
 printf("usage %s hostname port\n",argv[0]);
 exit(1);
}
port = atoi(argv[2]);
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if(sockfd < 0){
 perror("Error during socket creation!");
 exit(2);
}
server = gethostbyname(argv[1]);
if(server == NULL){
 printf("No such host! \n");
 exit(3);
}
bzero((char*) &serv_addr,sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
bcopy((char*) server->h_addr,(char*)&serv_addr.sin_addr.s_addr,server->h_length);
serv_addr.sin_port = htons(port);
if(connect(sockfd,&serv_addr,sizeof(serv_addr)) < 0){
 perror("Error connecting!");
 exit(4);
}
do{
 printf("Enter message : ");
 bzero(buffer,256);
 fgets(buffer,255,stdin);
 n = write(sockfd,buffer,strlen(buffer));
 if(n < 0){
 perror("Error in Writing");
 exit(5);
 }
 bzero(buffer,256);
 n = read(sockfd,buffer,255);
 if(n < 0){
 perror("Error Reading");
 exit(6);
 }
 printf("%s \n",buffer);
}while(1);
return 0;
}

UDP FILE TRANSER

//server
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#define BUFLEN 512
#define PORT 9930
void err(char *s)
{
perror(s);
exit(1);
}
int main(int argc, char** argv)
{
struct sockaddr_in serv_addr;
int sockfd, i, slen=sizeof(serv_addr);
char buf[BUFLEN];
if(argc != 2)
{
printf("Usage : %s <Server-IP>\n",argv[0]);
exit(0);
}
if ((sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1)
err("socket");
bzero(&serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(PORT);
if (inet_aton(argv[1], &serv_addr.sin_addr)==0)
{
fprintf(stderr, "inet_aton() failed\n");
exit(1);
}
while(1)
{
printf("\nEnter data to send(Type exit and press enter to exit) : ");
scanf("%[^\n]",buf);
getchar();
if(strcmp(buf,"exit") == 0)
exit(0);
if (sendto(sockfd, buf, BUFLEN, 0, (struct sockaddr*)&serv_addr,
slen)==-1)
err("sendto()");
}
close(sockfd);
return 0;
}

//client
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#define BUFLEN 512
#define PORT 9930
void err(char *s)
{
perror(s);
exit(1);
}
int main(int argc, char** argv)
{
struct sockaddr_in serv_addr;
int sockfd, i, slen=sizeof(serv_addr);
char buf[BUFLEN];
if(argc != 2)
{
printf("Usage : %s <Server-IP>\n",argv[0]);
exit(0);
}
if ((sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1)
err("socket");
bzero(&serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(PORT);
if (inet_aton(argv[1], &serv_addr.sin_addr)==0)
{
fprintf(stderr, "inet_aton() failed\n");
exit(1);
}
while(1)
{
printf("\nEnter data to send(Type exit and press enter to exit) : ");
scanf("%[^\n]",buf);
getchar();
if(strcmp(buf,"exit") == 0)
exit(0);
if (sendto(sockfd, buf, BUFLEN, 0, (struct sockaddr*)&serv_addr,
slen)==-1)
err("sendto()");
}
close(sockfd);
return 0;
}

TCP/IP FILE TRANSFER

//server
#include<sys/types.h>
#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>
int main(int argc, char *argv[]){
int sockfd,newsockfd,clilen;
int port,n;
char buffer[1024];
struct sockaddr_in serv_addr,cli_addr;
if(argc < 2){
 printf("No port provided!");
 exit(1);
}
sockfd = socket(AF_INET,SOCK_STREAM,0);
if(sockfd < 0){
 perror("Error during socet creation!");
 exit(2);
}
bzero((char*) &serv_addr, sizeof(serv_addr));
port = atoi(argv[1]);
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(port);
if(bind(sockfd,(struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0){
 perror("Error during binding!");
 exit(3);
}
listen(sockfd,5);
clilen = sizeof(cli_addr);
newsockfd = accept(sockfd,(struct sockaddr *) &cli_addr, &clilen);
if(newsockfd < 0){
 perror("Error on accept!");
 exit(4);
}
//Full setup done.... server listening
FILE *fptr;
bzero(buffer,1024);
fptr = fopen("filemsg.txt","r");
if(fptr == NULL){
 printf("File open error!");
 exit(5);
}
fscanf(fptr,"%[^\n]",&buffer);
 printf("%s \n",buffer);
 n = write(newsockfd,buffer,1023);
 if(n < 0){
 perror("Error in writing");
 exit(6);
 }
 printf("String sent : %s \n",buffer);
printf("File sent!! \n");
fclose(fptr);
close(newsockfd);
//Process ends
return 0;
}
// client
#include<sys/types.h>
#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<netdb.h>
int main(int argc, char *argv[]){
int sockfd,port,n;
struct sockaddr_in serv_addr;
struct hostent *server;
char buffer[1024];
if(argc < 3){
 printf("usage %s hostname port\n",argv[0]);
 exit(1);
}
port = atoi(argv[2]);
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if(sockfd < 0){
 perror("Error during socket creation!");
 exit(2);
}
server = gethostbyname(argv[1]);
if(server == NULL){
 printf("No such host! \n");
 exit(3);
}
bzero((char*) &serv_addr,sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
bcopy((char*) server->h_addr,(char*)&serv_addr.sin_addr.s_addr,server->h_length);
serv_addr.sin_port = htons(port);
if(connect(sockfd,&serv_addr,sizeof(serv_addr)) < 0){
 perror("Error connecting!");
 exit(4);
}

FILE *fptr;
fptr = fopen("file1.txt","a");
if(fptr == NULL){
 printf("File error");
 exit(5);
}
bzero(buffer,1024);
 n = read(sockfd,buffer,1023);
 if(n < 0){
 perror("Error reading");
 exit(5);
 }
 fprintf(fptr,"%s",buffer);
printf("File recieved!!\n");
fclose(fptr);
return 0;
}

AUTHENTICATION 1

//server
#include<sys/types.h>
#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>
int main(int argc, char *argv[]){
int sockfd,newsockfd,clilen;
int port,n;
char actuser[256];
char actpass[256];
char user[256];
char pass[256];
struct sockaddr_in serv_addr,cli_addr;
if(argc < 2){
 printf("No port provided!");
 exit(1);
}
sockfd = socket(AF_INET,SOCK_STREAM,0);
if(sockfd < 0){
 perror("Error during socket creation!");
 exit(2);
}
bzero((char*) &serv_addr, sizeof(serv_addr));
port = atoi(argv[1]);
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(port);
if(bind(sockfd,(struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0){
 perror("Error during binding!");
 exit(3);
}
listen(sockfd,5);
clilen = sizeof(cli_addr);
newsockfd = accept(sockfd,(struct sockaddr *) &cli_addr, &clilen);
if(newsockfd < 0){
 perror("Error on accept!");
 exit(4);
}
printf("Enter actual username : ");
scanf("%s",&actuser);
printf("Enter actual password : ");
scanf("%s",&actpass);
n = write(newsockfd,"Enter username : ",17);
n = read(newsockfd,user,255);
user[strlen(user)] = '\0';
if(strcmp(user,actuser) == 10){
 n = write(newsockfd,"Enter password : ",17);
 n = read(newsockfd,pass,255);
 pass[strlen(pass)] = '\0';
 if(strcmp(pass,actpass) == 10){
 n = write(newsockfd,"Accepted!",9);
 printf("ACCEPT \n");
 }
 else{
 n = write(newsockfd,"Rejected!",9);
 printf("REJECT \n");
 close(newsockfd);
 }
}
else{
 n = write(newsockfd,"Rejected!",9);
 printf("REJECT\n");
 close(newsockfd);
}
return 0;
}

//client
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<netdb.h>
int main(int argc, char *argv[]){
int sockfd,port,n;
struct sockaddr_in serv_addr;
struct hostent *server;
char buffer[256];
char user[256];
char pass[256];
if(argc < 3){
 printf("usage %s hostname port\n",argv[0]);
 exit(1);
}
port = atoi(argv[2]);
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if(sockfd < 0){
 perror("Error during socket creation!");
 exit(2);
}
server = gethostbyname(argv[1]);
if(server == NULL){
 printf("No such host! \n");
 exit(3);
}
bzero((char*) &serv_addr,sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
bcopy((char*) server->h_addr,(char*)&serv_addr.sin_addr.s_addr,server->h_length);
serv_addr.sin_port = htons(port);
if(connect(sockfd,&serv_addr,sizeof(serv_addr)) < 0){
 perror("Error connecting!");
 exit(4);
}
bzero(buffer,256);
n = read(sockfd,buffer,255);
printf("%s",buffer);
bzero(user,256);
fgets(user,255,stdin);
n = write(sockfd,user,strlen(user));
bzero(buffer,256);
n = read(sockfd,buffer,255);
printf("%s",buffer);
bzero(pass,256);
fgets(pass,255,stdin);
n = write(sockfd,pass,strlen(pass));
bzero(buffer,256);
n = read(sockfd,buffer,255);
printf("%s\n",buffer);
return 0;
}

AUTHENTICATION 2

//client
#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("unknown host\n");
exit(1);
}
if((host=gethostbyname(argv[1]))==NULL)
{
printf("Unkown 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 username");
scanf("%s",buffer1);
write(sock_des,buffer1,sizeof(buffer1));
bzero(buffer4,sizeof(buffer4));
n=read(sock_des,buffer4,sizeof(buffer4));
buffer4[n]='\0';
printf("server sent:%s\n",buffer4);
bzero(buffer2,sizeof(buffer2));
printf("eneter passowrd\n");
scanf("%s",buffer2);
write(sock_des,buffer2,sizeof(buffer2));
bzero(buffer3,sizeof(buffer3));
buffer3[n]='\0';
printf("serever sent %s\n",buffer3);
close(sock_des);
}

//server
#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 password");
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("bind");
exit(1);
}
server_addr.sin_family=AF_INET;
server.addr.sin_port=htons(port);
server_addr.sin_addr.s_addr=hotnl(INADDR_ANY);
if(bind(sock_des,(conts 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 sock_addr*)&client_add,&length))=-1)
{
perroe("accept");
exit(1);
}
bzero(buffer1,sizeof(buffer1));
n1=read(new_des,buffer1,sizeof(buffer1));
buffer1[n1]='\0';
if((s1=strcmp(buffer1,buffer3))==0)
{
write(new_des," Username match \n enter password",30);
printf("username match\n");
bzero(buffer2,sizeof(buffer2));
buffer2[n2]='\0';
if((s2=strcmp(buffer2,buffer4))==0)
{
write(new_des,"password match",15);
}
else
{
write(new_des,"password not match",19);}
}
close(new_des);
}

ECHO

SERVER:
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<unistd.h>
#include<netdb.h>
#include<stdio.h>
#include<string.h>
#include<arpa/inet.h>
#define MAXLINE 1024
int main(int argc,char **argv)
{
int sockfd;
int n;
socklen_t len;
char msg[1024];
struct sockaddr_in servaddr,cliaddr;
sockfd=socket(AF_INET,SOCK_DGRAM,0);
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=INADDR_ANY;
servaddr.sin_port=htons(5035);
printf("\n\n Binded");
bind(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
printf("\n\n Listening...");
for(;;)
{
printf("\n ");
len=sizeof(cliaddr);
n=recvfrom(sockfd,msg,MAXLINE,0,(struct
sockaddr*)&cliaddr,&len);
printf("\n Client's Message : %s\n",msg);
if(n<6)
perror("send error");
sendto(sockfd,msg,n,0,(struct sockaddr*)&cliaddr,len);
}
return 0;
}
//CLIENT:
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<string.h>
#include<arpa/inet.h>
#include<string.h>
#include<arpa/inet.h>
#include<stdio.h>
#define MAXLINE 1024
int main(int argc,char* argv[])
{
int sockfd;
int n;
socklen_t len;
char sendline[1024],recvline[1024];
struct sockaddr_in servaddr;
strcpy(sendline,"");
printf("\n Enter the message : ");
scanf("%s",sendline);
sockfd=socket(AF_INET,SOCK_DGRAM,0);
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=inet_addr("127.0.0.1");
servaddr.sin_port=htons(5035);
connect(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
len=sizeof(servaddr);
sendto(sockfd,sendline,MAXLINE,0,(struct sockaddr*)&servaddr,len);
n=recvfrom(sockfd,recvline,MAXLINE,0,NULL,NULL);
recvline[n]=0;
printf("\n Server's Echo : %s\n\n",recvline);
return 0;
}