---

rpcmem.cc

Go to the documentation of this file.

/*************************************************************************
* File:rpcmem.cc                                                         *
* Authors: Fred Proctor, Will Shackleford                                *
* Purpose: C++ file for RPC client that reads and writes                 *
*          to a local NML buffer for remote processes.                   *
* Includes:                                                              *
*          1. class RPCMEM member functions.                             *
*************************************************************************/

#include "rcs_defs.hh"          /* __MSDOS__, EXTERN_C_STD_HEADERS */

#ifdef EXTERN_C_STD_HEADERS
extern "C"
{
#endif

#include <stdlib.h>             /* exit() */
#include <string.h>             /* strncpy(), strchr() */
#include <stddef.h>             /* size_t */

#if defined(WIN32) && !defined(USE_OLD_WINSOCK)
/* Lame problem if windows.h is included before winsock2.h many redefined
 compiler errors result. */
#include <winsock2.h>
#endif

#ifndef __MSDOS__
#include <rpc/rpc.h>            /* bool_t, xdr_ & clnt_ functions  */
#endif
#ifndef irix6
#include <math.h>               /* fmod() */
#else
// Work around for the conflict between the gcc includes and /usr/includes
// on some of our SGI's regarding the definition of initstate()
  extern double fmod (double, double);
#endif

#ifdef VXWORKS
#include <sys/types.h>          /* u_short (needed by socket.h) */
#include <sys/socket.h>         /* sockaddr_in */
#include <hostLib.h>            /* hostGetByName() */
#include <rpcLib.h>             /* rpcTaskInit() */
#include <rpc/rpcGbl.h>         /* rpc_createerr */
#endif

#ifdef EXTERN_C_STD_HEADERS
}
#endif

#ifdef __MSDOS__
extern "C"
{
#ifndef WIN32
#include <sys/nfs_time.h>       /* struct timeval */
#endif
#include <rpc/rpc.h>            /* struct CLIENT, enum clnt_stat */
#ifdef _MSDOS
/* PC-NFS 5.0 Programmer`s Toolkit Header files */
#include <tklib.h>              /* tkdll_cleanup() */
#endif
}
#endif

#include "cms.hh"               /* class CMS, enum CMS_STATUS */
#include "rpcmem.hh"            /* class RPCMEM */
#include "timer.hh"             /* class RCS_TIMER */
#include "xdr_msg.hh"           /* struct XBUFFER, xdr_XBUFFER() */
#include "rcs_prnt.hh"          /* rcs_print_error() */
#include "rpcintrf.h"           /* Dynamic Interface to RPC (dl_clnt_ )functions */
#include "crypt2.hh"            // crypt()


RPCMEM::RPCMEM (char *bufline, char *procline):
CMS (bufline, procline)
{
  /* Set pointers to dynamically allocated objects to NULL so that the */
  /* destructor won't delete them unless they are actually created. */
  clnt = NULL;
  timeval_time_out = NULL;
  //rpc_host = NULL;

  /* Load the interface for RPC functions and pointers.
     * This is required so that  Windows apps that don't need RPC
     * can run on systems without PCNFS. */
  if (load_rpc_interface () < 0)
    {
      /* PCNFS appears to not be available. */
      status = CMS_LIBRARY_UNAVAILABLE_ERROR;
      return;
    }
  timeval_time_out = malloc (sizeof (struct timeval));

#ifdef VXWORKS
  rpcTaskInit ();
#endif
  open ();
}

RPCMEM::~RPCMEM ()
{
#ifdef DEBUG
  rcs_print_error ("deleting RPCMEM\n");
  fflush (stderr);
#endif
  if (NULL != timeval_time_out)
    {
#ifdef sparcworks_sun4          /* free is defined as int free(char *)
                                   for this platform
                                   it should be void free(void *); */
      free ((char *) timeval_time_out);
#else
      free (timeval_time_out);
#endif
      timeval_time_out = NULL;
    }
  close ();

  /* Calling this decrements a counter,
     when the counter reaches zero under Windows
     the PCNFS DLL should be unloaded. */
  unload_rpc_interface ();
}

