Name- FATEH SINGH RAWAT

Subject- UNIX NETWORK

PROGRAMMING & SIMULATION
LAB

Branch- CSA2

Roll no.- 10EUDCS033

Year/Sem- IV Year, VIII Sem





INDEX
S.No. Experiment Date Remarks
1 Implement the following forms of IPC.
a)Pipes
b)FIFO



2 Implement file transfer using Message
Queue form of IPC



3 Write a program to create an integer variable
using shared memory concept and increment
the variable simultaneously by two
processes. Use semaphores to avoid race
conditions



4 Design TCP iterative Client and server
application to reverse the given input
sentence



5 Design TCP client and server application to
transfer file



6 Design a TCP concurrent server to convert a
given text into upper case using multiplexing
system call select



7 Design a TCP concurrent server to echo
given set of sentences using poll functions



8 Design UDP Client and server application to
reverse the given input sentence



9 Design UDP Client server to transfer a file



10 Design using poll client server application to
multiplex TCP and UDP requests for
converting a given text into upper case.



11 Design a RPC application to add and
subtract a given pair of integers





Program1

Implement the following forms of IPC.
a) Pipes
b) FIFO

a) Named Pipes

Half Duplex
half Duplex.h
#define HALF_DUPLEX "/tmp/halfduplex"
#define MAX_BUF_SIZE 255

hd_server.c
#include <stdio.h>
#include <errno.h>
#include <ctype.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "half_duplex.h" /* For name of the named-pipe */
#include <stdlib.h>
int main (int argc, char *argv[])
{
int fd, ret_val, count, numread;
char buf[MAX_BUF_SIZE];
/* Create the named - pipe */
ret_val = mkfifo(HALF_DUPLEX, 0666);
if ((ret_val == -1) && (errno != EEXIST)) {
perror("Error creating the named pipe\n");
exit (1);
}
/* Open the pipe for reading */
fd = open(HALF_DUPLEX, O_RDONLY);
/* Read from the pipe */
numread = read(fd, buf, MAX_BUF_SIZE);
buf[numread] = '0';
printf("Half Duplex Server : Read From the pipe : %s\n", buf);
/* Convert to the string to upper case */
count = 0;
while (count < numread) {
buf[count] = toupper(buf[count]);
count++;
}
printf("Half Duplex Server : Converted String : %s\n", buf);
}

halfduplex1.h
#define HALF_DUPLEX "/tmp/halfduplex1"
#define MAX_BUF_SIZE 255

hd_client.c
#include <stdio.h>
#include <errno.h>
#include <ctype.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <fcntl.h>
#include "half_duplex1.h" /* For name of the named-pipe */
#include <stdlib.h>
int main(int argc, char *argv[])
{
int fd;
/* Check if an argument was specified. */
if (argc != 2) {
printf("Usage : %s <string to be sent to the server>n", argv[0]);
exit (1);
}
/* Open the pipe for writing */
fd = open(HALF_DUPLEX, O_WRONLY);
/* Write to the pipe */
write(fd, argv[1], strlen(argv[1]));
}
Execution Steps:
1. Named Pipes:
a) Half Duplex.
1. Run the server:
% cc hd_server.c
% mv a.out hd_server
%./hd_server &
The server program will block here, and the shell will return control to the
command line.
2. Run the client:
% cc hd_client
% mv a.out hd_client
%./hd_client hello
3. The server prints the string read and terminates:

Output:-
Half Duplex Server : Read From the pipe : hello
Half Duplex Server : Converted String : HELLO

b) Named Pipe:
Full Duplex:
full duplex.h
#define NP1 "/tmp/np1"
#define NP2 "/tmp/np2"
#define MAX_BUF_SIZE 255

fd_server.c
#include <stdio.h>
#include <errno.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "fullduplex.h" /* For name of the named-pipe */
#include <stdlib.h>
#include<string.h>
int main(int argc, char *argv[])
{
int rdfd, wrfd, ret_val, count, numread;
char buf[MAX_BUF_SIZE];
/* Create the first named - pipe */
ret_val = mkfifo(NP1, 0666);
if ((ret_val == -1) && (errno != EEXIST)) {
perror("Error creating the named pipe");
exit (1);
}
ret_val = mkfifo(NP2, 0666);
if ((ret_val == -1) && (errno != EEXIST)) {
perror("Error creating the named pipe");
exit (1);
}
/* Open the first named pipe for reading */
rdfd = open(NP1, O_RDONLY);

/* Open the second named pipe for writing */
wrfd = open(NP2, O_WRONLY);
/* Read from the first pipe */
numread = read(rdfd, buf, MAX_BUF_SIZE);
buf[numread] = '0';
printf("Full Duplex Server : Read From the pipe : %s\n", buf);
/* Convert to the string to upper case */
count = 0;
while (count < numread) {
buf[count] = toupper(buf[count]);
count++;
}
/*
* * Write the converted string back to the second
* * pipe
* */
write(wrfd, buf, strlen(buf));
}

