ccplusplus.com

Showing posts with label IPC - Socket : Advance Concept Sample Codes. Show all posts

Saturday, February 18, 2012

struct iovec example

/*************************************************************************
 * File     :   writev.c
 * Author   :   Saurabh Gupta
 * Desc     :   struct iovec example
 * Source   :   http://www.ccplusplus.com/2011/07/socket.html
 * Created  :   10:37 PM Saturday, February 18, 2012
 *************************************************************************/
 #include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <string.h>
 #include <sys/uio.h>

int main(int argc,char **argv) {
     static char part2[] = "THIS IS FROM WRITEV : http://www.ccplusplus.com/";
     static char part3[] = "]\n";
     static char part1[] = "[";
     struct iovec iov[3];

iov[0].iov_base = part1;
     iov[0].iov_len = strlen(part1);

iov[1].iov_base = part2;
     iov[1].iov_len = strlen(part2);

iov[2].iov_base = part3;
     iov[2].iov_len = strlen(part3);

writev(1,iov,3);

return 0;
 }
/*
 *
 *
 [sgupta@rhel6x86 passing-creential-over-network]$ gcc writev.c -o writev
 [sgupta@rhel6x86 passing-creential-over-network]$ ./writev
 [THIS IS FROM WRITEV : http://www.ccplusplus.com/]
 [sgupta@rhel6x86 passing-creential-over-network]$
 */

writev example c

/*************************************************************************
 * File     :   writev.c
 * Author   :   Saurabh Gupta
 * Desc     :   writev example c
 * Source   :   http://www.ccplusplus.com/2011/07/socket.html
 * Created  :   10:37 PM Saturday, February 18, 2012
 *************************************************************************/
 #include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <string.h>
 #include <sys/uio.h>

iov[0].iov_base = part1;
     iov[0].iov_len = strlen(part1);

iov[1].iov_base = part2;
     iov[1].iov_len = strlen(part2);

iov[2].iov_base = part3;
     iov[2].iov_len = strlen(part3);

writev(1,iov,3);

Monday, September 19, 2011

stream tcp server c

/*************************************************************
 * File     :   stream-tcp-server.c
 * Author   :   Saurabh Gupta
 * Desc     :   Example inetd daytime server:
 * Source   :   http://saurabhgupta0527.blogspot.com/p/c.html 
 * Created  :   AM 06:36 19 September 2011
 *************************************************************/
 #include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <string.h>
 #include <time.h>
 #include <sys/types.h>
 
/*
 * This function reports the error and
 * exits back to the shell:
 */
 static void displayError(const char *on_what) {
     if ( errno != 0 ) {
         fputs(strerror(errno),stderr);
         fputs(": ",stderr);
     }
     fputs(on_what,stderr);
     fputc('\n',stderr);
     exit(1);
 }

int main(int argc,char **argv) {
     int z;
     int n;
     time_t td;         // Current date&time 
     char dtbuf[128];   // Date/Time info
    /*
     * Generate a time stamp:
     */
     time(&td);
     n = (int) strftime(dtbuf,sizeof dtbuf,
     "%A %b %d %H:%M:%S %Y\n",
     localtime(&td));

/*
     * Write result back to the client:
     */
     z = write(1,dtbuf,n);
     if ( z == -1 ) {
        displayError("write(2)");
     }
     return 0;
 }
/*
 * OUTPUT
 *
 [sgupta@rhel55x86 socket]$ gcc stream-tcp-server.c -o stream-tcp-server
 stream-tcp-server.c:50:3: warning: no newline at end of file
 [sgupta@rhel55x86 socket]$ ls
 [sgupta@rhel55x86 socket]$ ./stream-tcp-server
 Monday Sep 19 06:34:27 2011
 [sgupta@rhel55x86 socket]$
 */

Wednesday, September 14, 2011

socket bind listen accept example code

/* bindacpt.c 
  *
  * socket, bind, listen & accept 
  */
  #include <stdio.h>
  #include <unistd.h>
  #include <stdlib.h>
  #include <errno.h>
  #include <string.h>
  #include <time.h>
  #include <sys/types.h>
  #include <sys/socket.h>
  #include <netinet/in.h>
  #include <arpa/inet.h>
  #include <netdb.h>
 
  extern int
  mkaddr(void *addr,
  int *addrlen,
  char *str_addr,
  char *protocol);
 
 /*
  * This function reports the error and
  * exits back to the shell 
  */
  void
  displayError(const char *on_what) {
      if ( errno != 0 ) {
          fputs(strerror(errno),stderr);
          fputs("  ",stderr);
      }
      fputs(on_what,stderr);
      fputc( '\n', stderr);
      exit(1);
  }
 
 /*
  * Call socket(2), bind(2),
  * listen(2) and accept(2) 
  *
  * Returns socket.
  */
  int
  BindAccept(char *addr) {
      int z;
      int s;
      struct sockaddr_in adr_srvr;
      struct sockaddr_in adr_clnt;
      int len_inet;
     
     /*
      * Create a TCP/IP socket to use 
      */
      s = socket(PF_INET,SOCK_STREAM,0);
      if ( s == -1 )
      displayError("socket()");
     
     /*
      * Bind the server address 
      */
      len_inet = sizeof adr_srvr;
      z = mkaddr(&adr_srvr,&len_inet,
      addr,"tcp");
     
      if ( z != 0 ) {
      puts("Bad address/port");
      exit(1);
      }
     
     /*
      * Bind server address 
      */
      z = bind(s,(struct sockaddr *)&adr_srvr,
      len_inet);
      if ( z == -1 )
      displayError("bind(2)");
     
     /*
      * Set listen mode 
      */
      if ( listen(s, 10) == -1 )
      displayError("listen(2)");
     
     /*
      * Wait for a connect 
      */
      len_inet = sizeof adr_clnt;
     
      z = accept(s,
      (struct sockaddr *)&adr_clnt,
      &len_inet);
     
      if ( z == -1 )
      displayError("accept(2)");
     
      close(s); /* No longer needed */
      return z; /* Connected socket */
  }
 
  int
  Connect(char *addr) {
      int z;
      int s;
      struct sockaddr_in adr_srvr;
      int len_inet;
     
     /*
      * Create a TDP/IP socket to use 
      */
      s = socket(PF_INET,SOCK_STREAM,0);
      if ( s == -1 )
      displayError("socket()");
     
     /*
      * Bind the server address 
      */
      len_inet = sizeof adr_srvr;
      z = mkaddr(&adr_srvr,&len_inet,
      addr,"tcp");
     
      if ( z != 0 ) {
      puts("Bad address/port");
      exit(1);
      }
     
     /*
      * Connect to server 
      */
      len_inet = sizeof adr_srvr;
     
      z = connect(s,
      (struct sockaddr *)&adr_srvr,
      len_inet);
     
      if ( z == -1 )
      displayError("connect(2)");
     
      return s; /* Connected socket */
  }

Receiving with the SIGURG Signal example code

