  IP Keepalive and dropping idle connections? 
 The Question is:
 
I cannot get the drop idle and keep alive TCPIP socket options to work. I have
 experimented using the attached program and 2 Alpha's running the program as
 server on one Alpha and client on the other. Neither server nor client drops
 the connection after I
 physically disconnect one Alpha from the other. And if I after a while then
 physically reconnect the Alpha's then the server continues printing the
 message repeatedly sent from the client (as if nothing happened). I have also
 verified this by running ser
ver and client from the debugger. Neither side drops out of its select() after
 I disconnect one Alpha from the other. I have never yet seen select() return
 with an "exception". Is this where I would see an exception? Both Alpha's are
 running TCPIP v5.0a.
 
Any help is much appreciated.
 
(I ran the attached programs with droptime=10, probetime=-5 and reptime=60)
 
/*
 * This is a testbed for examination of TCPIP sockets.
 * It runs as server or client depending on the commandline args.
 * The server prints the messages received as sent by clients.
 * It is derived from tcpip$examples:tcp_server_ipc.c and tcp_client_ipc.c.
 *
 * The server args are
 *
 *   &lt;local&gt;   : Local interface
 *                 ="": any local interface
 *   &lt;port&gt;    : Port number
 *   &lt;segsize&gt; : Max size of recv() segments
 *                 =0: no segmentation
 *   &lt;droptime&gt;: Wait in seconds until drop of idle connection
 *                 =0: no drop time
 *
 * Examples
 *
 *   mcr &lt;filespec&gt; "" 5678 0 0
 *   mcr &lt;filespec&gt; "192.168.12.34" 5678 5 60
 *
 * The client args are
 *
 *   &lt;local&gt;    : Local interface
 *                  ="": any local interface
 *   &lt;remote&gt;   : Remote interface
 *   &lt;port&gt;     : Port number
 *   &lt;message&gt;  : Any message
 *   &lt;segsize&gt;  : Max size of send() segments
 *                  =0: no segmentation
 *   &lt;probetime&gt;: Wait in seconds until next probe
 *                  &lt;0: enable keepalive
 *                  =0: no probe time
 *   &lt;reptime&gt;  : Wait in seconds until repeat
 *                  &lt;0: do not wait
 *                  =0: no repeat time
 *
 * Examples
 *
 *   mcr &lt;filespec&gt; "" "192.168.12.34" 5678 "Hi there" 0 5 2
 *   mcr &lt;filespec&gt; "192.168.12.34" omega 5678 "Hi there" 0 0 0
 *
 */
#include &lt;ssdef.h&gt;              //SS$_&lt;xyz&gt; sys ser return stati &lt;8-)
#include &lt;stdio.h&gt;              //UNIX 'Standard I/O' Definitions
#include &lt;iodef.h&gt;              //I/O function code defs
#include &lt;starlet.h&gt;            //Sys ser calls
#include &lt;lib$routines.h&gt;       //LIB$ RTL-routine signatures.
#include &lt;string.h&gt;             //String handling function definitions
#include &lt;unixio.h&gt;             //Prototypes for UNIX emulation functions
#include &lt;signal.h&gt;             //UNIX style Signal Value Definitions
#include &lt;errno.h&gt;              //C RTL Unix style error identifiers
#include &lt;in.h&gt;                 //internet system constants and structures
#include &lt;inet.h&gt;               //Network address info.
#include &lt;netdb.h&gt;              //Network database library info.
#include &lt;socket.h&gt;             //TCP/IP socket definitions.
#include &lt;stdlib.h&gt;             //General Utilities
#include &lt;tcpip$inetdef.h&gt;      //TCPIP network definitions
 
static int              Server();
static int              Client();
static void             Cleanup();
static void             VacateMsgBuf();
static int              GetSockTag();
 