fd_client.c
#include <stdio.h>
#include <errno.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "fullduplex.h" /* For name of the named-pipe */
#include <stdlib.h>
#include<string.h>
int main(int argc, char *argv[])
{
int wrfd, rdfd, numread;
char rdbuf[MAX_BUF_SIZE];
/* Check if an argument was specified. */
if (argc != 2) {
printf("Usage : %s <string to be sent to the server>n", argv[0]);
exit (1);
}
/* Open the first named pipe for writing */
wrfd = open(NP1, O_WRONLY);
/* Open the second named pipe for reading */
rdfd = open(NP2, O_RDONLY);
/* Write to the pipe */
write(wrfd, argv[1], strlen(argv[1]));
/* Read from the pipe */
numread = read(rdfd, rdbuf, MAX_BUF_SIZE);
rdbuf[numread] = '0';
printf("Full Duplex Client : Read From the Pipe : %s\n", rdbuf);
}

Execution Steps:
b) Full Duplex.
1. Run the server:
% cc fd_server.c
% mv a.out fd_server
%./fd_server &
The server program will block here, and the shell will return control to the
command line.
2. Run the client:
% cc fd_client
% mv a.out fd_client
%./fd_client hello
3. The client program will send the string to server and block on the read
to await the server's response.
4. The server prints the following:
Full Duplex Server : Read From the pipe : hello
The client prints the following:
Full Duplex Client : Read From the pipe : HELLO
Program2

Implement file transfer using Message Queue form of IPC

message_send.c -- creating and sending to a simple message queue
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <string.h>
#define MSGSZ 128
/*
* Declare the message structure.
*/
typedef struct msgbuf {
long mtype;
char mtext[MSGSZ];
} message_buf;
main()
{
int msqid;
int msgflg = IPC_CREAT | 0666;
key_t key;
message_buf sbuf;
size_t buf_length;
/*
* Get the message queue id for the
* "name" 1234, which was created by
* the server.
*/
key = 1234;
(void) fprintf(stderr, "\nmsgget: Calling msgget(%#lx,\
%#o)\n",
key, msgflg);
if ((msqid = msgget(key, msgflg )) < 0) {
perror("msgget");

exit(1);
}
else
(void) fprintf(stderr,"msgget: msgget succeeded: msqid = %d\n", msqid);
/*
* We'll send message type 1
*/
sbuf.mtype = 1;
(void) fprintf(stderr,"msgget: msgget succeeded: msqid = %d\n", msqid);
(void) strcpy(sbuf.mtext, "Did you get this?");
(void) fprintf(stderr,"msgget: msgget succeeded: msqid = %d\n", msqid);
buf_length = strlen(sbuf.mtext) + 1 ;
/*
* Send a message.
*/
if (msgsnd(msqid, &sbuf, buf_length, IPC_NOWAIT) < 0) {
printf ("%d, %d, %s, %d\n", msqid, sbuf.mtype, sbuf.mtext, buf_length);
perror("msgsnd");
exit(1);
}
else
printf("Message: \"%s\" Sent\n", sbuf.mtext);
exit(0);
}

message_rec.c -- receiving the above message
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#define MSGSZ 128
/*
* Declare the message structure.
*/
typedef struct msgbuf {
long mtype;
char mtext[MSGSZ];
} message_buf;
main()
{
int msqid;
key_t key;
message_buf rbuf;
/*
* Get the message queue id for the
* "name" 1234, which was created by
* the server.
*/
key = 1234;
if ((msqid = msgget(key, 0666)) < 0) {
perror("msgget");
exit(1);
}
/*
* Receive an answer of message type 1.
*/
if (msgrcv(msqid, &rbuf, MSGSZ, 1, 0) < 0) {
perror("msgrcv");

exit(1);
}
/*
* Print the answer.
*/
printf("%s\n", rbuf.mtext);
exit(0);
}

Execution Steps:
[sampath@localhost msgque]cc message_send.c
[sampath@localhost msgque]mv a.out msgsend
[sampath@localhost msgque]$ ./msgsend
msgget: Calling msgget(0x4d2,01666)
msgget: msgget succeeded: msqid = 0
msgget: msgget succeeded: msqid = 0
msgget: msgget succeeded: msqid = 0
Message: "Did you get this?" Sent
[sampath@localhost msgque]cc message_rec.c
[sampath@localhost msgque]mv a.out msgrec
[sampath@localhost msgque]$ ./msgrec &
[1] 2907
[sampath@localhost msgque]$ Did you get this?
Program3

Write a program to create an integer variable using shared memory concept and
increment the variable simultaneously by two processes. Use semaphores to avoid
race conditions.

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
int main(void) {
pid_t pid;
int *shared; /* pointer to the shm */
int shmid;
shmid = shmget(IPC_PRIVATE, sizeof(int), IPC_CREAT | 0666);
printf("Shared Memory ID=%u",shmid);
if (fork() == 0) { /* Child */
/* Attach to shared memory and print the pointer */
shared = shmat(shmid, (void *) 0, 0);
printf("Child pointer %u\n", shared);
*shared=1;
printf("Child value=%d\n", *shared);
sleep(2);
printf("Child value=%d\n", *shared);
} else { /* Parent */
/* Attach to shared memory and print the pointer */
shared = shmat(shmid, (void *) 0, 0);
printf("Parent pointer %u\n", shared);
printf("Parent value=%d\n", *shared);
sleep(1);
*shared=42;
printf("Parent value=%d\n", *shared);
sleep(5);
shmctl(shmid, IPC_RMID, 0);
}
}