/* oobrecv.c:
 *
 * Example OOB receiver:
 */
  #include <stdio.h>
  #include <unistd.h>
  #include <stdlib.h>
  #include <errno.h>
  #include <string.h>
  #include <signal.h>
  #include <fcntl.h>
  #include <sys/types.h>
  #include <sys/socket.h>
 
  extern void displayError(char *on_what);
  extern int BindAccept(char *addr);
 
  static int s = -1; /* Socket */
 
 /*
  * SIGURG signal handler:
  */
  static void
  sigurg(int signo) {
      int n;
      char buf[256];
     
      n = recv(s,buf,sizeof buf,MSG_OOB);
      if ( n < 0 ) {
        displayError("recv(2)");
      }
     
      buf[n] = 0;
      printf("URG '%s' (%d) \n",
      buf,n);
     
      signal(SIGURG,sigurg);
  }
 
  int
  main(int argc,char **argv) {
      int z; /* Status */
      char buf[256];
     /*
      * Use a server address from the command
      * line, if one has been provided.
      * Otherwise, this program will default
      * to using the arbitrary address
      * 127.0.0.:
      */
      s = BindAccept(argc >= 2
      ? argv[1]
      : "127.0.0.1:9011");
     
     /*
      * Establish ownership:
      */
      z = fcntl(s,F_SETOWN,getpid());
      if ( z == -1 ) {
        displayError("fcntl(2)");
      }
     
     /*
      * Catch SIGURG:
      */
      signal(SIGURG,sigurg);
     
      for (;;) {
          z = recv(s,buf,sizeof buf,0);
          if ( z == -1 ) {
            displayError("recv(2)");
          }
          if ( z == 0 ) {
            break;
          }
          buf[z] = 0;
         
          printf("rcv '%s' (%d)\n",
          buf, z);
      }
     
      close(s);
      return 0;
  }

sending out of band data example code

/* oobsend.c 
  * sending out of band data example code
  * Example OOB sender 
  */
  #include <stdio.h>
  #include <unistd.h>
  #include <stdlib.h>
  #include <errno.h>
  #include <string.h>
  #include <sys/types.h>
  #include <sys/socket.h>
 
  extern void displayError(char *on_what);
  extern int Connect(char *addr);
 
 /*
  * Send in-band data 
  */
  static void iband(int s,char *str) {
      int z;
     
      z = send(s,str,strlen(str),0);
      if ( z == -1 ) {
        displayError("send(2)");
      }
     
      printf("ib  '%s' (%d)\n",str,z);
  }
 
 /*
  * Send out-of-band data 
  */
  static void
  oband(int s,char *str) {
      int z;
     
      z = send(s,str,strlen(str),MSG_OOB);
      if ( z == -1 ) {
        displayError("send(2)");
      }
     
      printf("OOB '%s' (%d)\n",str,z);
  }
 
  int
  main(int argc,char **argv) {
      int s = -1; /* Socket */
     
      s = Connect(argc >= 2
      ? argv[1]
      : "127.0.0.1:9011");
     
      iband(s,"In the beginning");
      sleep(1);
     
      iband(s,"Linus begat Linux,");
      sleep(1);
     
      iband(s,"and the Penguins");
      sleep(1);
     
      oband(s,"rejoiced");
      sleep(1);
     
      iband(s,"exceedingly.");
      close(s);
     
      return 0;
  }

Saturday, September 10, 2011

udp broadcast client example in c

/* udp-broadcast-client.c
  * udp datagram client
  * Get datagram stock market quotes from UDP broadcast:
  * see below the step by step explanation
  */
  #include <stdio.h>
  #include <unistd.h>
  #include <stdlib.h>
  #include <errno.h>
  #include <string.h>
  #include <time.h>
  #include <signal.h>
  #include <sys/types.h>
  #include <sys/socket.h>
  #include <netinet/in.h>
  #include <arpa/inet.h>

#ifndef TRUE
  #define TRUE 1
  #define FALSE 0
  #endif

extern int mkaddr(
                    void *addr,
                    int *addrlen,
                    char *str_addr,
                    char *protocol);

/*
 * This function reports the error and
 * exits back to the shell:
 */
 static void
 displayError(const char *on_what) {
     fputs(strerror(errno),stderr);
     fputs(": ",stderr);
     fputs(on_what,stderr);
     fputc('\n',stderr);
     exit(1);
}

int
 main(int argc,char **argv) {
     int z;
     int x;
     struct sockaddr_in adr;  /* AF_INET */
     int len_inet;            /* length */
     int s;                   /* Socket */
     char dgram[512];         /* Recv buffer */
     static int so_reuseaddr = TRUE;
     static char
     *bc_addr = "127.255.255.2:9097";

/*
     * Use a server address from the command
     * line, if one has been provided.
     * Otherwise, this program will default
     * to using the arbitrary address
     * 127.0.0.:
     */
     if ( argc > 1 )
     /* Broadcast address: */
        bc_addr = argv[1];

/*
     * Create a UDP socket to use:
     */
     s = socket(AF_INET,SOCK_DGRAM,0);
     if ( s == -1 )
        displayError("socket()");

/*
     * Form the broadcast address:
     */
     len_inet = sizeof adr;

z = mkaddr(&adr,
                &len_inet,
                bc_addr,
                "udp");

if ( z == -1 )
        displayError("Bad broadcast address");

/*
     * Allow multiple listeners on the
     * broadcast address:
     */
     z = setsockopt(s,
                    SOL_SOCKET,
                    SO_REUSEADDR,
                    &so_reuseaddr,
                    sizeof so_reuseaddr);

if ( z == -1 )
        displayError("setsockopt(SO_REUSEADDR)");

/*
     * Bind our socket to the broadcast address:
     */
     z = bind(s,
             (struct sockaddr *)&adr,
             len_inet);

if ( z == -1 )
        displayError("bind(2)");

for (;;) {
        /*
         * Wait for a broadcast message:
         */
         z = recvfrom(s,      /* Socket */
                      dgram,  /* Receiving buffer */
                      sizeof dgram,/* Max rcv buf size */
                      0,      /* Flags: no options */
                      (struct sockaddr *)&adr, /* Addr */
                      &x);    /* Addr len, in & out */

if ( z < 0 )
            displayError("recvfrom(2)"); /* else err */

fwrite(dgram,z,1,stdout);
         putchar('\n');

fflush(stdout);
     }

return 0;
 }

The general steps used by the client program are these:

The socket is created (lines 68 to 70).
The broadcast address is formed (lines 75 to 83).
The SO_REUSEADDR option is enabled (lines 89 to 96).
Bind the broadcast address to the current socket (lines 101 to 106).
Begin a broadcast receiving loop (line 108).
Receive a broadcast (lines 112 to 120).
Write the broadcast information to the standard output (lines 122 to 125).
Repeat step 5.

Pay special attention to step 4. To receive the broadcast, there has to be a client program that has this
address bound to the socket. This identifies the client program as the intended recipient of the
messages. 

There is a problem with this approach, however. If one client program binds this address, then no
others on the same host will be able to bind that address. This would defeat the purpose of
broadcasting. Enabling SO_REUSEADDR allows multiple client programs to receive from the same
broadcast address, on the same host. 

To compile the demonstration client program, you can use the following command: 

Take this mkaddr.c file for compiling the code

Output