/*
  Open the RPCMEM cms
  */
int
RPCMEM::open ()
{
#if 0
  /* Check to see if the remote server has registered with the portmapper. */
  if (NULL != rpc_host)
    {
      if (-1 ==
          (registered =
           rpc_host->check_if_prog_registered (rpc_program_number)))
        {
          rcs_print_error
            ("RPCMEM: Can`t find out if server is registered.\n");
          status = CMS_MISC_ERROR;
          return -1;
        }
      if (!registered)
        {
          rcs_print_error ("RPCMEM: Please start server for %s on %s.\n",
                           BufferName, BufferHost);
          rcs_print_error
            ("RPCMEM: It should register as program 0x%X(%ld).\n",
             rpc_program_number, rpc_program_number);
          status = CMS_NO_SERVER_ERROR;
          return -1;
        }
    }
#endif

  clnt = dl_clnt_create (BufferHost, rpc_program_number, 1, "tcp");
  if (clnt == NULL)
    {
      //      rcs_print_error("RPCMEM::open: cf_stat = %d\n", rpc_createerr.cf_stat);
#ifndef _Windows
      if (rpc_createerr.cf_stat == RPC_PROGNOTREGISTERED)
        {
          status = CMS_NO_SERVER_ERROR;
        }
      else
        {
          status = CMS_MISC_ERROR;
        }
#else
      status = CMS_NO_SERVER_ERROR;
#endif
      char *error_msg;
      error_msg = dl_clnt_spcreateerror ("RPCMEM::open");
      rcs_puts (error_msg);
#if 0
      // It is not neccessary to get the TLI errno because the message
      //  from dl_clnt_spcreateerror will include it if there's a TLI error any way.
      if (rpc_createerr.cf_stat == RPC_TLIERROR && t_errno != 0)
        {
          error_msg = t_strerror (t_errno);
          rcs_puts (error_msg);
        }
#endif
      rcs_print_error ("RPCMEM::open (Name = %s, ", BufferName);
      rcs_print_error ("BufferHost = %s, ", BufferHost);
      rcs_print_error ("prog = 0x%lX(%ld))\n",
                       rpc_program_number, rpc_program_number);
      return (-1);
    }
  if (timeout >= 0.0)
    {
      /* Fill the timeval structure from the timout in sec
       * tv_sec = interger part of timeout
       * tv_usec = fractional part of timeout * 1000;
       */
      ((struct timeval *) timeval_time_out)->tv_sec = (long) timeout;
      ((struct timeval *) timeval_time_out)->tv_usec = (long) (timeout * 1000000.0);
      if (((struct timeval *) timeval_time_out)->tv_usec >= 1000000)
        {

          ((struct timeval *) timeval_time_out)->tv_usec =
            ((struct timeval *) timeval_time_out)->tv_usec % 1000000;
        }
    }
  else
    {
      /* Time out should be infinite,but I can only set it high. */
      /* I can't even set it as high as I would like because it causes */
      /* a wierd problem where the dl_clnt_create function stops working */
      /* after 7 more calls. */
      ((struct timeval *) timeval_time_out)->tv_sec = 60;       /* 1 minute. */
      ((struct timeval *) timeval_time_out)->tv_usec = 500;
    }
  if (!dl_clnt_control
      ((CLIENT *) clnt, CLSET_TIMEOUT, (char *) timeval_time_out))
    {
      rcs_print_error ("RPCMEM:Could not set timeout.\n");
    }
  return 0;
}


/* Closes the socket file descriptors. */
int
RPCMEM::close ()
{
  if (delete_totally && NULL != clnt)
    {
      /* Send the server the command to kill itself. */
      dl_clnt_call ((CLIENT *) clnt, 4,
                    (xdrproc_t)
                    ((rpc_library_type != PCNFS_TKDLL_WINDOWS_31) ?
                     (void *) ptr_to_xdr_void :
                     (void *) ptr_to_pascal_xdr_void),
                    (char *) NULL,
                    (xdrproc_t)
                    ((rpc_library_type != PCNFS_TKDLL_WINDOWS_31) ?
                     (void *) ptr_to_xdr_void :
                     (void *) ptr_to_pascal_xdr_void),
                    (char *) NULL, *((struct timeval *) timeval_time_out));
    }
  if (NULL == clnt)
    {
      return (-1);
    }
  else
    {
      dl_clnt_destroy ((CLIENT *) clnt);
    }
  return 0;
}