Execution steps:
[sampath@localhost ipc]$cc shared_mem.c
[sampath@localhost ipc]$ ./a.out
Shared Memory ID=65537Child pointer 3086680064
Child value=1
Shared Memory ID=65537Parent pointer 3086680064
Parent value=1
Parent value=42
Child value=42

























Program4,5

Design TCP iterative Client and server application to reverse the given input
sentence
Design TCP client and server application to transfer file


tcpserver.c
/******************************************************************
*********
* FILENAME :demoserver.c
* DESCRIPTION:Contains Code for a server,that will accept
* a string from a client process , prints the string and the
* IP Address of the client .(Shows a typical ITERATIVE SERVER )
* Invoke the Executable as a.out
******************************************************************
**********/
#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 <arpa/inet.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <unistd.h>
#define MYPORT 13154 /*The port users will be connecting to*/
void readstring(int,char *);
int main(int C, char *V[] )
{
int listensocket,connectionsocket,retbind;
struct sockaddr_in
serveraddress,cliaddr;
socklen_t len;
char buf[100],databuf[1024];
listensocket = socket(AF_INET, SOCK_STREAM, 0 );
if (listensocket < 0 )
{
perror("socket" );
exit(1);
}
memset(&serveraddress, 0, sizeof(serveraddress) );
serveraddress.sin_family = AF_INET;
serveraddress.sin_port = htons(MYPORT);/*PORT NO*/
serveraddress.sin_addr.s_addr = htonl(INADDR_ANY);/*ADDRESS*/
retbind=bind(listensocket,(struct sockaddr*)&serveraddress,
sizeof(serveraddress));
/*Check the return value of bind for error*/
if(-1==retbind)
{
perror("BIND ERROR\n");
exit(1);
}
listen(listensocket,5);
/*Beginning of the Main Server Processing Loop*/
for (;;)
{
printf("Server:I am waiting-----Start of Main Loop\n");
len=sizeof(cliaddr);
connectionsocket=accept(listensocket,
(struct sockaddr*)&cliaddr,&len);
if (connectionsocket < 0)
{
if (errno == EINTR)
printf("Interrupted system call ??");
continue;
}
printf("Connection from %s\n",
inet_ntop(AF_INET,&cliaddr.sin_addr,buf,sizeof(buf)));
readstring(connectionsocket , databuf);
close(connectionsocket);
printf("Finished Serving One Client\n");
}
}

/******************************************************************
**
* FUNCTION NAME:readstring
* DESCRIPTION: Reads the string sent by the client over the
* socket and stores it in the array fname .
* NOTES : No Error Checking is done .
* RETURNS :void
******************************************************************
***/
void readstring(
int connectionsocket, /*Socket Descriptor*/
char *fname) /*Array , to be populated by the string from client*/
/******************************************************************
**/
{
int pointer=0,n;
int len=0,a,b;
char rev[50],temp[50],temp1[50];
int k,i;
while ((n=read(connectionsocket, (fname + pointer),1024))>0)
{
pointer=pointer+n;
}
fname[pointer]='\0';
printf("enter the string\n");
printf("Server :Received %s\n " ,fname);
//strcpy(temp,fname);
k=strlen(fname);
// for(k=0;temp[k]!=0;k++);
// len=k;
a=0;
for(i=k-1;i>=0;i--)
temp[a++]=fname[i];
temp[a]='\0';
printf("\nrev is %s\n", temp);
}
/******************************************************************
****/


tcpclient.c
/******************************************************************
*********
* FILENAME : democlient.c
* DESCRIPTION:Contains Code for a client that will send a string
* to a server process and exits.
* Invoke the Executable as a.out IPAddress PortNo string

******************************************************************
***********/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#define MAXBUFFER 1024
void sendstring(int , char *);
int main( int C, char *V[] )
{
int sd,fd;
char c;
struct sockaddr_in serveraddress;
char text[100];
int i=0;
sd = socket( AF_INET, SOCK_STREAM, 0 );
if( sd < 0 ) {
perror( "socket" );
exit( 1 );
}
if (V[1] == NULL ) {
printf ("PL specfiy the server's IP Address \n");
exit(0);
}
if (V[2] == NULL ) {
printf ("PL specify the server's Port No \n");
exit(0);
}
// if (V[3] == NULL ) {
// printf ("PL specfiy the string to be send to the server \n");
// exit(0);
// }
memset( &serveraddress, 0, sizeof(serveraddress) );
serveraddress.sin_family = AF_INET;
serveraddress.sin_port = htons(atoi(V[2]));//PORT NO
serveraddress.sin_addr.s_addr = inet_addr(V[1]);//ADDRESS
if (connect(sd,(struct sockaddr*)&serveraddress,
sizeof(serveraddress))<0)
{
printf("Cannot Connect to server");
exit(1);
}
printf("enter sentence to end enter #");
while(1)
{
c=getchar();
if(c=='#')
break;
text[i++]=c;
}
text[i]='\0';
sendstring(sd,text);
close(sd);
return 0;
}
/******************************************************************
******
* FUNCTION NAME:sendstring
* DESCRIPTION: sends a string over the socket .
* NOTES : No Error Checking is done .
* RETURNS :void
******************************************************************
******/
void sendstring(
int sd, /*Socket Descriptor*/
char *fname) /*Array Containing the string */
/******************************************************************
*******/
{int n, byteswritten=0, written ;
char buffer[MAXBUFFER];
strcpy(buffer , fname);
n=strlen(buffer);
while (byteswritten<n)
{
written=write(sd , buffer+byteswritten,(n-byteswritten));
byteswritten+=written;
}
printf("String : %s sent to server \n",buffer);
}
/******************************************************************
**********/
Execution Steps:
2. TCP
a) Client Server Application.
1.Compiling and running server
[user@localhost Program9]$ cc tcpserver.c
[user@localhost Program9]$ mv a.out tcpserver
[user@localhost Program9]$ ./tcpserver
Server:I am waiting-----Start of Main Loop
Connection from 127.0.0.1
enter the string
Server :Received Network Programming
Rev string is gnimmargorP krowteN
Finished Serving One Client
Server:I am waiting-----Start of Main Loop