[root@rhel54x64 socket]# gcc -c -D_GNU_SOURCE -Wall -Wreturn-type -g udp-broadcast-client.c

[root@rhel54x64 socket]# gcc -c -D_GNU_SOURCE -Wall -Wreturn-type -g mkaddr.c

[root@rhel54x64 socket]# gcc -g udp-broadcast-client.o mkaddr.o -o udp-broadcast-client

Here is the complete udp broadcast client-server application

Friday, September 9, 2011

udp broadcast server c

/* udp-broadcast-server.c:
  * udp broadcast server example 
  * Example Stock Index Broadcast:
  */
  #include <stdio.h>
  #include <unistd.h>
  #include <stdlib.h>
  #include <errno.h>
  #include <string.h>
  #include <time.h>
  #include <sys/types.h>
  #include <sys/socket.h>
  #include <netinet/in.h>
  #include <arpa/inet.h>
 
  #ifndef TRUE
  #define TRUE 1
  #define FALSE 0
  #endif
 
  extern int mkaddr(
 				    void *addr,
				    int *addrlen,
				    char *str_addr,
				    char *protocol);
 
  #define MAXQ 4
 
  static struct {
	  char *index;
	  int start;
	  int volit;
	  int current;
  } quotes[] = {
	  { "DJIA", 1030330, 375 },
	  { "NASDAQ", 276175, 125 },
	  { "S&P 500", 128331, 50 },
	  { "TSE 300", 689572, 75 },
  };
 
 /*
  * Initialize:
  */
  static void
  initialize(void) {
	  short x;
	  time_t td;
	 
	  /*
	  * Seed the random number generator:
	  */
	  time(&td);
	  srand((int)td);
	 
	  for ( x=0; x < MAXQ; ++x )
	  quotes[x].current =
	  quotes[x].start;
  }
 
 /*
  * Randomly change one index quotation:
  */
  static void
  gen_quote(void) {
	  short x;    /* Index */
	  short v;    /* Volatility of index */
	  short h;    /* Half of v */
	  short r;    /* Random change */
	 
	  x = rand() % MAXQ;
	  v = quotes[x].volit;
	  h = (v / 2) - 2;
	  r = rand() % v;
	  if ( r < h )
		r = -r;
	  quotes[x].current += r;
  }
 
 /*
  * This function reports the error and
  * exits back to the shell:
  */
  static void
  displayError(const char *on_what) {
	  fputs(strerror(errno),stderr);
	  fputs(": ",stderr);
	  fputs(on_what,stderr);
	  fputc('\n',stderr);
	  exit(1);
  }
 
  int
  main(int argc,char **argv) {
	  short x;    /* index of Stock Indexes */
	  double I0;  /* Initial index value */
	  double I;   /* Index value */
	  char bcbuf[512], *bp;/* Buffer and ptr */
	  int z;      /* Status return code */
	  int s;      /* Socket */
	  struct sockaddr_in adr_srvr;/* AF_INET */
	  int len_srvr;               /* length */
	  struct sockaddr_in adr_bc;  /* AF_INET */
	  int len_bc;                 /* length */
	  static int so_broadcast = TRUE;
	  static char
	  *sv_addr = "127.0.0.:*",
	  *bc_addr = "127.255.255.2 9097";
	 
     /*
	  * Form a server address:
	  */
	  if ( argc > 2 )
	  /* Server address: */
	  sv_addr = argv[2];
	 
	  if ( argc > 1 )
	  /* Broadcast address: */
	  bc_addr = argv[1];
	 
	 /*
	  * Form the server address:
	  */
	  len_srvr = sizeof adr_srvr;

z = mkaddr(
	 		  &adr_srvr,  /* Returned address */
			  &len_srvr,  /* Returned length */
			  sv_addr,    /* Input string addr */
			  "udp");     /* UDP protocol */

if ( z == -1 )
		displayError("Bad server address");
	 
	 /*
	  * Form the broadcast address:
	  */
	  len_bc = sizeof adr_bc;
	 
	  z = mkaddr(
		  &adr_bc, /* Returned address */
		  &len_bc, /* Returned length */
		  bc_addr, /* Input string addr */
		  "udp"); /* UDP protocol */
	 
	  if ( z == -1 )
		displayError("Bad broadcast address");
	 
	 /*
	  * Create a UDP socket to use:
	  */
	  s = socket(AF_INET,SOCK_DGRAM,0);
	  if ( s == -1 )
		displayError("socket()");
	 
	 /*
	  * Allow broadcasts:
	  */
	  z = setsockopt(s,
					 SOL_SOCKET,
					 SO_BROADCAST,
					 &so_broadcast,
					 sizeof so_broadcast);
	 
	  if ( z == -1 )
		displayError("setsockopt(SO_BROADCAST)");

/*
	  * Bind an address to our socket, so that
	  * client programs can listen to this
	  * server:
	  */
	  z = bind(s,
			  (struct sockaddr *)&adr_srvr,
			  len_srvr);
	 
	  if ( z == -1 )
		displayError("bind()");
	 
	 /*
	  * Now start serving quotes:
	  */
	  initialize();
	 
	  for (;;) {
		 /*
		  * Update one quote in the list:
		  */
		  gen_quote();
		 
		 /*
		  * Form a packet to send out:
		  */
		  bp = bcbuf;
		  for ( x=0; x<MAXQ; ++x ) {
			  I0 = quotes[x].start / 100.0;
			  I = quotes[x].current / 100.0;
			  sprintf(bp,
					  "%-7.7s %8.2f %+.2f\n",
					  quotes[x].index,
					  I,
					  I - I0);
			  bp += strlen(bp);
		  }

/*
		  * Broadcast the updated info:
		  */
		  z = sendto(s,
					 bcbuf,
					 strlen(bcbuf),
					 0,
					(struct sockaddr *)&adr_bc,
					len_bc); 
		 
		  if ( z == -1 )
			displayError("sendto()");

sleep(4);
	  }
	 
	  return 0;
  }

Here is the step by step code flow of the abover udp server: The server shown in Listing above is functionally divided into the following sections:

The table of stock market indexes is declared in lines 27 to 39. Four indexes are defined with starting values and a crude form of volatility value, which is used for the simulation.
The function initialize() in lines 44 to 58 is called once to initialize for the simulation.
The function gen_quote() is called to randomly change the simulated value of a randomly selected stock market index (lines 63 to 77).
The main() program, which forms the basis of the server, is contained within lines 92 to 222.

The basic operation of this stock market server is as follows:

Default addresses are declared in lines 106 and 107. These are used when no command-line arguments are supplied.
If two command-line arguments are supplied, then the server address takes the address from the second argument (line 114).
If one or more command-line arguments are supplied, then the broadcast argument is taken from argument one (line 118).
The server address is formed (lines 123 to 132).
The broadcast address is formed (lines 137 to 146).
A socket is created (lines 151 to 153).
The SO_BROADCAST option is enabled on the socket (lines 158 to 165).
The server address is bound (lines 172 to 177).
The stock market indices are initialized (line 182).
The server loop begins in line 184.

Compiling the above server:

Take this version of mkaddr.c

[root@rhel54x64 socket]# gcc -c -D_GNU_SOURCE -Wall -Wreturn-type -g udp-broadcast-server.c