int
RPCMEM::check_if_read ()
{
  static int retval;
  clnt_stat val;


  /* get the latest buffer data from the server */
  if ((val = dl_clnt_call ((CLIENT *) clnt, 3,
                           (xdrproc_t)
                           ((rpc_library_type != PCNFS_TKDLL_WINDOWS_31) ?
                            (void *) ptr_to_xdr_long :
                            (void *) ptr_to_pascal_xdr_long),
                           (char *) &buffer_number,
                           (xdrproc_t)
                           ((rpc_library_type != PCNFS_TKDLL_WINDOWS_31) ?
                            (void *) ptr_to_xdr_int :
                            (void *) ptr_to_pascal_xdr_int),
                           (char *) &retval,
                           *((struct timeval *) timeval_time_out))) != 0)
    {
      char *error_msg;
      error_msg = dl_clnt_sperrno (val);
      rcs_puts (error_msg);
      rcs_print_error ("\n");
      if (val == RPC_TIMEDOUT)
        {
          status = CMS_TIMED_OUT;
        }
      else
        {
          status = CMS_MISC_ERROR;
        }
      return (-1);
    }

  /* increment debug heartbeat */
  return (retval);
}

CMS_STATUS
RPCMEM::clear ()
{
  static int retval;
  clnt_stat val;


  /* get the latest buffer data from the server */
  if ((val = dl_clnt_call ((CLIENT *) clnt, 5,
                           (xdrproc_t)
                           ((rpc_library_type != PCNFS_TKDLL_WINDOWS_31) ?
                            (void *) ptr_to_xdr_long :
                            (void *) ptr_to_pascal_xdr_long),
                           (char *) &buffer_number,
                           (xdrproc_t) (void *) ptr_to_xdr_int,
                           (char *) &retval,
                           *((struct timeval *) timeval_time_out))) != 0)
    {
      char *error_msg;
      error_msg = dl_clnt_sperrno (val);
      rcs_puts (error_msg);
      rcs_print_error ("\n");
      if (val == RPC_TIMEDOUT)
        {
          status = CMS_TIMED_OUT;
        }
      else
        {
          status = CMS_MISC_ERROR;
        }
      return (status);
    }

  return ((CMS_STATUS) retval);
}

/* Copy data from network to local buffer */
CMS_STATUS
RPCMEM::read ()
{
  clnt_stat val;
  REMOTE_READ_REQUEST read_req;
  REMOTE_READ_REPLY read_reply;

  /* Check pointers. */
  if ((NULL == clnt))
    {
      rcs_print_error ("RPCMEM: clnt is NULL.\n");
      return (status = CMS_MISC_ERROR);
    }

  /* Set up read request message. */
  read_req.buffer_number = buffer_number;
  read_req.access_type = CMS_READ_ACCESS;
  read_req.last_id_read = in_buffer_id;

  /* Setup storage for reply */
  read_reply.data = encoded_data;

  /* get the latest buffer data from the server */
  if ((val = dl_clnt_call ((CLIENT *) clnt, 1,
                           (xdrproc_t)
                           (
                            (rpc_library_type != PCNFS_TKDLL_WINDOWS_31) ?
                            (void *) xdr_REMOTE_READ_REQUEST :
                            (void *) xdr_REMOTE_READ_REQUEST_PASCAL),
                           (char *) &read_req,
                           (xdrproc_t)
                           (
                            (rpc_library_type != PCNFS_TKDLL_WINDOWS_31) ?
                            (void *) xdr_REMOTE_READ_REPLY :
                            (void *) xdr_REMOTE_READ_REPLY_PASCAL),
                           (char *) &read_reply,
                           *((struct timeval *) timeval_time_out))) != 0)
    {
      char *error_msg;
      error_msg = dl_clnt_sperrno (val);
      rcs_puts (error_msg);
      rcs_print_error ("\n");
      if (val == RPC_TIMEDOUT)
        {
          rcs_print_error ("CMS:(%s) Network timed-out on read.\n",
                           BufferName);
          status = CMS_TIMED_OUT;
        }
      else
        {
          rcs_print_error ("CMS:(%s) Network communication error on read.\n",
                           BufferName);
          status = CMS_MISC_ERROR;
        }
      return (status);
    }

  if (read_reply.status != CMS_READ_OK && read_reply.status != CMS_READ_OLD)
    {
      rcs_print_error ("CMS:(%s) Failure with remote server on read.\n",
                       BufferName);
    }
  status = (CMS_STATUS) read_reply.status;
  header.was_read = read_reply.was_read;
  check_id (read_reply.write_id);

  return (status);
}