2. Compiling and running client
[user@localhost Program9]$ cc tcpclient.c
[user@localhost Program9]$ mv a.out tcpclient
[user@localhost Program9]$./tcpclient 127.0.0.1 13153
enter sentence to end enter #Network Programming#
String : Network Programming sent to server


Program 6

Design a TCP concurrent server to convert a given text into upper case using
multiplexing

system call select
tcpservselect01.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#define MAXLINE 100
#define SERV_PORT 13153
int main(int argc, char **argv)
{
int k, i, maxi, maxfd, listenfd, connfd, sockfd;
int nready, client[FD_SETSIZE];
ssize_t n;
fd_set rset, allset;
char line[MAXLINE],buf[100];
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
listenfd = socket(AF_INET, SOCK_STREAM, 0);
if (listenfd < 0 )
{
perror("socket" );
exit(1);
}
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
listen(listenfd,5);
maxfd = listenfd; /* initialize */
maxi = -1; /* index into client[] array */
for (i = 0; i < FD_SETSIZE; i++)
client[i] = -1; /* -1 indicates available entry */
FD_ZERO(&allset);
FD_SET(listenfd, &allset);
/* end fig01 */
/* include fig02 */
for ( ; ; ) {
printf("Server:I am waiting-----Start of Main Loop\n");
rset = allset; /* structure assignment */
nready = select(maxfd+1, &rset, NULL, NULL, NULL);
if (FD_ISSET(listenfd, &rset)) { /* new client connection */
clilen = sizeof(cliaddr);
connfd = accept(listenfd, (struct sockaddr *) &cliaddr, &clilen);
#ifdef NOTDEF
printf("new client: %s, port %d\n",
inet_ntop(AF_INET, &cliaddr.sin_addr, buf, NULL),
ntohs(cliaddr.sin_port));
#endif
for (i = 0; i < FD_SETSIZE; i++)
if (client[i] < 0) {
client[i] = connfd; /* save descriptor */
break;
}
if (i == FD_SETSIZE)
{
printf("too many clients");
exit(0);
}
FD_SET(connfd, &allset); /* add new descriptor to set */
if (connfd > maxfd)
maxfd = connfd; /* for select */
if (i > maxi)
maxi = i; /* max index in client[] array */
if (--nready <= 0)
continue; /* no more readable descriptors
*/
}
for (i = 0; i <= maxi; i++) { /* check all clients for data */
if ( (sockfd = client[i]) < 0)
continue;
if (FD_ISSET(sockfd, &rset)) {
if ( (n = read(sockfd, line, MAXLINE)) == 0) {
/*4connection closed by client */
close(sockfd);
FD_CLR(sockfd, &allset);
client[i] = -1;
} else
{
printf("\n output at server\n");
for(k=0;line[k]!='\0';k++)
printf("%c",toupper(line[k]));
write(sockfd, line, n);
}
if (--nready <= 0)
break; /* no more readable descriptors
*/
}
}
}
}
/* end fig02 */
tcpclient.c
/******************************************************************
*********
* FILENAME : democlient.c
* DESCRIPTION:Contains Code for a client that will send a string
* to a server process and exits.
* Invoke the Executable as a.out IPAddress PortNo string
******************************************************************
***********/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#define MAXBUFFER 1024
void sendstring(int , char *);
int main( int C, char *V[] )
{
int sd,fd;
char c;
struct sockaddr_in serveraddress;
char text[100];
int i=0;
sd = socket( AF_INET, SOCK_STREAM, 0 );
if( sd < 0 ) {
perror( "socket" );
exit( 1 );
}
if (V[1] == NULL ) {
printf ("PL specfiy the server's IP Address \n");
exit(0);
}
if (V[2] == NULL ) {
printf ("PL specify the server's Port No \n");
exit(0);
}
// if (V[3] == NULL ) {
// printf ("PL specfiy the string to be send to the server \n");
// exit(0);
// }
memset( &serveraddress, 0, sizeof(serveraddress) );
serveraddress.sin_family = AF_INET;
serveraddress.sin_port = htons(atoi(V[2]));//PORT NO
serveraddress.sin_addr.s_addr = inet_addr(V[1]);//ADDRESS
if (connect(sd,(struct sockaddr*)&serveraddress,
sizeof(serveraddress))<0)
{
printf("Cannot Connect to server");
exit(1);
}
printf("enter sentence to end enter #");
while(1)
{
c=getchar();
if(c=='#')
break;
text[i++]=c;
}
text[i]='\0';
sendstring(sd,text);
close(sd);
return 0;
}
/******************************************************************
******
* FUNCTION NAME:sendstring
* DESCRIPTION: sends a string over the socket .
* NOTES : No Error Checking is done .
* RETURNS :void
******************************************************************
******/
void sendstring(
int sd, /*Socket Descriptor*/
char *fname) /*Array Containing the string */
/******************************************************************
*******/
{ int n , byteswritten=0 , written ;
char buffer[MAXBUFFER];
strcpy(buffer , fname);
n=strlen(buffer);
while (byteswritten<n)
{
written=write(sd , buffer+byteswritten,(n-byteswritten));
byteswritten+=written;
}
printf("String : %s sent to server \n",buffer);
}
/******************************************************************
**********/
Execution Steps:
b) Concurrent Server Application Using Select.
Compiling and running server.
root@localhost Program7and8]# cc tcpservselect01.c
[root@localhost Program7and8]# mv a.out tcpservselect1
[root@localhost Program7and8]# ./tcpservselect1
Server:I am waiting-----Start of Main Loop
Server:I am waiting-----Start of Main Loop
output at server
A B C DServer:I am waiting-----Start of Main Loop
output at server
A B C DServer:I am waiting-----Start of Main Loop
Server:I am waiting-----Start of Main Loop
Compiling and running Client.
root@localhost Program7and8]# ./tcpclient 127.0.0.1 13153
enter sentence to end enter #abcd#
String : abcd sent to server
