[root@rhel54x64 socket]# gcc -c -D_GNU_SOURCE -Wall -Wreturn-type -g mkaddr.c

[root@rhel54x64 socket]# gcc -g udp-broadcast-server.o mkaddr.o -o udp-broadcast-server

Here is the complete udp broadcast client-server application

mkaddr c code

There is another version of mkaddr.c subroutine which is using inet_addr. The problem with inet_addr(3) is that it returns the value INADDR_NONE when an address is invalid. When the IP address 255.255.255.255 is converted to a 32-bit value, its return value is identical to the constant INADDR_NONE. Consequently, it becomes impossible to distinguish between a bad input IP address, and the general broadcast address. Use of the inet_aton(3) function avoids this ambiguity.

/* mkaddr.c
  * The mkaddr() Subroutine using inet_aton
  * Make a socket address:
  */
  #include <stdio.h>
  #include <unistd.h>
  #include <stdlib.h>
  #include <errno.h>
  #include <ctype.h>
  #include <string.h>
  #include <sys/types.h>
  #include <sys/socket.h>
  #include <netinet/in.h>
  #include <arpa/inet.h>
  #include <netdb.h>
 
 /*
  * Create an AF_INET Address:
  *
  * ARGUMENTS:
  * 1. addr Ptr to area
  * where address is
  * to be placed.
  * 2. addrlen Ptr to int that
  * will hold the final
  * address length.
  * 3. str_addr The input string
  * format hostname, and
  * port.
  * 4. protocol The input string
  * indicating the
  * protocol being used.
  * NULL implies  tcp .
  * RETURNS:
  * 0 Success.
  * -1 Bad host part.
  * -2 Bad port part.
  *
  * NOTES:
  *  *  for the host portion of the
  * address implies INADDR_ANY.
  *
  *  *  for the port portion will
  * imply zero for the port (assign
  * a port number).
  *
  * EXAMPLES:
  *  www.lwn.net:80 
  *  localhost:telnet 
  *  *:21 
  *  *:* 
  *  ftp.redhat.com:ftp 
  *  sunsite.unc.edu 
  *  sunsite.unc.edu:* 
  */
  int mkaddr(void *addr,
             int *addrlen,
             char *str_addr,
             char *protocol) {
 
  char *inp_addr = strdup(str_addr);
  char *host_part = strtok(inp_addr, ":" );
  char *port_part = strtok(NULL, "\n" );
  struct sockaddr_in *ap =
  (struct sockaddr_in *) addr;
  struct hostent *hp = NULL;
  struct servent *sp = NULL;
  char *cp;
  long lv;
 
 /*
  * Set input defaults:
  */
  if ( !host_part ) {
	host_part =  "*" ;
  }
  if ( !port_part ) {
	port_part =  "*" ;
  }
  if ( !protocol ) {
	protocol =  "tcp" ;
  }
 
 /*
  * Initialize the address structure:
  */
  memset(ap,0,*addrlen);
  ap->sin_family = AF_INET;
  ap->sin_port = 0;
  ap->sin_addr.s_addr = INADDR_ANY;
 
 /*
  * Fill in the host address:
  */
  if ( strcmp(host_part, "*" ) == 0 ) {
	; /* Leave as INADDR_ANY */
  }
  else if ( isdigit(*host_part) ) {
   /*
	* Numeric IP address:
	*/
	ap->sin_addr.s_addr =
	inet_addr(host_part);
	// if ( ap->sin_addr.s_addr == INADDR_NONE ) {
	if ( !inet_aton(host_part,&ap->sin_addr) ) {
           return -1;
	}
  } 
  else {
 /*
  * Assume a hostname:
  */
	hp = gethostbyname(host_part);
	if ( !hp ) {
		return -1;
	}
	if ( hp->h_addrtype != AF_INET ) {
		return -1;
	}
	ap->sin_addr = * (struct in_addr *)
					  hp->h_addr_list[0];
  }
 
 /*
  * Process an optional port #:
  */
  if ( !strcmp(port_part, "*" ) ) {
	/* Leave as wild (zero) */
  }
  else if ( isdigit(*port_part) ) {
 /*
  * Process numeric port #:
  */
	lv = strtol(port_part,&cp,10);
	if ( cp != NULL && *cp ) {
		return -2;
	}
	if ( lv < 0L || lv >= 32768 ) {
		return -2;
	}
	ap->sin_port = htons( (short)lv);
  } 
  else {
 /*
  * Lookup the service:
  */
	sp = getservbyname( port_part, protocol);
	if ( !sp ) {
		return -2;
	}
	ap->sin_port = (short) sp->s_port;
  }
 
 /* 
  * Return address length 
  */
  *addrlen = sizeof *ap;
 
  free(inp_addr);
  return 0;
  }

Here is the complete udp broadcast client-server application

Tuesday, September 6, 2011

getsockopt so_type example c code

/* gettype.c:
  * Retrieving the Socket Type (SO_TYPE) using getsockopt
  * Get SO_TYPE Option:
  */
  #include <stdio.h>
  #include <unistd.h>
  #include <stdlib.h>
  #include <errno.h>
  #include <string.h>
  #include <sys/types.h>
  #include <sys/socket.h>
  #include <assert.h>
 
 /*
  * This function reports the error and
  * exits back to the shell:
  */
  static void displayError(const char *on_what) {
	  if ( errno != 0 ) {
		  fputs(strerror(errno),stderr);
		  fputs(": ",stderr);
	  }
	  fputs(on_what,stderr);
	  fputc('\n',stderr);
	  exit(1);
  }
 
  int main(int argc,char **argv) {
	  int z;
	  int s = -1;       /* Socket */
	  int so_type = -1; /* Socket type */
	  socklen_t optlen; /* Option length */
	 
	 /*
	  * Create a TCP/IP socket to use:
	  */
	  s = socket(PF_INET,SOCK_STREAM,0);
	  if ( s == -1 ) {
		displayError("socket(2)");
	  }
	 
	 /*
	  * Get socket option SO_SNDBUF:
	  */
	  optlen = sizeof so_type;
	  z = getsockopt(s,
	                 SOL_SOCKET,
					 SO_TYPE,
	                 &so_type,
					 &optlen);
	  if ( z ) {
		displayError("getsockopt(s,SOL_SOCKET," 
  		             "SO_TYPE)");
	  }
	 
	  assert(optlen == sizeof so_type);
	 
	 /*
	  * Report the buffer sizes:
	  */
	  printf("Socket s : %d\n",s);
	  printf(" SO_TYPE : %d\n",so_type);
	  printf(" SOCK_STREAM = %d\n", SOCK_STREAM);
	 
	  close(s);
	  return 0;
  }
  /*
   * OUTPUT
   *
   [sgupta@rhel54x64 socket]$ gcc getty.c -o getty
   [sgupta@rhel54x64 socket]$ ./getty
   Socket s : 3
   SO_TYPE : 1
   SOCK_STREAM = 1
   [sgupta@rhel54x64 socket]$
   */

Monday, September 5, 2011

setsockopt example c code

