Program to demonstrate NON BLOCKING IO

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<fcntl.h>
#define BUFFSIZE 100
int main()
{
int n;
char buff[BUFFSIZE];
if(fcntl(0,F_SETFL,FNDELAY)<0)
{
perror("non blocking failed");
exit(0);
}
while(1)
{
while((n=read(0,buff,BUFFSIZE))<0)
{
if(errno!=EWOULDBLOCK) break;
}
fflush(stdout);
if(write(1,buff,n)<0)
{
perror("write");
break;
}
}
}
Program to copy standard input to standard output, using asynchronous I/O
#include <signal.h>
#include<fcntl.h>
#define BUFFSIZE 1024
int siflag;
main()
{
int n; char buff[BUFFSIZE]; int signal_handler();
signal(SIGIO, signal_handler);

if(fcntl(0, F_SETOWN, getpid())<0) {

perror( “fcntl error:”);
exit(-1);
}
if(fcntl(0,F_SETFL,FASYNC)<0) {
perror( “fcntl error:”);
exit(-1);
}
for(;;)
{
sigblock(sigmask(SIGIO));
while(sigflag==0)
sigpause(0); /* wait for a signal */
if( ( n=read(0, buff, BUFFSIZE))>0)
{
if(write(1,buff,n)!=n)
{
perror(“write error: “);
exit(-1);
}
sigflag=0; /* turn off our flag */
sigsetmask(0); /* and reenable signals */
}
}
int signal_handler() /* handler */
{
sigflag=1; /* just set flag and return */
}
Demonstrate the use of readv() and writev() system calls
#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<fcntl.h>
#include<sys/types.h>

main()
{
char buff1[20], buff2[20], buff3[20] , buff4[20] , buff5[20];
struct iovec inv[5];
char buff1_rd[20], buff2_rd [20], , buff3_rd [20] , buff4_rd [20] , buff5_rd [20];
struct iovec inv_rd[5];

printf(“\nEnter message1:”); scanf(“%s”,&buff1);

printf(“\nEnter message2:”); scanf(“%s”,&buff2);
printf(“\nEnter message3:”); scanf(“%s”,&buff3);
printf(“\nEnter message4:”); scanf(“%s”,&buff4);
printf(“\nEnter message5:”); scanf(“%s”,&buff5);

inv[0].iov_base=buff1;
inv[0].iov_len=sizeof(buff1);
inv[1].iov_base=buff2;
inv[1].iov_len=sizeof(buff2);
inv[2].iov_base=buff3;
inv[2].iov_len=sizeof(buff3);
inv[3].iov_base=buff4;
inv[3].iov_len=sizeof(buff4);
inv[4].iov_base=buff5;
inv[4].iov_len=sizeof(buff5);

int fd1=open(argv[1],O_WRONLY);
printf(“\nwriting the messages into the file…”);
writev(fd1, (struct iovec*)&iov,5);

inv_rd[0].iov_base=buff1_rd;
inv_rd [0].iov_len=sizeof(buff1_rd);
inv_rd [1].iov_base=buff2_rd;
inv_rd [1].iov_len=sizeof(buff2_rd);
inv_rd [2].iov_base=buff3_rd;
inv_rd [2].iov_len=sizeof(buff3_rd);
inv_rd [3].iov_base=buff4_rd;
inv_rd [3].iov_len=sizeof(buff4_rd);
inv_rd [4].iov_base=buff5_rd;
inv_rd [4].iov_len=sizeof(buff5_rd);

inf fd2=open(argv[1],O_RDONLY);

printf(“\nReading from the file into buffers…”)’;

readv(fd2, (struct iovec*)&inv_rd,5);

printf(“\nThe messages are: %s \t % %s \t %s \t %s \t %s \t %s\n”,buff1_rd,buff2_rd, buff3_rd,

buff4_rd, buff5_rd);
close(fd1);
close(fd2);
return 0;
}
Implement Time service & Day Time Service using RPC
DATE.x

program DATE_PROG
{
version DATE_VERS
{
long BIN_DATE(void)=1;
string STR_DATE(long)=2;
}=1;
}=0x31234567;

//Server
long *bin_date_1_svc(NULL)
{
static long timeval;
long time();
timeval = time((long *) 0);
return &timeval;
}
char **str_date_1_svc(long *lresult)
{
static char* time;
char* ctime();
time=ctime(lresult);
return &time;
}
//Client
#include<rpc/rpc.h>
#include"date.h"
main(int argc,char *argv[])
{
CLIENT *cl;
char **sresult;
long *lresult;
char *servername;
servername=argv[1];
cl=clnt_create(servername,DATE_PROG,DATE_VERS,"udp");
lresult=bin_date_1(NULL,cl);
sresult=str_date_1(lresult,cl);
printf("Time: %ld seconds\n",*lresult);
 printf("Date: %s\n",*sresult);
}
Implement Echo-Server using RPC
Echo.x:::

program ECHO_PROG
{
version ECHO_VERS
{
string STR_ECHO(string)=1;
}=1;
}=0x20000099;

//Server

char **str_echo_1_svc(char **str)

{
static char* s;
s=*str;
return &s;
}
//Client
#include<rpc/rpc.h>
#include<stdio.h>
#include"echo.h"
main(int argc,char *argv[])
{
CLIENT *cl;
int i=0;
char c;
char **echo;
char *str;
char *servername;
servername=argv[1];
cl=clnt_create(servername,ECHO_PROG,ECHO_VERS,"udp");
printf("\nEnter a string: ");
fgets(str, 256, stdin);
echo=str_echo_1(&str,cl);
printf("Echoed message: %s\n",*echo);
}
Implement Remote file access using RPC
File.x:::

program FILE_PROG
{
version FILE_VERS
{
string STR_FILE(string)=1;
}=1;
}=0x2000ffff;

//Server

#include<stdio.h>
#include<stdlib.h>
char **str_file_1_svc(char **str)
{
static char* s;
FILE *fp;
s=(char*)malloc(4096);
int i=0;
char c;
if((fp=fopen(*str,"r"))==NULL)
{
s="File not found!\n";
return &s;
}
while((c=fgetc(fp))!=EOF)
{
s[i]=c;
i++;
}
s[i]='\0';
fclose(fp);
return &s;
}

//Client

#include<rpc/rpc.h>
#include<stdio.h>
#include"file.h"
main(int argc,char *argv[])
{
CLIENT *cl;
int i=0,n;
char c;
char **buf;
char *str=(char*)malloc(20);
char *servername;
servername=argv[1];
cl=clnt_create(servername,FILE_PROG,FILE_VERS,"udp");
printf("\nEnter a file name: ");
scanf("%s",str);
buf=str_file_1(&str,cl);
printf("\n%s\n",*buf);
}
Demonstrate the use of advanced socket system calls getsockname(), getpeername()
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
int main(int argc,char *argv[])
{
int s,t,len; struct sockaddr_in local,rem;
s=socket(AF_INET,SOCK_STREAM,0);
if(s==-1)
{
perror("socket"); exit(1);
}

local.sin_family=AF_INET;
local.sin_port=htons(atoi(argv[1]));
local.sin_addr.s_addr=inet_addr(“172.16.0.1”);
if(bind(s,(struct sockaddr *)&local,sizeof(local))==-1)
{
perror("bind"); exit(1);
}
len=sizeof(name);
getsockname(sfd,(struct sockadd*)&local,&len);
// Local address
printf(“\n my local IP= %s \t and port=%d\n”,inet_ntoa(local.sin_addr),ntohs(local.sin_port));

listen(s,5);
s2=accept(s,(struct sockaddr *)&rem,&t);
if(s2==-1)
{
perror("accept"); exit(1);
}
//getpeername(sfd,(struct sockadd*)&rem,&len);
printf(“\n Remote IP= %s \t and port=%d\n”,inet_ntoa(rem.sin_addr),ntohs(rem.sin_port));

close(s2);
return 0;
}

Demonstrate the use of advanced socket system calls setsockopt(), getsockopt()

system calls

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<sys/socket.h>
#include<netinet/tcp.h>
int main()
{
        int sockfd,maxseg,sendbuff,optlen;
        if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0)
        {
                perror("socket");
                exit(0);
        }
        optlen=sizeof(maxseg);
        if(getsockopt(sockfd,IPPROTO_TCP,TCP_MAXSEG,(char *)&maxseg,&optlen)<0)
        {
                perror("get sockopt1");
                exit(0);
        }
        printf("\nTCP maxseg=%d",maxseg);
        sendbuff=12324;
        if(setsockopt(sockfd,SOL_SOCKET,SO_SNDBUF,(char *)&sendbuff,sizeof(sendbuff))<0)
        {
                perror("set socket opt");
                exit(0);
        }
        optlen=sizeof(sendbuff);
        if(getsockopt(sockfd,SOL_SOCKET,SO_SNDBUF,(char *)&sendbuff,&optlen)<0)
        {
                perror("get sockopt2");
                exit(0);
        }
        printf("\nsend buffer size=%d\n",sendbuff);
        return 0;
}
Implement remote command execution using sockets