Program 7

Design a TCP concurrent server to echo given set of sentences using poll functions

tcpservpoll01.c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <limits.h> /* for OPEN_MAX */
#include <poll.h>
#include <errno.h>
#define MAXLINE 100
#define SERV_PORT 13154
#define POLLRDNORM 5
#define INFTIM 5
#define OPEN_MAX 5
int main(int argc, char **argv)
{
int k, i, maxi, listenfd, connfd, sockfd;
int nready;
ssize_t n;
char line[MAXLINE];
socklen_t clilen;
struct pollfd client[OPEN_MAX];
struct sockaddr_in cliaddr, servaddr;
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(SERV_PORT);
bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
listen(listenfd, 5);
client[0].fd = listenfd;
client[0].events = POLLRDNORM;
for (i = 1; i < OPEN_MAX; i++)
client[i].fd = -1; /* -1 indicates available entry */
maxi = 0; /* max index into client[] array */
/* end fig01 */
/* include fig02 */
for ( ; ; ) {
nready = poll(client, maxi+1, INFTIM);
if (client[0].revents & POLLRDNORM) { /* new client connection */
clilen = sizeof(cliaddr);
connfd = accept(listenfd, (struct sockaddr *) &cliaddr, &clilen);
#ifdef NOTDEF
printf("new client: %s\n", sock_ntop((struct sockaddr *) &cliaddr,
clilen));
#endif
for (i = 1; i < OPEN_MAX; i++)
if (client[i].fd < 0) {
client[i].fd = connfd; /* save descriptor */
break;
}
if (i == OPEN_MAX)
{
printf("too many clients");
exit(0);
}
client[i].events = POLLRDNORM;
if (i > maxi)
maxi = i; /* max index in client[] array */
if (--nready <= 0)
continue; /* no more readable descriptors
*/
}
for (i = 1; i <= maxi; i++) { /* check all clients for data */
if ( (sockfd = client[i].fd) < 0)
continue;
if (client[i].revents & (POLLRDNORM | POLLERR)) {
if ( (n = read(sockfd, line, MAXLINE)) < 0) {
if (errno == ECONNRESET) {
/*4connection reset by client */
#ifdef NOTDEF
printf("client[%d] aborted connection\n", i);
#endif
close(sockfd);
client[i].fd = -1;
} else
printf("readline error");
} else if (n == 0) {
/*4connection closed by client */
#ifdef NOTDEF
printf("client[%d] closed connection\n", i);
#endif
close(sockfd);
client[i].fd = -1;
} else{ printf("\n data from client is \n");
k=strlen(line);
printf(" length=%d data = %s\n", k,line);
//write(sockfd, line, n);
strcpy(line," ");
}
if (--nready <= 0)
break; /* no more readable descriptors
*/
}
}
}
}
/* end fig02 */