/* setsndrcv.c:
  * setsockopt sample c code
  * using setsockopt function
  * Set SO_SNDBUF & SO_RCVBUF Options:
  */
  #include <stdio.h>
  #include <unistd.h>
  #include <stdlib.h>
  #include <errno.h>
  #include <string.h>
  #include <sys/types.h>
  #include <sys/socket.h>
  #include <assert.h>
 
 /*
  * This function reports the error and
  * exits back to the shell:
  */
  static void
  displayError(const char *on_what) {
	  if ( errno != 0 ) {
		  fputs(strerror(errno),stderr);
		  fputs(": ",stderr);
	  }
	  fputs(on_what,stderr);
	  fputc('\n',stderr);
	  exit(1);
  }
 
  int
  main(int argc,char **argv) {
	  int z;
	  int s = -1;        /* Socket */
	  int sndbuf=0;      /* Send buffer size */
	  int rcvbuf=0;      /* Receive buffer size */
	  socklen_t optlen;  /* Option length */
	 
	 /*
	  * Create a TCP/IP socket to use:
	  */
	  s = socket(PF_INET,SOCK_STREAM,0);
	  if ( s == -1 ) {
		displayError("socket(2)");
	  }
	 
	 /*
	  * Set the SO_SNDBUF Size:
	  */
	  sndbuf = 5000;  /* Send buffer size */
	  z = setsockopt(s,
	                 SOL_SOCKET,
					 SO_SNDBUF,
	                 &sndbuf,
					 sizeof sndbuf);
	  if ( z ) {
		displayError("setsockopt(s,SOL_SOCKET,"
		"SO_SNDBUF)");
	  }
	 
	 /*
	  * Set the SO_RCVBUF Size:
	  */
	  rcvbuf = 8192;  /* Send buffer size */
	  z = setsockopt(s,
	                 SOL_SOCKET,
					 SO_RCVBUF,
	                 &rcvbuf,
					 sizeof rcvbuf);
	  if ( z ) {
		 displayError("setsockopt(s,SOL_SOCKET,"
		 "SO_RCVBUF)");
      }	 
	 /*
	  * As a check on the above . . .
	  * Get socket option SO_SNDBUF:
	  */
	  optlen = sizeof sndbuf;
	  z = getsockopt(s,
	                 SOL_SOCKET,
					 SO_SNDBUF,
	                 &sndbuf,
					 &optlen);
	  if ( z ) {
    	 displayError("getsockopt(s,SOL_SOCKET,"
	     "SO_SNDBUF)");
	  }
	 
	  assert(optlen == sizeof sndbuf);
	 
	 /*
	  * Get socket option SO_SNDBUF:
	  */
	  optlen = sizeof rcvbuf;
	  z = getsockopt(s,
	                 SOL_SOCKET,
					 SO_RCVBUF,
	                 &rcvbuf,
					 &optlen);
	  if ( z ) {
	     displayError("getsockopt(s,SOL_SOCKET,"
	     "SO_RCVBUF)");
	  }
	 
	  assert(optlen == sizeof rcvbuf);
	 
	 /*
	  * Report the buffer sizes:
	  */
	  printf("Socket s : %d\n",s);
	  printf(" Send buf: %d bytes\n", sndbuf);
	  printf(" Recv buf: %d bytes\n", rcvbuf);
	 
	  close(s);
	  return 0;
  }
  
  /*
   * OUTPUT
   *
   [sgupta@rhel54x64 socket]$ gcc setsndrcv.c -o setsndrcv
   [sgupta@rhel54x64 socket]$ ./setsndrcv
   Socket s : 3
   Send buf: 10000 bytes
   Recv buf: 16384 bytes
   [sgupta@rhel54x64 socket]$
   */

getsockopt example c code

/* getsndrcv.c:
  * getsockopt sample c code
  * using getsockopt
  * Get SO_SNDBUF & SO_RCVBUF Options:
  */
  #include <stdio.h>
  #include <unistd.h>
  #include <stdlib.h>
  #include <errno.h>
  #include <string.h>
  #include <sys/types.h>
  #include <sys/socket.h>
  #include <assert.h>
 
 /*
  * This function reports the error and
  * exits back to the shell:
  */
  static void
  displayError(const char *on_what) {
	  if ( errno != 0 ) {
		  fputs(strerror(errno),stderr);
		  fputs(": ",stderr);
	  }
	  fputs(on_what,stderr);
	  fputc('\n',stderr);
	  exit(1);
  }
 
  int main(int argc,char **argv) {
	  int z;
	  int s = -1;       /* Socket */
	  int sndbuf=0;     /* Send buffer size */
	  int rcvbuf=0;     /* Receive buffer size */
	  socklen_t optlen; /* Option length */
	 
     /*
	  * Create a TDP/IP socket to use:
	  */
	  s = socket(PF_INET,SOCK_STREAM,0);
	  if ( s == -1 ) {
		displayError("socket(2)");
	  }
	 
	 /*
	  * Get socket option SO_SNDBUF:
	  */
	  optlen = sizeof sndbuf;
	  z = getsockopt(s,
	                 SOL_SOCKET,
					 SO_SNDBUF,
	                 &sndbuf,&optlen);
	  if ( z ) {
		displayError("getsockopt(s,SOL_SOCKET," 
      	             "SO_SNDBUF)");
	  }
	 
	  assert(optlen == sizeof sndbuf);
	 
	 /*
	  * Get socket option SO_SNDBUF:
	  */
	  optlen = sizeof rcvbuf;
	  z = getsockopt(s,
	                 SOL_SOCKET,
					 SO_RCVBUF,
	                 &rcvbuf,&optlen);
	  if ( z ) {
		displayError("getsockopt(s,SOL_SOCKET,"
		             "SO_RCVBUF)");
	  }
	 
	  assert(optlen == sizeof rcvbuf);
	 
	 /*
	  * Report the buffer sizes:
	  */
	  printf( "Socket s : %d\n",s);
	  printf( "Send buf: %d bytes\n", sndbuf);
	  printf( "Recv buf: %d bytes\n", rcvbuf);
	 
	  close(s);
	  return 0;
  }

/*
  * OUTPUT
  *
  [sgupta@rhel54x64 socket]$ gcc getsndrcv.c -o getsndrcv
  [sgupta@rhel54x64 socket]$ ./getsndrcv 
  Socket s : 3
  Send buf: 16384 bytes
  Recv buf: 87380 bytes
  [sgupta@rhel54x64 socket]$
  */

Wednesday, August 31, 2011

RPN main server code

Previous to this I have presented the RPN calculator code Now here is the server code to work with that. Below I am also presenting how to work with the RPN Server also. First let us present the server code, if you feel any difficulty in understanding the code post me I will give you the explanations step by step