/* Copy data from network to local buffer */
/* Do not change was_read flag. */
CMS_STATUS
RPCMEM::peek ()
{
  clnt_stat val;
  REMOTE_READ_REQUEST read_req;
  REMOTE_READ_REPLY read_reply;

  /* Check pointers. */
  if (NULL == clnt)
    {
      return (status = CMS_MISC_ERROR);
    }

  /* Set up read request message. */
  read_req.buffer_number = buffer_number;
  read_req.access_type = CMS_PEEK_ACCESS;
  read_req.last_id_read = in_buffer_id;

  /* Setup storage for reply */
  read_reply.data = encoded_data;

  /* get the latest buffer data from the server */
  if ((val = dl_clnt_call ((CLIENT *) clnt, 1,
                           (xdrproc_t)
                           (
                            (rpc_library_type != PCNFS_TKDLL_WINDOWS_31) ?
                            (void *) xdr_REMOTE_READ_REQUEST :
                            (void *) xdr_REMOTE_READ_REQUEST_PASCAL),
                           (char *) &read_req,
                           (xdrproc_t)
                           (
                            (rpc_library_type != PCNFS_TKDLL_WINDOWS_31) ?
                            (void *) xdr_REMOTE_READ_REPLY :
                            (void *) xdr_REMOTE_READ_REPLY_PASCAL),
                           (char *) &read_reply,
                           *((struct timeval *) timeval_time_out))) != 0)
    {
      char *error_msg;
      error_msg = dl_clnt_sperrno (val);
      rcs_print_error ("%s\n", error_msg);
      if (val == RPC_TIMEDOUT)
        {
          rcs_print_error ("CMS:(%s) Network timed-out on read.\n",
                           BufferName);
          status = CMS_TIMED_OUT;
        }
      else
        {
          rcs_print_error ("CMS:(%s) Network communication error on read.\n",
                           BufferName);
          status = CMS_MISC_ERROR;
        }
      return (status);
    }
  if (read_reply.status != CMS_READ_OK && read_reply.status != CMS_READ_OLD)
    {
      rcs_print_error ("CMS:(%s) Failure with remote server on read.\n",
                       BufferName);
    }

  status = (CMS_STATUS) read_reply.status;
  header.was_read = read_reply.was_read;
  check_id (read_reply.write_id);

  return (status);
}