democlient.c
/******************************************************************
*********
* FILENAME : democlient.c
* DESCRIPTION:Contains Code for a client that will send a string
* to a server process and exits.
* Invoke the Executable as a.out IPAddress PortNo string

******************************************************************
***********/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#define MAXBUFFER 1024
void sendstring(int , char *);
int main( int C, char *V[] )
{
int sd,fd;
char c;
struct sockaddr_in serveraddress;
char text[100];
int i=0;
sd = socket( AF_INET, SOCK_STREAM, 0 );
if( sd < 0 ) {
perror( "socket" );
exit( 1 );
}
if (V[1] == NULL ) {
printf ("PL specfiy the server's IP Address \n");
exit(0);
}
if (V[2] == NULL ) {
printf ("PL specify the server's Port No \n");
exit(0);
}
// if (V[3] == NULL ) {
// printf ("PL specfiy the string to be send to the server \n");
// exit(0);
// }
memset( &serveraddress, 0, sizeof(serveraddress));
serveraddress.sin_family = AF_INET;
serveraddress.sin_port = htons(atoi(V[2]));//PORT NO
serveraddress.sin_addr.s_addr = inet_addr(V[1]);//ADDRESS
if (connect(sd,(struct sockaddr*)&serveraddress,
sizeof(serveraddress))<0)
{
printf("Cannot Connect to server");
exit(1);
}
printf("enter sentence to end enter #");
while(1)
{
c=getchar();
if(c=='#')
break;
text[i++]=c;
}
text[i]='\0';
sendstring(sd,text);
close(sd);
return 0;
}
/******************************************************************
******
* FUNCTION NAME:sendstring
* DESCRIPTION: sends a string over the socket .
* NOTES : No Error Checking is done .
* RETURNS :void
******************************************************************
******/
void sendstring(
int sd, /*Socket Descriptor*/
char *fname) /*Array Containing the string */
/******************************************************************
*******/
{ int n , byteswritten=0 , written ;
char buffer[MAXBUFFER];
strcpy(buffer , fname);
n=strlen(buffer);
while (byteswritten<n)
{
written=write(sd , buffer+byteswritten,(n-byteswritten));

byteswritten+=written;
}
printf("String : %s sent to server \n",buffer);
}
/******************************************************************
**********/

c) Concurrent Server Application Using Poll.
Compiling and running server.
[root@localhost Program8]# cc tcpservpoll01.c
[root@localhost Program8]# mv a.out pollserv
[root@localhost Program8]# ./pollserv
data from client is
data = aaaaaaaaaaaaaaaaaaaaaaaa
Compiling and running Client.
[root@localhost Program8]#cc democlient.c
[root@localhost Program8]#mv a.out client
[root@localhost Program8]# ./client 127.0.0.1 13153
enter sentence to end enter #aaaaaaaaaaaaaaaaaaaaaaaa#
String : aaaaaaaaaaaaaaaaaaaaaaaa sent to server


Program8
Design UDP Client and server application to reverse the given input sentence
Program9
Design UDP Client server to transfer a file
Program10
Design using poll client server application to multiplex TCP and UDP requests for
converting a given text into upper case.

udp_server.c
/******************************************************************
************
* FILENAME : uechos.c
* DESCRIPTION:Contains Code for a echo server , that will accept data
* from a client process and sends that data back to client, using UDP
* Invoke the Executable as a.out

******************************************************************
************/
#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 <arpa/inet.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <signal.h>
#define BUFSIZE 512
#define MYPORT 11710
#define MAXNAME 100
int main(int C, char **V )
{
int sd,n,ret;
struct sockaddr_in
serveraddress,cliaddr;
socklen_t length;
char clientname[MAXNAME],datareceived[BUFSIZE];
sd = socket( AF_INET, SOCK_DGRAM, 0 );
if( sd < 0 ) {
perror( "socket" );
exit( 1 );
}
memset( &serveraddress, 0, sizeof(serveraddress) );
memset( &cliaddr, 0, sizeof(cliaddr) );
serveraddress.sin_family = AF_INET;
serveraddress.sin_port = htons(MYPORT);//PORT NO
serveraddress.sin_addr.s_addr = htonl(INADDR_ANY);//IP ADDRESS
ret=bind(sd,(struct sockaddr*)&serveraddress,sizeof(serveraddress));
if(ret<0)
{
perror("BIND FAILS");
exit(1);
}
for(;;)
{
printf("I am waiting\n");
/*Received a datagram*/
length=sizeof(cliaddr);
n=recvfrom(sd,datareceived,BUFSIZE,0,
(struct sockaddr*)&cliaddr , &length);
printf("Data Received from %s\n",
inet_ntop(AF_INET,&cliaddr.sin_addr,
clientname,sizeof(clientname)));
/*Sending the Received datagram back*/
datareceived[n]='\0';
printf("I have received %s\n",datareceived);
sendto(sd,datareceived,n,0,(struct sockaddr *)&cliaddr,length);
}
}