/* rpnsrv.c:
 *
 * Example RPN Server:
 */
  #include <stdio.h>
  #include <unistd.h>
  #include <stdlib.h>
  #include <errno.h>
  #include <string.h>
  #include <time.h>
  #include <sys/types.h>
  #include <sys/socket.h>
  #include <netinet/in.h>
  #include <arpa/inet.h>
  #include <netdb.h>
 
  #ifndef SHUT_RDWR
  #define SHUT_RDWR 3
  #endif
 
  extern int mkaddr(void *addr,
                    int *addr_len,
                    char *input_address,
                    char *protocol);
 
  extern void rpn_process(FILE *tx, char *buf);
 
 
 /*
  * This function reports the error and
  * exits back to the shell:
  */
  static void
  displayError(const char *on_what) {
	  if ( errno != 0 ) {
		  fputs(strerror(errno),stderr);
		  fputs(": ",stderr);
	  }
	  fputs(on_what,stderr);
	  fputc('\n',stderr);
	  exit(1);
  }
 
  int
  main(int argc,char **argv) {
	  int z;
	  char *srvr_addr = "127.0.0.:9090";
	  struct sockaddr_in adr_srvr;/* AF_INET */
	  struct sockaddr_in adr_clnt;/* AF_INET */
	  int len_inet;               /* length */
	  int s = -1;                 /* Socket */
	  int c = -1;                 /* Client socket */
	  FILE *rx = NULL;            /* Read stream */
	  FILE *tx = NULL;            /* Write stream */
	  char buf[4096];             /* I/O Buffer */
	 
	 /*
	  * Use a server address from the command
	  * line, otherwise default to 127.0.0.:
	  */
	  if ( argc >= 2 ) {
		srvr_addr = argv[1];
	  }
	 
	  len_inet = sizeof adr_srvr;
	  z = mkaddr(&adr_srvr,
	             &len_inet,
           	     srvr_addr,"tcp");
	 
	  if ( z < 0 || !adr_srvr.sin_port ) {
		  fprintf(stderr,"Invalid server "
		  "address, or no port number "
		  "was specified.\n");
		  exit(1);
	  }
	 
	 /*
	  * Create a TCP/IP socket to use:
	  */
	  s = socket(PF_INET,SOCK_STREAM,0);
	  if ( s == -1 ) {
		displayError("socket(2)");
	  }
	 
	 /*
	  * Bind the server address:
	  */
	  z = bind(s,
	           (struct sockaddr *)&adr_srvr,
	           len_inet);
	  if ( z == -1 ) {
		displayError("bind(2)");
	  }
	 
	 /*
	  * Make it a listening socket:
	  */
	  z = listen(s,10);
	  if ( z == -1 ) {
		displayError("listen(2)");
	  }
	 
	 /*
	  * Start the server loop:
	  */
	  for (;;) {
		 /*
		  * Wait for a connect:
		  */
		  len_inet = sizeof adr_clnt;
		  c = accept(s,
 		            (struct sockaddr *)&adr_clnt,
	 	            &len_inet);
		  if ( c == -1 ) {
			displayError("accept(2)");
		  }
		 
		 /*
		  * Create streams:
		  */
		  rx = fdopen(c,"r");
		  if ( !rx ) {
			  /* Failed */
			  close(c);
			  continue;
		  }

tx = fdopen(dup(c),"w");
		  if ( !tx ) {
			 fclose(rx);
			 continue;
		  }
		 
		 /*
		  * Set both streams to line
		  * buffered mode:
		  */
		  setlinebuf(rx);
		  setlinebuf(tx);
		 
		 /*
		  * Process client's requests:
		  */
		  while ( fgets(buf,sizeof buf,rx) )
			rpn_process(tx,buf);
		 
		 /*
		  * Close this client's connection:
		  */
		  fclose(tx);
		  shutdown(fileno(rx),SHUT_RDWR);
		  fclose(rx);
	  }
	 
	  /* Control never gets here */
	  return 0;
 }

Trying out the RPN Server

Here are all the files

rpneng.c
mkaddr.c

To compile all the related source modules for the RPN server, you can perform the following make command:

Output
gcc -c -D_GNU_SOURCE -Wall -Wreturn-type rpnsrv.c
gcc -c -D_GNU_SOURCE -Wall -Wreturn-type rpneng.c
gcc -c -D_GNU_SOURCE -Wall -Wreturn-type mkaddr.c
gcc rpnsrv.o rpneng.o mkaddr.o -o rpnsrv -lgmp

After the executable rpnsrv for the server has been created, you can start the server as follows:

Output
$ ./rpnsrv &
[1] 13321
$

In the output shown, the server was started with a process ID of 13321, and run in the background. To keep things simple at this point, you'll just use the telnet command to try out the server. The
next chapter will fully outline this server's functions. For now, just try some simple tests.

CAUTION
The server presented is not a production-grade server. Some forms of incorrect input can provoke the server to abort. The RPN calculator computes based upon numbers that are pushed onto the stack. To perform the add operation, for example, requires at least two numbers to exist on the stack. To push a number onto the stack, you will enter a line as follows:

#:970976453

After you press Enter, the server will respond with something like this:
0:

This tells you that the number has been stacked at the bottom of the stack (entry number zero). To stack another number, simply do the same, as follows:

#:2636364
The server will respond with
1:

This indicates that the number 2636364 was stacked at position 1, although the original number 970976453 still sits at the bottom of the stack at position 0. You can list the current contents of
the stack by entering the following:

dump

The following example shows what the session and its output might look like this:
Output

$ telnet localhost 9090
Trying 127.0.0.1 . . .
Connected to localhost.
Escape character is '^]'.
#:970976453
0:
#:2636364
1:
dump
1:2636364
0:970976453
E:end of stack dump

To perform a binary operation, you simply enter the name of the operation or its symbol. For example, to add these numbers, you would just enter the + character and press return. The session
repeated without entering the dump command would appear as follows if the + operation was performed, and then followed by the = operation:

Output
$ telnet localhost 9090
Trying 127.0.0.1 . . .
Connected to localhost.
Escape character is '^]'.
#:970976453
0:
#:2636364
1:
+
0:
=
0:973612817
^]
telnet> c
Connection closed.
$

The + operation caused the two stacked numbers to be added together, and the result replaced the two original values. The = operator here pops the result off the stack and displays it for you. To exit the server, type CTRL+] and you will be prompted with the prompt:

telnet>

From there, enter a c to indicate that you want the session closed, and press Enter. To terminate the server, just use the kill command.
Take a few minutes now to have some fun with the new RPN calculating server program. Restart the server, and see whether you can figure out how to compute the equation (3 + 2) * (2 + 4) using the
calculating server just presented.

The RPN Calculator Engine C Code

The RPN calculator engine code will be presented next. It is not expected that you will understand all of the GMP function calls because they have not been presented. However, if you have Red Hat Enterprise Linux installed, you can find out more about the GMP calls by performing the following command:

$ info GMP

This will bring up the info viewer with documentation about the GMP function library. Listing 10.5 lists the RPN calculator code. Note especially the standard I/O calls in the functions rpn_dump() and rpn_process().