/* Copy data from local buffer to server for deposit in shared memory */
/* WARNING: user_data parameter is ignored. */
CMS_STATUS
RPCMEM::write (void *user_data)
{
  REMOTE_WRITE_REQUEST write_req;
  REMOTE_WRITE_REPLY write_reply;

  clnt_stat val;

  /* Check pointers. */
  if (NULL == clnt)
    {
      return (status = CMS_MISC_ERROR);
    }

  /* Setup write request message. */
  write_req.data = (unsigned char *) encoded_data;
  write_req.size = (int) header.in_buffer_size;
  write_req.access_type = CMS_WRITE_ACCESS;
  write_req.buffer_number = buffer_number;


  /* write our data to the BufferHost's shared memory via the server */
  if ((val = dl_clnt_call ((CLIENT *) clnt, 2,
                           (xdrproc_t)
                           (
                            (rpc_library_type != PCNFS_TKDLL_WINDOWS_31) ?
                            (void *) xdr_REMOTE_WRITE_REQUEST :
                            (void *) xdr_REMOTE_WRITE_REQUEST_PASCAL),
                           (char *) &write_req,
                           (xdrproc_t)
                           (
                            (rpc_library_type != PCNFS_TKDLL_WINDOWS_31) ?
                            (void *) xdr_REMOTE_WRITE_REPLY :
                            (void *) xdr_REMOTE_WRITE_REPLY_PASCAL),
                           (char *) &write_reply,
                           *((struct timeval *) timeval_time_out))) != 0)
    {
      char *error_msg;
      error_msg = dl_clnt_sperrno (val);
      rcs_print_error ("%s\n", error_msg);
      if (val == RPC_TIMEDOUT)
        {
          rcs_print_error ("CMS:(%s) Network timed-out on write. \n",
                           BufferName);
          status = CMS_TIMED_OUT;
        }
      else
        {
          rcs_print_error
            ("CMS:(%s) Network communication error on write. \n", BufferName);
          status = CMS_MISC_ERROR;
        }
      return (status);
    }

  if (write_reply.status != CMS_WRITE_OK)
    {
      rcs_print_error ("CMS:(%s) Failure with remote server on write.\n",
                       BufferName);
    }
  status = (CMS_STATUS) write_reply.status;
  header.was_read = write_reply.was_read;
  return (status);
}

/* Copy data from local buffer to server for deposit in shared memory */
/* Write will only succeed if the buffer has been read since the last write. */
/* WARNING: user_data parameter is ignored. */
CMS_STATUS
RPCMEM::write_if_read (void *user_data)
{
  REMOTE_WRITE_REQUEST write_req;
  REMOTE_WRITE_REPLY write_reply;

  clnt_stat val;

  /* Check pointers. */
  if (NULL == clnt)
    {
      return (status = CMS_MISC_ERROR);
    }

  /* Setup write request message. */
  write_req.data = (unsigned char *) encoded_data;
  write_req.access_type = CMS_WRITE_IF_READ_ACCESS;
  write_req.buffer_number = buffer_number;

  /* write our data to the BufferHost's shared memory via the server */
  if ((val = dl_clnt_call ((CLIENT *) clnt, 2,
                           (xdrproc_t)
                           (
                            (rpc_library_type != PCNFS_TKDLL_WINDOWS_31) ?
                            (void *) xdr_REMOTE_WRITE_REQUEST :
                            (void *) xdr_REMOTE_WRITE_REQUEST_PASCAL),
                           (char *) &write_req,
                           (xdrproc_t)
                           (
                            (rpc_library_type != PCNFS_TKDLL_WINDOWS_31) ?
                            (void *) xdr_REMOTE_WRITE_REPLY :
                            (void *) xdr_REMOTE_WRITE_REPLY_PASCAL),
                           (char *) &write_reply,
                           *((struct timeval *) timeval_time_out))) != 0)
    {
      char *error_msg;
      error_msg = dl_clnt_sperrno (val);
      rcs_print_error ("%s\n", error_msg);
      if (val == RPC_TIMEDOUT)
        {
          rcs_print_error ("CMS:(%s) Network timed-out on write. \n",
                           BufferName);
          status = CMS_TIMED_OUT;
        }
      else
        {
          rcs_print_error
            ("CMS:(%s) Network communication error on write. \n", BufferName);
          status = CMS_MISC_ERROR;
        }
      return (status);
    }

  if (write_reply.status != CMS_WRITE_OK &&
      write_reply.status != CMS_WRITE_WAS_BLOCKED)
    {
      rcs_print_error ("CMS:(%s) Failure with remote server on write.\n",
                       BufferName);
    }
  header.was_read = write_reply.was_read;
  status = (CMS_STATUS) write_reply.status;
  return (status);
}