udp_client.c
/******************************************************************
*********
* FILENAME : uechoc.c
* DESCRIPTION:Contains Code for a echo client , that will accept data
* from the user(keyboard) and sens that data to a echo server process
* and prints the received data back on the screen .(UDP)
* Invoke the Executable as a.out ServerIP ServerPort

******************************************************************
**********/
#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 <arpa/inet.h>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
#define BUFSIZE 512
static void sig_usr(int);
void str_cli(FILE *fp , int sockfd , struct sockaddr *server , socklen_t len);
int main( int C, char *argv[] )
{
int sd;
struct sockaddr_in
serveraddress;
/*Installing signal Handlers*/
signal(SIGPIPE,sig_usr);
signal(SIGINT,sig_usr);
if (NULL==argv[1])
{
printf("Please enter the IP Address of the server\n");
exit(0);
}
if (NULL==argv[2])
{
printf("Please enter the Port Number of the server\n");
exit(0);

}
sd = socket( AF_INET, SOCK_DGRAM, 0 );
if( sd < 0 )
{
perror( "socket" );
exit( 1 );
}
memset( &serveraddress, 0, sizeof(serveraddress) );
serveraddress.sin_family = AF_INET;
serveraddress.sin_port = htons(atoi(argv[2]));//PORT NO
serveraddress.sin_addr.s_addr = inet_addr(argv[1]);//ADDRESS
printf("Client Starting service\n");
printf("Enter Data For the server\n");
str_cli(stdin,sd ,(struct sockaddr *)&serveraddress,
sizeof(serveraddress));
}
/******************************************************************
******
* FUNCTION NAME:sig_usr
* DESCRIPTION: Signal Handler for Trappinf SIGPIPE
* NOTES : No Error Checking is done.
* RETURNS :void
******************************************************************
******/
static void sig_usr(
int signo) /*Signal Number*/
/******************************************************************
******/
{
char *strpipe="RECEIVED SIGPIPE - ERROR";
char *strctrl="RECEIVED CTRL-C FROM YOU";
if(signo==SIGPIPE)
{
write(1,strpipe,strlen(strpipe));
exit(1);
}
else if(signo==SIGINT)
{
write(1,strctrl,strlen(strctrl));
exit(1);
}

}
/******************************************************************
******
* FUNCTION NAME:str_cli
* DESCRIPTION: Main Client Processing (Select waits for readiness of
* connection socket or stdin
* NOTES : No Error Checking is done .
* RETURNS :void
******************************************************************
******/
void str_cli(FILE *fp, /*Here to be used as stdin as argument*/
int sockfd ,
struct sockaddr *to ,socklen_t length) /*Connection Socket */
/******************************************************************
*****/
{
int maxdes,n;
fd_set rset;
char sendbuf[BUFSIZE] , recvbuf[BUFSIZE] ,servername[100];
struct sockaddr_in serveraddr;
socklen_t slen;
FD_ZERO(&rset);
maxdes=(sockfd>fileno(fp)?sockfd+1:fileno(fp)+1);
for(;;){
FD_SET(fileno(fp) , &rset);
FD_SET(sockfd , &rset);
select(maxdes,&rset,NULL,NULL,NULL);
if(FD_ISSET(sockfd , & rset))
{
slen=sizeof(serveraddr);
n=recvfrom(sockfd,recvbuf,BUFSIZE,0,
(struct sockaddr*)&serveraddr,&slen);
printf("Data Received from server %s:\n",
inet_ntop(AF_INET,&serveraddr.sin_addr,
servername,sizeof(servername)));
write(1,recvbuf,n);
printf("Enter Data For the server\n");
}
if(FD_ISSET(fileno(fp) , & rset))
{
/*Reading data from the keyboard*/
fgets(sendbuf,BUFSIZE, fp);
n = strlen (sendbuf);
/*Sending the read data over socket*/
sendto(sockfd,sendbuf,n,0,to,length);
printf("Data Sent To Server\n");
}
}
}
/******************************************************************
********/

5. UDP Client Server Application.
Compiling and running server.
[user@localhost Program9]$ cc udp_server.c
[user@localhost Program9]$ mv a.out udp_server
[user@localhost Program9]$ ./ udp_server
I am waiting
Data Received from 127.0.0.1
I have received abcd efgh
rev is
hgfe dcba
I am waiting
Compiling and running client.
user@localhost Program9]$ cc udp_client.c
[user@localhost Program9]$ mv a.out udp_client
[user@localhost Program9]$ ./ udp_client 127.0.0.1 11710
Client Starting service
Enter Data For the server
abcd efgh
Data Sent To Server
Data Received from server 127.0.0.1:
abcd efgh
Enter Data For the server

























Program11

Design a RPC application to add and subtract a given pair of integers

rpctime.x
/******************************************************************
***********/
/*** rpctime.x ***/
/*** ***/
/*** SPECIFICATION FILE FOR RPC TO DEFINE SERVER PROCEDURE
AND
ARGUMENTS ***/
/******************************************************************
***********/
program RPCTIME
{
version RPCTIMEVERSION
{
long GETTIME() = 1;
} = 1;
} = 2000001;

rpctime.h
/*
* Please do not edit this file.
* It was generated using rpcgen.
*/
#ifndef _RPCTIME_H_RPCGEN
#define _RPCTIME_H_RPCGEN
#include <rpc/rpc.h>
#ifdef __cplusplus
extern "C" {
#endif
#define RPCTIME 2000001
#define RPCTIMEVERSION 1
#if defined(__STDC__) || defined(__cplusplus)
#define GETTIME 1
extern long * gettime_1(void *, CLIENT *);
extern long * gettime_1_svc(void *, struct svc_req *);
extern int rpctime_1_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
#else /* K&R C */
#define GETTIME 1
extern long * gettime_1();
extern long * gettime_1_svc();
extern int rpctime_1_freeresult ();
#endif /* K&R C */
#ifdef __cplusplus
}
#endif
#endif /* !_RPCTIME_H_RPCGEN */