/* rpneng.c:
  *
  * RPN Engine:
  */
  #include <stdio.h>
  #include <stdlib.h>
  #include <errno.h>
  #include <string.h>
  #include <limits.h>
  #include <gmp.h>
 
  typedef void (*mpz_func)(mpz_t,
  const mpz_t,const mpz_t);
  typedef void (*mpz_unary)(mpz_t,const mpz_t);
  typedef int (*rpn_spec)(void);
 
 /*
  * RPN Stack:
  */
  #define MAX_STACK 32
  static mpz_t *stack[MAX_STACK];
  static int sp = 0;
 
 /*
  * Allocate a new mpz_t value:
  */
  static mpz_t *
  rpn_alloc(void) {
      mpz_t *v = malloc(sizeof(mpz_t));
      mpz_init(*v);
      return v;
  }
 
 /*
  * Duplicate a mpz_t value:
  */
  static mpz_t *
  rpn_duplicate(mpz_t *value) {
      mpz_t *v = rpn_alloc();     
      mpz_set(*v,*value);
      return v;
  }
 
 /*
  * Free an allocated mpz_t value:
  */
  static void
  rpn_free(mpz_t **v) {
      mpz_clear(**v);
      free(*v);
      *v = NULL;
  }
 
 /*
  * Push an mpz_t value onto the stack:
  */
  static int
  rpn_push(mpz_t *value) {
      if ( sp >= MAX_STACK )
      return -1;
      stack[sp] = value;
      return sp++;
  }
 
  /*
  * Pop a mpz_t value from the stack:
  */
  static int
  rpn_pop(mpz_t **value) {
      if ( sp <= 0 )
      return -1;
      *value = stack[--sp];
      return sp;
  }
 
  /*
  * Duplicate the top value on the stack:
  */
  static int
  rpn_dup(void) {
      mpz_t *opr2;
     
      if ( sp <=  0)
      return -1;
     
      opr2 = rpn_alloc();
      mpz_set(*opr2,*stack[sp-1]);
      return rpn_push(opr2);
  }
 
 /*
  * Swap the top two values on the stack:
  */
  static int
  rpn_swap(void) {
      mpz_t *opr1, *opr2;
     
      if ( sp < 0 )
      return -1;
     
      rpn_pop(&opr1);
      rpn_pop(&opr2) ;
      rpn_push(opr1);
      return rpn_push(opr2);
  }
 
 /*
  * Dump the stack:
  */
  static void
  rpn_dump(FILE *tx) {
      int sx;
      for ( sx=sp-1; sx >= 0; --sx ) {
          fprintf(tx,"%d:",sx);
          mpz_out_str(tx,10,*stack[sx]);
          fputc('\n',tx);
      }
      fputs("E:end of stack dump\n",tx);
  }
 
 /*
  * Operation "seed":
  *
  * OPERANDS:
  * : the least significant 3 bits
  * will seed the random number
  * generator via srand(3):
  * RESULTS:
  * none.
  */
  static int
  rpn_seed(void) {
      int z;
      mpz_t *opr;
      long lv;
     
      if ( (z = rpn_pop(&opr)) <  0)
      /* No operand available */
      return -1;
     
     /*
      * Get long value, ignoring errors.
      * Then seed the random number
      * generator:
      */
      lv = mpz_get_si(*opr);
      srand((int)lv);
     
      rpn_free(&opr);
      return z;
  }
 
 /*
  * Operation "random":
  *
  * OPERANDS:
  * 1. A modulo value to apply after
  * the random number is generated.
  * RESULTS:
  * 1. A random value:  < modulo value.
  */
  static int
  rpn_random(void) {
      mpz_t *opr, *res;
      mpz_t r;
      size_t limbs;
     
      if ( rpn_pop(&opr) <  0)
      /* No operand available */
      return -1;
     
      mpz_init(r);
      res = rpn_alloc();
     
     /*
      * Pop the top to use as the modulo
      * operand. Generate a random number
      * r. Then compute r % opr as the
      * final result:
      */
      limbs = mpz_size(*opr);
      mpz_random(r,limbs);
      mpz_tdiv_r(*res,r,*opr);
     
      mpz_clear(r);
      rpn_free(&opr);
     
      return rpn_push(res);
  }
 
 /*
  * Operation "tprime":
  *
  * Test for probability of being
  * a prime number:
  *
  * OPERANDS:
  * 1. Number to test
  * 2. Number of tests to try
  * (typically 25)
  * RESULTS:
  * 1. Number tested is probably
  * prime when value = 1.
  * Number tested is not prime
  * when result is zero.
  */
  static int
  rpn_test_prime(void) {
      mpz_t *opr1, *opr2;
      long reps;
      int z;
     
      if ( sp < 2 )
      /* Insufficient operands */
      return -1;
     
      rpn_pop(&opr1);
      rpn_pop(&opr2);
     
      if ( mpz_size(*opr2) >  1)
      /* Too many limbs in size */
      return -1;
     
      reps = mpz_get_si(*opr2);
      if ( reps < 1L || reps > 32768L )
      /* Too large for opr */
      return -1;
     
      z = mpz_probab_prime_p(*opr1,reps);
      mpz_set_si(*opr1,(long)z);
      rpn_free(&opr2);
     
      return rpn_push(opr1);
  }
 
 /*
  * Operation "genprime":
  *
  * Generate a random prime number.
  *
  * OPERANDS:
  * 1. The modulo value to apply
  * to the randomizing value
  * (see "random").
  * 2. The number of primality
  * tests to perform (typically
  * this value is 25).
  * RESULTS:
  * 1. The randomly generated prime
  * number (actually, only a high
  * probability of being prime).
  */
  static int
  rpn_genprime(void) {
      mpz_t *opr1;
      mpz_t *opr2;
      mpz_t *res;
     
      if ( sp <  2)
      return -1;
     
      rpn_pop(&opr1);
      rpn_pop(&opr2);
     
      for (;;) {
      rpn_push(rpn_duplicate(opr1));
      rpn_random();
      rpn_dup();
      rpn_push(rpn_duplicate(opr2));
      rpn_swap();
      rpn_test_prime();
      rpn_pop(&res);
      if ( mpz_cmp_si(*res,0L) !=  0)
      break;
      rpn_free(&res);
      rpn_pop(&res);
      rpn_free(&res);
      }
     
      rpn_free(&res);
      rpn_free(&opr2);
      rpn_free(&opr1);
     
      return sp - 1;
  }
 
 /*
  * Standard binary arithmetic operations:
  *
  * OPERANDS:
  * 1. Operand 2
  * 2. Operand 1
  *
  * RESULTS:
  * 1. Operand  op Operand 2
  */
  static int
  rpn_binoper(mpz_func f) {
      mpz_t *res, *opr1, *opr2;
     
      if ( sp <  2)
      /* Insufficient operands */
      return -1;
     
      res = rpn_alloc();
      rpn_pop(&opr2);
      rpn_pop(&opr1);
     
      f(*res,*opr1,*opr2);
     
      rpn_free(&opr1);
      rpn_free(&opr2);
      return rpn_push(res);
  }
 
 /*
  * Standard Unary Operations:
  *
  * OPERANDS:
  * 1. Operand 1
  *
  * RESULTS:
  * 1. Result of unary operation.
  */
  static int
  rpn_unaryop(mpz_unary f) {
      mpz_t *res, *opr1;
     
      if ( sp <  1)
      /* Insufficient operands */
      return -1;
     
      res = rpn_alloc();
      rpn_pop(&opr1);
     
      f(*res,*opr1);
     
      rpn_free(&opr1);
      return rpn_push(res);
  }
 
 /*
  * Execute RPN operation:
  *
  * RETURNS:
  *  Successful.
  * - Failed.
  */
  static int
  rpn_opr(char *oper) {
      int x;
      static struct {
          char *oper;
          rpn_spec func;
      }
      spec[] = {
          { "dup", rpn_dup },
          { "swap", rpn_swap },
          { "seed", rpn_seed },
          { "random", rpn_random },
          { "tprime", rpn_test_prime },
          { "genprime", rpn_genprime },
          {  }
      };
      static struct {
          char *oper;
          mpz_func func;
      }
      binops[] = {
          { "+", mpz_add },
          { "-", mpz_sub },
          { "*", mpz_mul },
          { "/", mpz_tdiv_q },
          { "%", mpz_tdiv_r },
          { "gcd", mpz_gcd },
          {  }
      };
      static struct {
          char *oper;
          mpz_unary func;
      } 
      unary[] = {
          { "abs", mpz_abs },
          { "neg", mpz_neg },
          { "sqrt", mpz_sqrt },
          {  }
      };
     
     /*
      * Special Cases:
      */
      for ( x=0; spec[x].oper; ++x ) {
        if ( !strcmp(spec[x].oper,oper) ) {
            return spec[x].func();
        }
      }
     /*
      * Test for a match on binary operators:
      */
      for ( x=0; binops[x].oper; ++x ) {
          if ( !strcmp(binops[x].oper,oper) ) {
            return rpn_binoper(binops[x].func);
          }
      }
     /*
      * Test for a match on unary operators:
      */
      for ( x=0; unary[x].oper; ++x ) {
          if ( !strcmp(unary[x].oper,oper) ) {
            return rpn_unaryop(unary[x].func);
          }
      }
      return -1; /* Failed: unknown operator */
  }
 
  void
  rpn_process(FILE *tx,char *buf) {
      int z;
      mpz_t *t;
      char *operation;
      char *operand;
     
      operation=strtok(buf,":\n\r");
      operand=strtok(NULL,"\n\r");
     
      if ( !strcmp(operation,"dump") ) {
        rpn_dump(tx);
      } 
      else if ( !strcmp(operation,"=") ) {
         /*
          * Pop off the result:
          */
          if ( (z = rpn_pop(&t)) == -1 ) {
            fputs("E:Nothing to pop\n",tx);
          }
          else {
              fprintf(tx,"%d:",z);
              mpz_out_str(tx,10,*t);
              fputc('\n',tx);
              rpn_free(&t);
          }
     
      } 
      else if ( !strcmp(operation,"#") ) {
         /*
          * Push an operand onto the stack:
          */
          t = rpn_alloc();
          if ( !mpz_set_str(*t,operand,10) ) {
            fprintf(tx,"%d:\n",rpn_push(t));
          }
          else {
              fputs("E:Invalid number\n",tx);
              rpn_free(&t);
          }
      } else {
     /*
      * Perform an operation:
      */
      z = rpn_opr(operation);
      if ( z == -1 ) {
        fprintf(tx, "E:Operation failed.\n");
      }
      else {
        fprintf(tx,"%d:\n",z);
      }
     
      fflush(tx);
  }
}