main(
int                     argc,
char                    *argv[] )
 
 
  int                   sts, s_t_s, status;
 
 
  /*
   * Check args
   */
  if( argc == 5 )
    sts = Server( argc, argv );
  else
  if( argc == 8 )
    sts = Client( argc, argv );
  else
  {
    printf( "server args:\n" );
    printf( "  &lt;local&gt; &lt;port&gt; &lt;segsize&gt; &lt;droptime&gt;\n" );
    printf( "client args:\n" );
    printf( "  &lt;local&gt; &lt;remote&gt; &lt;port&gt; &lt;message&gt; &lt;segsize&gt; &lt;probetime&gt;
 &lt;reptime&gt;\n");
    sts = 0;
  }
 
  return( sts );
 
 
/*
 * Server
 */
static int Server(
int                     argc,
char                    *argv[] )
 
 
  int                   sts, s_t_s, status;
  int                   sock;
  int                   port;
  int                   optval;
  int                   flag;
  int                   cnt;
  int                   msgsiz_recv;
  int                   msgoff;
  int                   remsiz;
  int                   segsiz;
  int                   size;
  int                   sock_connect_msgsiz;
  int                   sts_select;
  int                   sock_listen;
  int                   sock_accept;
  int                   sock_connect;
  int                   wait_read;
  int                   wait_write;
  int                   wait_probe;
  int                   wait_drop;
  int                   repeat_probe;
  int unsigned          sock_mask_read;
  int unsigned          sock_mask_write;
  int unsigned          sock_mask_excep;
  int unsigned          sock_listen_mask;
  int unsigned          sock_accept_mask;
  int unsigned          sock_connect_mask;
  int unsigned          sock_read_mask;
  int unsigned          sock_write_mask;
  int unsigned          sock_accept_busy;
  int unsigned          sizeof_sock_accept_tag;
  int unsigned          sizeof_sock_connect_tag;
  char                  *local;
  char                  *remote;
  char                  *msgbuf_send;
  char                  *sock_connect_msgbuf;
  static                                        //bind fails unless static
  struct sockaddr_in    sock_listen_tag;        //tag struct for socket
  static                                        //bind fails unless static
  struct sockaddr_in    sock_accept_tag;        //tag struct for socket
  static                                        //bind fails unless static
  struct sockaddr_in    sock_connect_tag;       //tag struct for socket
  struct timeval        wait_select = { 0, 0 },
                        *wait_select_p;
  char                  msgbuf_recv[BUFSIZ];
  int                   sock_accept_msgsiz[32] = { 0 };
  char                  sock_accept_msgbuf[32][10];//small to illustrate
  struct in_addr        sock_connect_addr[32];
 
 
  /*
   * Get args
   */
  local  = argv[1];                             //local interface
  port   = atoi( argv[2] );                     //port number
  if( !port || 65535 &lt; port )
  {
    printf( "Invalid port: %s\n", argv[2] );
    return( 0 );
  }
  segsiz = atoi( argv[3] );                     //segment size
  wait_drop = atoi( argv[4] );                  //idle connection timeout
 
  /*
   * Get socket tag of listen socket
   */
  sts = GetSockTag( local, port, &amp;sock_listen_tag );
  if( !sts )
  {
    perror( "GetSockTag" );
    return( 0 );
  }
 
  /*
   * Create (untagged) listen socket
   */
  sock_listen = socket( AF_INET, SOCK_STREAM, 0 );
  if( sock_listen == -1 )
  {
    perror( "socket" );
    return( 0 );
  }
 
  /*
   * Enable reuse of local addresses in assignment of local addresses to the
   * listening socket. Otherwise bind() may fail with error "local address
   * already in use" on immediate rerun of the program (because of a delay in
   * TCPIP on cleaning up?). Setting the option does not also enable reuse of
   * the port number if already in use by another process. Maybe that is what
   * option SO_REUSEPORT is for.
   * (Note, that TCPIP$C_SOCKOPT as used with the $QIO implementation does
   * NOT carry the same value as SOL_SOCKET)
   */
  optval = 1;
  sts = setsockopt( sock_listen,                //socket
                    SOL_SOCKET, SO_REUSEADDR,   //option ident
                    (char *)&amp;optval, sizeof(optval) );//option value
  if( sts == -1 )
  {
    perror( "setsockopt" );
    Cleanup( sock_listen, 0 );
    return( 0 );
  }
 
  /*
   * Assign tag to listen socket
   */
  sts = bind( sock_listen,
              (struct sockaddr *)&amp;sock_listen_tag,
              sizeof(sock_listen_tag) );
  if( sts == -1 )
  {
    perror( "bind" );
    Cleanup( sock_listen, 0 );
    return( 0 );
  }
 
  /*
   * Listen on listen socket for connection requests from connect socket.
   */
  sts = listen( sock_listen, 5 );
  if( sts == -1 )
  {
    perror( "listen" );
    Cleanup( sock_listen, 0 );
    return( 0 );
  }
  sock_listen_mask = 1&lt;&lt;sock_listen;
  sock_accept_mask = 0;                         //no sockets accepted yet
 
  /*
   * Process incoming traffic
   */
  while( !0 )
  {
 
    /*
     * Vacate message buffers of idle sockets
     */
    sock_accept_busy = sock_accept_mask &amp; sock_mask_read;
    for( sock=0; sock&lt;32; sock++ )
    {
      if( !(sock_accept_msgsiz[sock]) )         //if buffer empty
        continue;
      if( sock_accept_busy &amp; 1&lt;&lt;sock )          //if buffer busy
        continue;
      VacateMsgBuf( sock, sock_connect_addr[sock],
                    sock_accept_msgbuf[sock], &amp;sock_accept_msgsiz[sock] );
    }
 
    /*
     * Select
     */
    sock_read_mask =   sock_listen_mask
                     | sock_accept_mask;
    sock_mask_read  = sock_read_mask;
    sock_mask_write = 0;                        //no writing in this example
    sock_mask_excep = sock_read_mask;
    if( !sock_accept_busy )                     //if no sockets were busy
      wait_select_p = 0;                        //wait until ready
    else
      wait_select_p = &amp;wait_select;             //wait to coalesce and vacate
    sts_select = select( 32,
                         (void *)&amp;sock_mask_read,
                         (void *)&amp;sock_mask_write,
                         (void *)&amp;sock_mask_excep,
                         (void *)wait_select_p );
 
    /*
     * Timeout.
     */
    if( !sts_select )
    {
      continue;
    }
 
    /*
     * Process exception
     */
    if( sock_mask_excep )
    {
      for( sock=0; sock&lt;32; sock++ )
      {
        if( !(sock_mask_excep &amp; 1&lt;&lt;sock) )
          continue;
        sizeof_sock_connect_tag = sizeof( sock_connect_tag );
        getsockname( sock,                    //get tag of peer
                     (struct sockaddr *)&amp;sock_connect_tag,
                     &amp;sizeof_sock_connect_tag );
        printf( "sock: %d remote: %s select: exception\n",
                sock, inet_ntoa(sock_connect_tag.sin_addr) );
      }
    }
 
    /*
     * Accept connection request on listen socket and spawn accept socket
     */
    if( sock_listen_mask &amp; sock_mask_read )     //if connection request
    {
      sizeof_sock_connect_tag = sizeof( sock_connect_tag );
      sock_accept = accept( sock_listen,
                            (struct sockaddr *)&amp;sock_connect_tag,//tag of peer
                            &amp;sizeof_sock_connect_tag );
      if( sock_accept == -1 )
      {
        perror( "accept" );
        Cleanup( sock_listen, 0 );
      }
      else
      if( 32 &lt;= sock_accept )                   //if no room in this program
      {
        printf( "sock: %d remote: %s accept: no room\n",
                sock, inet_ntoa(sock_connect_tag.sin_addr) );
        Cleanup( sock_accept, 1 );
      }
      else
      {
        sock_accept_mask |= 1&lt;&lt;sock_accept;     //insert
        printf( "sock: %d chnl: %d remote: %s accept: ok\n",
                sock_accept, decc$get_sdc( sock_accept ),
                inet_ntoa(sock_connect_tag.sin_addr) );
 
        /*
         * Save addr of peer for printing
         */
        sock_connect_addr[sock_accept] = sock_connect_tag.sin_addr;
 
        /*
         * Set connection idle timeout on accept socket
         * (Note, that  TCPIP$C_TCPOPT and TCPIP$C_TCP as used with the $QIO
         * implementation carry the same value as IPPROTO_TCP)
         */
        if( wait_drop )
        {
          sts = setsockopt( sock_accept,        //socket
                            IPPROTO_TCP, TCPIP$C_TCP_DROP_IDLE,//option ident
                           (char *)&amp;wait_drop, sizeof(wait_drop) );//option value
          if( sts == -1 )
          {
            perror( "setsockopt" );
            Cleanup( sock_accept, 1 );
            sock_accept_mask &amp;= ~(1&lt;&lt;sock);     //remove
          }
        }
      }
    }
 
    /*
     * Receive message from connect socket to accept socket
     */
    sock_accept_busy = sock_accept_mask &amp; sock_mask_read;
    if( sock_accept_busy )
    {
      for( sock=0; sock&lt;32; sock++ )
      {
        if( !( sock_accept_busy &amp; 1&lt;&lt;sock ) )   //if not busy
          continue;
        if( !segsiz )                           //if no segmentation
          size = sizeof(msgbuf_recv);
        else
        if( segsiz &lt; sizeof(msgbuf_recv) )
          size = segsiz;
        else
          size = sizeof(msgbuf_recv);
        flag = 0;
        cnt = recv( sock,
                    msgbuf_recv, size, flag );
        if( cnt == -1 )                         //if error
        {
          perror( "recv" );
          Cleanup( sock, 1 );
          sock_accept_mask &amp;= ~(1&lt;&lt;sock);       //remove
        }
        else
        if( cnt == 0 )                          //peer closed
        {
          perror( "recv" );
          Cleanup( sock, 1 );
          sock_accept_mask &amp;= ~(1&lt;&lt;sock);       //remove
        }
        else                                    //ok
        {
 
          /*
           * The following is for the sake of the exercise. The buffer
           * received is emptied into the dedicated buffer as space permits
           * and the dedicated buffer emptied (printed) as it becomes full.
           */
          msgoff = 0;
          while( cnt )
          {
            remsiz =   sizeof(sock_accept_msgbuf[sock])
                     - sock_accept_msgsiz[sock];
            if( remsiz == 0 )                   //no space
            {
              VacateMsgBuf( sock, sock_connect_addr[sock],//vacate
                            sock_accept_msgbuf[sock],
                            &amp;sock_accept_msgsiz[sock] );
              continue;                         //try again
            }
            if( remsiz &lt; cnt )                  //if not enough space
              msgsiz_recv = remsiz;
            else
              msgsiz_recv = cnt;
            memcpy(   sock_accept_msgbuf[sock]  //append
                    + sock_accept_msgsiz[sock],
                    msgbuf_recv+msgoff, msgsiz_recv );
            sock_accept_msgsiz[sock] += msgsiz_recv;
            msgoff += msgsiz_recv;
            cnt -= msgsiz_recv;
          }
        }
      }
    }
  }
 
  return( 1 );
 
 
/*
 * Client
 */
static int Client(
int                     argc,
char                    *argv[] )
 
 
  int                   sts, s_t_s, status;
  int                   sock;
  int                   port;
  int                   optval;
  int                   flag;
  int                   cnt;
  int                   msgsiz_send;
  int                   msgoff;
  int                   remsiz;
  int                   segsiz;
  int                   size;
  int                   sock_connect_msgsiz;
  int                   sts_select;
  int                   sock_listen;
  int                   sock_accept;
  int                   sock_connect;
  int                   wait_read;
  int                   wait_write;
  int                   wait_probe;
  int                   wait_drop;
  int                   repeat_probe;
  int unsigned          sock_mask_read;
  int unsigned          sock_mask_write;
  int unsigned          sock_mask_excep;
  int unsigned          sock_listen_mask;
  int unsigned          sock_accept_mask;
  int unsigned          sock_connect_mask = 0;
  int unsigned          sock_read_mask;
  int unsigned          sock_write_mask;
  int unsigned          sock_accept_busy;
  int unsigned          sizeof_sock_accept_tag;
  int unsigned          sizeof_sock_connect_tag;
  char                  *local;
  char                  *remote;
  char                  *msgbuf_send;
  char                  *sock_connect_msgbuf;
  static                                        //bind fails unless static
  struct sockaddr_in    sock_listen_tag;        //tag struct for socket
  static                                        //bind fails unless static
  struct sockaddr_in    sock_accept_tag;        //tag struct for socket
  static                                        //bind fails unless static
  struct sockaddr_in    sock_connect_tag;       //tag struct for socket
  struct timeval        wait_select = { 0, 0 },
                        *wait_select_p;
  char                  msgbuf_recv[BUFSIZ];
  int                   sock_accept_msgsiz[32] = { 0 };
  char                  sock_accept_msgbuf[32][10];//small to illustrate
  struct in_addr        sock_connect_addr[32];
 
 
  /*
   * Get args
   */
  local        = argv[1];
  remote       = argv[2];
  port         = atoi( argv[3] );
  if( !port || 65535 &lt; port )
  {
    printf( "Invalid port: %s\n", argv[2] );
    return( 0 );
  }
  sock_connect_msgbuf = argv[4];
  sock_connect_msgsiz = strlen( sock_connect_msgbuf );
  segsiz = atoi( argv[5] );
  wait_probe = atoi( argv[6] );
  if( wait_probe &lt; 0 )                          //if enable keepalive
  {
    wait_probe *= -1;                           //make positive
    repeat_probe = 1;                           //enable keepalive
  }
  else
    repeat_probe = 0;                           //do not enable keepalive
  wait_write = atoi( argv[7] );                 //wait until repeat
 
 
  /*
   * Get socket tag of connect socket
   */
  sts = GetSockTag( local, 0, &amp;sock_connect_tag );
  if( !sts )
  {
    perror( "GetSockTag" );
    return( 0 );
  }
 
  /*
   * Get socket tag of listen socket
   */
  sts = GetSockTag( remote, port, &amp;sock_listen_tag );
  if( !sts )
  {
    perror( "GetSockTag" );
    return( 0 );
  }
 
  /*
   * Create (untagged) connect socket
   */
  sock_connect = socket( AF_INET, SOCK_STREAM, 0 );
  if( sock_connect == -1 )
  {
    perror( "socket" );
    return( 0 );
  }
 
  /*
   * Set wait until connection timeout (and keepalive, if enabled)
   * (Note, that TCPIP$C_TCPOPT and TCPIP$C_TCP as used with the $QIO
   * implementation carry the same value as IPPROTO_TCP)
   */
  if( wait_probe )
  {
    sts = setsockopt( sock_connect,             //socket
                      IPPROTO_TCP, TCPIP$C_TCP_PROBE_IDLE,//option ident
                      (char *)&amp;wait_probe, sizeof(wait_probe) );//option value
    if( sts == -1 )
    {
      perror( "setsockopt" );
      Cleanup( sock_connect, 0 );
      return( 0 );
    }
  }
 
  /*
   * Enable keepalive e.g. enable repeat of probe, if any
   * (Note, that TCPIP$C_KEEPALIVE as used with the $QIO implementation
   * carry the same value as SO_KEEPALIVE)
   */
  if( repeat_probe )
  {
    optval = repeat_probe;
    sts = setsockopt( sock_connect,             //socket
                      SOL_SOCKET, SO_KEEPALIVE, //option ident
                      (char *)&amp;optval, sizeof(optval) );//option value
    if( sts == -1 )
    {
      perror( "setsockopt" );
      Cleanup( sock_connect, 0 );
      return( 0 );
    }
  }
 
  /*
   * Assign tag to connect socket
   */
  sts = bind( sock_connect,
              (struct sockaddr *)&amp;sock_connect_tag,
              sizeof(sock_connect_tag) );
  if( sts == -1 )
  {
    perror( "bind" );
    Cleanup( sock_connect, 0 );
    return( 0 );
  }
 
  /*
   * Connect connect socket to listen socket.
   */
  sts = connect( sock_connect,
                 (struct sockaddr *)&amp;sock_listen_tag,//socket tag of peer
                 sizeof(sock_listen_tag) );
  if( sts == -1 )
  {
    perror( "connect" );
    Cleanup( sock_connect, 0 );
    return( 0 );
  }
  printf( "sock: %d chnl: %d connect: ok\n",
          sock_connect, decc$get_sdc( sock_connect ) );
  sock_connect_mask |= 1&lt;&lt;sock_connect;         //insert
  msgbuf_send = sock_connect_msgbuf;            //init
  msgsiz_send = sock_connect_msgsiz;
 
  /*
   * Process outgoing traffic
   */
  while( !0 )
  {
    if( !msgsiz_send ) {                        //if nothing to send
      msgbuf_send = sock_connect_msgbuf;        //reload
      msgsiz_send = sock_connect_msgsiz;
      if( wait_write &lt; 0 )                      //if do not wait
      {
        sock_write_mask = sock_connect_mask;
        wait_select_p = 0;                      //wait until ready
      }
      else
      if( !wait_write )                         //if do not repeat
      {
        break;
      }
      else
      {
        sock_write_mask = 0;
        wait_select.tv_sec = wait_write;
        wait_select_p = &amp;wait_select;           //wait until timeout
      }
    }
    else
    {
      sock_write_mask = sock_connect_mask;
      wait_select_p = 0;                        //wait until ready
    }
 
    /*
     * Select
     */
    sock_mask_read  = 0;                        //no reading in this example
    sock_mask_write = sock_write_mask;
    sock_mask_excep = sock_connect_mask;
    sts_select = select( 32,
                         (void *)&amp;sock_mask_read,
                         (void *)&amp;sock_mask_write,
                         (void *)&amp;sock_mask_excep,
                         (void *)wait_select_p );
 
    /*
     * Timeout.
     */
    if( !sts_select )
    {
      continue;
    }
 
    /*
     * Process exception
     */
    if( sock_mask_excep )
    {
      perror( "select" );
    }
 
    /*
     * Send message from connect socket to accept socket
     */
    if( sock_connect_mask &amp; sock_mask_write )
    {
      if( !segsiz )
        size = msgsiz_send;
      else
      if( segsiz &lt; msgsiz_send )
        size = segsiz;
      else
        size = msgsiz_send;
      flag = 0;
      cnt = send( sock_connect,
                  msgbuf_send, size, flag );
      if( cnt == -1 )                           //if error
      {
        perror( "send" );
        Cleanup( sock_connect, 1 );
        sock_connect_mask &amp;= ~(1&lt;&lt;sock_connect);//remove
        return( 0 );
      }
      else
      {
        msgbuf_send += cnt;
        msgsiz_send -= cnt;
      }
    }
  }
 
  /*
   * Call cleanup to shutdown and close socket.
   */
  Cleanup( sock_connect, 1 );
 
  return( 1 );
 
 
static
int GetSockTag(
char                    *name,
int                     port,
struct sockaddr_in      *sock_tag )             //tag struct for socket
 
 
  int                   sts, s_t_s, status;
  int                   idx;
  int                   family;
  int                   addr;
  struct hostent        *hostent;               //pointer to host file entry
 
 
  /*
   * Get value of members of tag structure of listen socket
   */
  if( !strlen( name ) )
  {
 
    /*
     * Interface not specified e.g. listen using any local interface
     */
    family = AF_INET;                           //the only legal value
    addr   = INADDR_ANY;                        //any local interface
  }
  else
  {
 
    /*
     * Interface specified e.g. listen using specified local interface only
     */
    addr = 0;
    for( idx=0; !addr; idx++ )
    {
      switch( idx ) {
      case 0:                                   //try by name in host file
        hostent = gethostbyname( name );
        if( hostent )
        {
          family = hostent-&gt;h_addrtype;         //AF_INET
          addr   = *(int *)hostent-&gt;h_addr_list[0];//first one in host file
        }
        break;
      case 1:                                   //try by addr in host file
        hostent = gethostbyaddr( name, strlen(name), AF_INET );
        if( hostent )
        {
          family = hostent-&gt;h_addrtype;         //AF_INET
          addr   = *(int *)hostent-&gt;h_addr_list[0];//first one in host file
        }
        break;
      case 2:                                   //try by addr ignoring host file
        family = AF_INET;                       //the only legal value
        addr = inet_addr( name );
        if( addr == -1 )
          addr = 0;
        break;
      default:
        return( 0 );
      }
    }
  }
 
  /*
   * Fill in members of tag structure of listen socket
   */
  sock_tag-&gt;sin_family = family;                //AF_INET
  sock_tag-&gt;sin_addr   = *(struct in_addr *)&amp;addr;//IP address
  sock_tag-&gt;sin_port   = htons( port );         //port number
 
  return( 1 );
 
 
static
void Cleanup(
int             sock,
int             shut )
 
 
  int                   sts, s_t_s, status;
 
 
  /*
   * Shutdown socket
   */
  if( shut )
  {
    sts = shutdown( sock, 2 );
    if( sts == -1 )
      perror( "shutdown" );
  }
 
  /*
   * Close socket
   */
  sts = close( sock );
  if( sts == -1 )
    perror( "close" );
 
  return;
 
 
static
void VacateMsgBuf(
int                     sock,
struct in_addr          sin_addr,
char                    *msgbuf,
int                     *msgsiz )
 
 
  int                   sts, s_t_s, status;
 
 
  /*
   * Print message contents
   */
  printf( "sock: %d remote: %s recv: %*.*s\n",
          sock, inet_ntoa(sin_addr), *msgsiz, *msgsiz, msgbuf );
  *msgsiz = 0;                                  //now empty
 
  return;
 
 
 
 
 
 The Answer is:
 
  Please contact the Compaq Customer Support Center for assistance with
  this question.
 