rpctime_client
/* rpctime_client.c
*
/******************************************************************
***********/
/*** rpctime_client.c ***/
/*** ***/
/******************************************************************
***********/
/*
* These are only templates and you can use them
* as a guideline for developing your own functions.
*/
#include "rpctime.h"
void
rpctime_1(char *host)
{
CLIENT *clnt;
long *result_1;
char *gettime_1_arg;
#ifndef DEBUG
clnt = clnt_create (host, RPCTIME, RPCTIMEVERSION, "udp");
if (clnt == NULL) {
clnt_pcreateerror (host);
exit (1);
}
#endif /* DEBUG */
result_1 = gettime_1((void*)&gettime_1_arg, clnt);
if (result_1 == (long *) NULL) {
clnt_perror (clnt, "call failed");
}
else
printf("%d |%s", *result_1, ctime(result_1));
#ifndef DEBUG
clnt_destroy (clnt);
#endif /* DEBUG */
}
int
main (int argc, char *argv[])
{
char *host;
if (argc < 2) {
printf ("usage: %s server_host\n", argv[0]);
exit (1);
}
host = argv[1];
rpctime_1 (host);
exit (0);
}
rpctime_cntl.c

#include <memory.h> /* for memset */

#include "rpctime.h"
/* Default timeout can be changed using clnt_control() */
static struct timeval TIMEOUT = { 25, 0 };
long *
gettime_1(void *argp, CLIENT *clnt)
{
static long clnt_res;
memset((char *)&clnt_res, 0, sizeof(clnt_res));
if (clnt_call (clnt, GETTIME,
(xdrproc_t) xdr_void, (caddr_t) argp,
(xdrproc_t) xdr_long, (caddr_t) &clnt_res,
TIMEOUT) != RPC_SUCCESS) {
return (NULL);
}
return (&clnt_res);
}

rpctime_server.c
/* rpctime_server.c
/******************************************************************
***********/
/*** rpctime_server.c ***/
/*** ***/
/******************************************************************
***********/
*/
#include "rpctime.h"
long *
gettime_1_svc(void *argp, struct svc_req *rqstp)
{
static long result;
50
time(&result);
return &result;
}
rpctime_svc.c

#include "rpctime.h"
#include <stdio.h>
#include <stdlib.h>
#include <rpc/pmap_clnt.h>
#include <string.h>
#include <memory.h>
#include <sys/socket.h>
#include <netinet/in.h>
#ifndef SIG_PF
#define SIG_PF void(*)(int)
#endif
static void
rpctime_1(struct svc_req *rqstp, register SVCXPRT *transp)
{
union {
int fill;
} argument;
char *result;
xdrproc_t _xdr_argument, _xdr_result;
char *(*local)(char *, struct svc_req *);
switch (rqstp->rq_proc) {
case NULLPROC:
(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
return;
case GETTIME:
_xdr_argument = (xdrproc_t) xdr_void;
_xdr_result = (xdrproc_t) xdr_long;
local = (char *(*)(char *, struct svc_req *)) gettime_1_svc;
break;
default:
svcerr_noproc (transp);
return;
}
memset ((char *)&argument, 0, sizeof (argument));
if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
svcerr_decode (transp);
return;
}
result = (*local)((char *)&argument, rqstp);
if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) {
svcerr_systemerr (transp);
}
if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
fprintf (stderr, "%s", "unable to free arguments");
exit (1);
}
return;
}
int
main (int argc, char **argv)
{
register SVCXPRT *transp;
pmap_unset (RPCTIME, RPCTIMEVERSION);
transp = svcudp_create(RPC_ANYSOCK);
if (transp == NULL) {
fprintf (stderr, "%s", "cannot create udp service.");
exit(1);
}
if (!svc_register(transp, RPCTIME, RPCTIMEVERSION, rpctime_1,
IPPROTO_UDP)) {
fprintf (stderr, "%s", "unable to register (RPCTIME, RPCTIMEVERSION,
udp).");
exit(1);
}
transp = svctcp_create(RPC_ANYSOCK, 0, 0);
if (transp == NULL) {
fprintf (stderr, "%s", "cannot create tcp service.");
exit(1);
}
if (!svc_register(transp, RPCTIME, RPCTIMEVERSION, rpctime_1,
IPPROTO_TCP)) {
fprintf (stderr, "%s", "unable to register (RPCTIME, RPCTIMEVERSION, tcp).");
exit(1);
}
svc_run ();
fprintf (stderr, "%s", "svc_run returned");
exit (1);
/* NOTREACHED */
}

6. RPC Application.
Step 1:
[user@localhost $]$ rpcgen C rpctime.x.
This creates rpctime.h, rpctime_clnt.c, rpctime_svc.c files in the folder
Step 2:
[user@localhost $]$cc c rpctime_client.c o rpctime_clien.o
Step 3:
[user@localhost $]$cc o client rpctime_client.o rpctime_clnt.o -lnsl
Step 4:
[user@localhost $]$cc c rpctime_server.c o rpctime_server.o
Step 5:
[user@localhost $]$cc o server rpctime_server.o rpctime_svc.o -lnsl
[root@localhost $]$./server &
[1] 7610
[root@localhost $]$./client 127.0.0.1
1277628700 |Sun Jun 27 14:21:40 2010
[root@localhost $]$./client 127.0.0.1
1277628718 |Sun Jun 27 14:21:58 2010