How the server works from the client side, will be examined after the remainder of the server code is presented. Listing 10.6 shows the remainder of the server source code. This represents the main program segment of the server.

mkaddr C Subroutine for socket

/* mkaddr.c
  * The mkaddr() Subroutine
  * Make a socket address:
  */
  #include <stdio.h>
  #include <unistd.h>
  #include <stdlib.h>
  #include <errno.h>
  #include <ctype.h>
  #include <string.h>
  #include <sys/types.h>
  #include <sys/socket.h>
  #include <netinet/in.h>
  #include <arpa/inet.h>
  #include <netdb.h>
 
 /*
  * Create an AF_INET Address:
  *
  * ARGUMENTS:
  * 1. addr Ptr to area
  * where address is
  * to be placed.
  * 2. addrlen Ptr to int that
  * will hold the final
  * address length.
  * 3. str_addr The input string
  * format hostname, and
  * port.
  * 4. protocol The input string
  * indicating the
  * protocol being used.
  * NULL implies  tcp .
  * RETURNS:
  * 0 Success.
  * -1 Bad host part.
  * -2 Bad port part.
  *
  * NOTES:
  *  *  for the host portion of the
  * address implies INADDR_ANY.
  *
  *  *  for the port portion will
  * imply zero for the port (assign
  * a port number).
  *
  * EXAMPLES:
  *  www.lwn.net:80 
  *  localhost:telnet 
  *  *:21 
  *  *:* 
  *  ftp.redhat.com:ftp 
  *  sunsite.unc.edu 
  *  sunsite.unc.edu:* 
  */
  int mkaddr(void *addr,
             int *addrlen,
             char *str_addr,
             char *protocol) {
 
  char *inp_addr = strdup(str_addr);
  char *host_part = strtok(inp_addr, ":" );
  char *port_part = strtok(NULL, "\n" );
  struct sockaddr_in *ap =
  (struct sockaddr_in *) addr;
  struct hostent *hp = NULL;
  struct servent *sp = NULL;
  char *cp;
  long lv;
 
 /*
  * Set input defaults:
  */
  if ( !host_part ) {
	host_part =  "*" ;
  }
  if ( !port_part ) {
	port_part =  "*" ;
  }
  if ( !protocol ) {
	protocol =  "tcp" ;
  }
 
 /*
  * Initialize the address structure:
  */
  memset(ap,0,*addrlen);
  ap->sin_family = AF_INET;
  ap->sin_port = 0;
  ap->sin_addr.s_addr = INADDR_ANY;
 
 /*
  * Fill in the host address:
  */
  if ( strcmp(host_part, "*" ) == 0 ) {
	; /* Leave as INADDR_ANY */
  }
  else if ( isdigit(*host_part) ) {
   /*
	* Numeric IP address:
	*/
	ap->sin_addr.s_addr =
	inet_addr(host_part);
	if ( ap->sin_addr.s_addr == INADDR_NONE ) {
		return -1;
	}
  } 
  else {
 /*
  * Assume a hostname:
  */
	hp = gethostbyname(host_part);
	if ( !hp ) {
		return -1;
	}
	if ( hp->h_addrtype != AF_INET ) {
		return -1;
	}
	ap->sin_addr = * (struct in_addr *)
					  hp->h_addr_list[0];
  }
 
 /*
  * Process an optional port #:
  */
  if ( !strcmp(port_part, "*" ) ) {
	/* Leave as wild (zero) */
  }
  else if ( isdigit(*port_part) ) {
 /*
  * Process numeric port #:
  */
	lv = strtol(port_part,&cp,10);
	if ( cp != NULL && *cp ) {
		return -2;
	}
	if ( lv < 0L || lv >= 32768 ) {
		return -2;
	}
	ap->sin_port = htons( (short)lv);
  } 
  else {
 /*
  * Lookup the service:
  */
	sp = getservbyname( port_part, protocol);
	if ( !sp ) {
		return -2;
	}
	ap->sin_port = (short) sp->s_port;
  }
 
 /* 
  * Return address length 
  */
  *addrlen = sizeof *ap;
 
  free(inp_addr);
  return 0;
  }