//Rmdser.C

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <stdlib.h>
#define MAX 80
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
int main(int argc,char *argv[2])
{
int sfd,i,n,len,s,nsfd;
char buf[512];
time_t t;
struct sockaddr_in sa,ca;

if((sfd=socket(AF_INET, SOCK_STREAM,0))<0)
{
perror("socket error:");
exit(-1);
}
sa.sin_family=AF_INET;
sa.sin_port=htons(atoi(argv[1]));
sa.sin_addr.s_addr=htonl(INADDR_ANY);

if((bind(sfd,(struct sockaddr *)&sa,sizeof(sa)))<0)

{
perror("bind error:");
exit(-1);
}
listen(sfd,5);
len=sizeof(sa);
nsfd=accept(sfd,(struct sockaddr *)&ca,&len);
if(nsfd<0)
{
perror("Accept error:");
exit(-1);
 }
n=recv(nsfd,&buf,MAX,0);
// buf[n-1]='\0';
// strcat(buf2,buf);
// n=strlen(buf2);
buf[n]='\0';

printf("\nRecied IP=%s\n",buf);
printf("\n..... \n");
system(buf);
// n= send(nsfd,&t,sizeof(t),0);
// printf("\n%d bytes have been sent and t=%ld\n",n,t);
close(nsfd);
close(sfd);
return 0;
}

//Rmdcli.C

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <stdlib.h>
#define MAX 512
int main(int argc,char *argv[])
{
int sfd,n,len,s,nsfd,i;
char buf[512];time_t t;
struct sockaddr_in sa,ca;
if((sfd=socket(AF_INET, SOCK_STREAM,0))<0)
{
perror("socket error:");
exit(-1);
}
sa.sin_family=AF_INET;
sa.sin_port=htons(atoi(argv[1]));
sa.sin_addr.s_addr=inet_addr("172.16.0.1");
s=connect(sfd,(struct sockaddr *)&sa,sizeof(sa));
if(s<0)
{
perror("connect error:");
 exit(-1);
}
strcpy(buf,argv[2]);
n=send(sfd,&buf,strlen(buf),0);
printf("\n%d bytes sent..\n",n);
n=recv(sfd,&buf,MAX,0);
printf("\nclient received is:%s\n",buf);
close(sfd);
return 0;
}