int
RPCMEM::login (const char *name, const char *passwd)
{
  REMOTE_GET_KEYS_REQUEST get_keys_req;
  REMOTE_GET_KEYS_REPLY get_keys_reply;
  REMOTE_LOGIN_REQUEST login_req;
  REMOTE_LOGIN_REPLY login_reply;
  char *crypt1_ret = NULL;
  char *crypt2_ret = NULL;
  char passwd_pass1[16];

  clnt_stat val;

  /* Check pointers. */
  if (NULL == clnt)
    {
      return (status = CMS_MISC_ERROR);
    }

  /* Setup get_keys request message. */
  get_keys_req.buffer_number = buffer_number;
  strncpy (get_keys_req.name, name, 16);

  /* get_keys our data to the BufferHost's shared memory via the server */
  if ((val = dl_clnt_call ((CLIENT *) clnt, 6,
                           (xdrproc_t)
                           (
                            (rpc_library_type != PCNFS_TKDLL_WINDOWS_31) ?
                            (void *) xdr_REMOTE_GET_KEYS_REQUEST :
                            (void *) xdr_REMOTE_GET_KEYS_REQUEST_PASCAL),
                           (char *) &get_keys_req,
                           (xdrproc_t)
                           (
                            (rpc_library_type != PCNFS_TKDLL_WINDOWS_31) ?
                            (void *) xdr_REMOTE_GET_KEYS_REPLY :
                            (void *) xdr_REMOTE_GET_KEYS_REPLY_PASCAL),
                           (char *) &get_keys_reply,
                           *((struct timeval *) timeval_time_out))) != 0)
    {
      char *error_msg;
      error_msg = dl_clnt_sperrno (val);
      rcs_print_error ("%s\n", error_msg);
      if (val == RPC_TIMEDOUT)
        {
          rcs_print_error ("CMS:(%s) Network timed-out on get_keys. \n",
                           BufferName);
          status = CMS_TIMED_OUT;
        }
      else
        {
          rcs_print_error
            ("CMS:(%s) Network communication error on get_keys. \n",
             BufferName);
          status = CMS_MISC_ERROR;
        }
      return (status);
    }


  /* Setup login request message. */
  strncpy (login_req.name, name, 16);
  crypt1_ret = rcs_crypt (passwd, get_keys_reply.key1);
  if (NULL == crypt1_ret)
    {
      rcs_print_error ("RPCMEM::login() : crypt function failed.\n");
      return 0;
    }
  strncpy (passwd_pass1, crypt1_ret, 16);
  crypt2_ret = rcs_crypt (passwd_pass1, get_keys_reply.key2);
  if (NULL == crypt2_ret)
    {
      rcs_print_error ("RPCMEM::login() : crypt function failed.\n");
      return 0;
    }
  strncpy (login_req.passwd, crypt2_ret, 16);
  login_req.buffer_number = buffer_number;



  /* login our data to the BufferHost's shared memory via the server */
  if ((val = dl_clnt_call ((CLIENT *) clnt, 7,
                           (xdrproc_t)
                           (
                            (rpc_library_type != PCNFS_TKDLL_WINDOWS_31) ?
                            (void *) xdr_REMOTE_LOGIN_REQUEST :
                            (void *) xdr_REMOTE_LOGIN_REQUEST_PASCAL),
                           (char *) &login_req,
                           (xdrproc_t)
                           (
                            (rpc_library_type != PCNFS_TKDLL_WINDOWS_31) ?
                            (void *) xdr_REMOTE_LOGIN_REPLY :
                            (void *) xdr_REMOTE_LOGIN_REPLY_PASCAL),
                           (char *) &login_reply,
                           *((struct timeval *) timeval_time_out))) != 0)
    {
      char *error_msg;
      error_msg = dl_clnt_sperrno (val);
      rcs_print_error ("%s\n", error_msg);
      if (val == RPC_TIMEDOUT)
        {
          rcs_print_error ("CMS:(%s) Network timed-out on login. \n",
                           BufferName);
          status = CMS_TIMED_OUT;
        }
      else
        {
          rcs_print_error
            ("CMS:(%s) Network communication error on login. \n", BufferName);
          status = CMS_MISC_ERROR;
        }
      return (0);
    }
  return (1);
}

---