---

rpc_srv.cc

Go to the documentation of this file.

extern "C"
{

#include <unistd.h>             // getpid()
#ifdef sunos5
#include <sys/select.h>         /* make sure NBBY defined before in.h */
  /* (needed for Solaris 2.6) */
#endif
#include <rpc/rpc.h>            /* SVCXPRT, svc_req,  xprt_, */
  /* & xdr_ functions */
#include <rpc/svc.h>            /* svc_ functions */
#ifdef sunos5
#include <rpc/svc_soc.h>
#endif

#if 0
  /* This is why I hate CenterLine and sparcworks */
  /* There should be a directory in
     /depot/Centerline called include which
     should contain all of the correct
     prototypes. */
  void svc_unregister (ulong prognum, ulong versnum);
  SVCXPRT *svctcp_create (int sock, u_int sendsz, u_int recvsz);
  bool_t svc_register (SVCXPRT * xprt, ulong prognum, ulong versnum,
                       void (*dispatch) (svc_req *, SVCXPRT *),
                       ulong protocol);
#endif

#ifdef VXWORKS
#include <rpcLib.h>             /* rpcTaskInit() */
#include <taskLib.h>            /* taskIdSelf() */
#endif
#if defined(VXWORKS) || defined(linuxppc) || defined(linuxPPC)
#ifdef svc_destroy
#undef svc_destroy
#define svc_destroy(xprt) \
  ((*(void (*)(SVCXPRT *))((xprt)->xp_ops->xp_destroy))(xprt))
#endif
#ifdef svc_getargs
#undef svc_getargs
#define svc_getargs(xprt,inproc,in) \
  ((*(bool_t (*)(SVCXPRT *,xdrproc_t, char *))((xprt)->xp_ops->xp_getargs))((xprt),(inproc), (in)))
#endif
#endif
}
#include "cms_srv.hh"           /* class CMS_SERVER */
#include "rpc_srv.hh"           /* class CMS_SERVER_REMOTE_RPC_PORT  */
#include "xdr_msg.hh"           /* xdr_REMOTE_READ_REQUEST(), */
                                /* xdr_REMOTE_WRITE_REQUEST */
#include "rcs_prnt.hh"          /* rcs_print_error() */

CMS_SERVER_REMOTE_RPC_PORT::CMS_SERVER_REMOTE_RPC_PORT (CMS_SERVER *
                                                        _cms_server_parent):CMS_SERVER_REMOTE_PORT
  (_cms_server_parent)
{
  prog_num = 0;
  xprt = NULL;
}

CMS_SERVER_REMOTE_RPC_PORT::~CMS_SERVER_REMOTE_RPC_PORT ()
{
  unregister_port ();
}

int
CMS_SERVER_REMOTE_RPC_PORT::accept_local_port_cms (CMS * _cms)
{
  if (NULL == _cms)
    {
      return 0;
    }

  if (_cms->remote_port_type != CMS_RPC_REMOTE_PORT_TYPE)
    {
      return 0;
    }

  if (prog_num == 0)
    {
      prog_num = _cms->rpc_program_number;
      return 1;
    }

  if (prog_num == _cms->rpc_program_number)
    {
      return 1;
    }
  return 0;
}

void
CMS_SERVER_REMOTE_RPC_PORT::run ()
{
  cms_server_count++;
  svc_run ();
}

void
CMS_SERVER_REMOTE_RPC_PORT::unregister_port ()
{
  if (0 != prog_num)
    {
      svc_unregister (prog_num, 1);
      prog_num = 0;
    }
  if (NULL != xprt)
    {
      svc_destroy (xprt);
      xprt = NULL;
    }
  port_registered = 0;
}

void
CMS_SERVER_REMOTE_RPC_PORT::register_port ()
{
  port_registered = 0;

#ifdef VXWORKS
  /* In VxWorks, always call rpcTaskInit() before using any other RPC call. */
  if (rpcTaskInit () < 0)
    {
      rcs_print_error ("CMS_SERVER_REMOTE_RPC_PORT: rpcTaskInit failed.\n");
      return;
    }
#endif

  /* Open a TCP/IP port to listen on. */
  xprt = (SVCXPRT *) svctcp_create (RPC_ANYSOCK, 0, 0);
  if (xprt == NULL)
    {
      rcs_print_error ("server: Can't create TCP socket.\n");
      cms_server_parent->clean (2);
      return;
    }

  /* Register with the RPC port_map facility. */
#if defined(sunos5) || defined(SGI) || defined(sparcworks) || defined(linux)
  if (svc_register (xprt, prog_num, 1, dispatch, IPPROTO_TCP) != TRUE)
#else
  if (svc_register (xprt, prog_num, 1, (void (*)()) dispatch,
                    IPPROTO_TCP) != TRUE)
#endif
    {
      rcs_print_error
        ("server: Can't register with RPC portmapper with program number %ld(0x%lX)\n",
         prog_num, prog_num);
      cms_server_parent->clean (2);
      return;
    }
  port_registered = 1;
}

/* Receive RPC calls and call the appropriate  CMS_SERVER_LOCAL_PORT function. */
void
CMS_SERVER_REMOTE_RPC_PORT::dispatch (svc_req * request,
                                      SVCXPRT * dispatch_xprt)
{

  CMS_SERVER *cms_server;

#ifdef VXWORKS
  int pid = taskIdSelf ();
#else
  pid_t pid = getpid ();
#endif

  rcs_print_debug (PRINT_RPC_SERVER_CALL, "RPC Server called.\n");
  rcs_print_debug (PRINT_RPC_SERVER_CALL, "(pid = %d, rq_proc = %d)\n",
                   pid, request->rq_proc);

  cms_server = find_server (pid);
  if (NULL == cms_server)
    {
      rcs_print_error
        ("Process Identifier(pid=%ld) does not match any on list of registered CMS servers.\n",
         pid);
      print_servers ();
      return;
    }
#if 0
#if defined(sunos5) || defined(sunos5CC)
  cms_server->remote_port->current_user_info =
    cms_server->remote_port->get_connected_user (dispatch_xprt->xp_fd);
#endif
#endif

  switch (request->rq_proc)
    {
    case 1:                     /* cms_reader */
      /* Get the request data  sent by remote reader. */
      if (svc_getargs (dispatch_xprt, (xdrproc_t) xdr_REMOTE_READ_REQUEST,
                       (char *) &cms_server->read_req) != TRUE)
        {
          rcs_print_error ("CMSserver: Couldn't getargs.\n");
          svcerr_decode (dispatch_xprt);
          return;
        }

#if 0
      /* Read from local CMS buffer. */
      cms_local_port =
        cms_server->find_local_port (cms_server->read_req.buffer_number);
      if (NULL == cms_local_port)
        {
          rcs_print_error ("CMSserver: Invalid buffer number (%d).\n",
                           cms_server->read_req.buffer_number);
          svcerr_systemerr (dispatch_xprt);
          return;
        }
      read_reply = cms_local_port->reader (&cms_server->read_req);
#endif
      cms_server->read_reply =
        (REMOTE_READ_REPLY
         *) (cms_server->process_request (&cms_server->read_req));

      if (NULL == cms_server->read_reply)
        {
          rcs_print_error ("CMSserver: Reader returned NULL.\n");
          svcerr_systemerr (dispatch_xprt);
          return;
        }

      /* Send buffer back to remote reader. */
      if (svc_sendreply (dispatch_xprt, (xdrproc_t) xdr_REMOTE_READ_REPLY,
                         (char *) cms_server->read_reply) != TRUE)
        {
          rcs_print_error ("CMSserver: Couldn't sendreply.\n");
          return;
        }
      break;

    case 2:                     /* cms_writer */
      /* Get the buffer that the remote writer is writing. */
      if (svc_getargs (dispatch_xprt, (xdrproc_t) xdr_REMOTE_WRITE_REQUEST,
                       (char *) &cms_server->write_req) != TRUE)
        {
          rcs_print_error ("CMSserver: Couldn't getargs.\n");
          svcerr_decode (dispatch_xprt);
          return;
        }

      /* Write to local CMS buffer. */
#if 0
      cms_local_port =
        cms_server->find_local_port (cms_server->write_req.buffer_number);
      if (NULL == cms_local_port)
        {
          rcs_print_error ("CMSserver: Invalid buffer number (%d).\n",
                           cms_server->write_req.buffer_number);
          svcerr_systemerr (dispatch_xprt);
          return;
        }
      write_reply = cms_local_port->writer (&cms_server->write_req);
#endif
      cms_server->write_reply =
        (REMOTE_WRITE_REPLY
         *) (cms_server->process_request (&cms_server->write_req));


      if (NULL == cms_server->write_reply)
        {
          rcs_print_error ("CMSserver: Writer returned NULL.\n");
          svcerr_systemerr (dispatch_xprt);
          return;
        }

      /* Send reply  back to the remote writer. */
      if (svc_sendreply (dispatch_xprt, (xdrproc_t) xdr_REMOTE_WRITE_REPLY,
                         (char *) cms_server->write_reply) != TRUE)
        {
          rcs_print_error ("CMSserver: Couldn't sendreply.\n");
          return;
        }
      break;
    case 3:                     /* check_if_read */
      /* Get the buffer that the remote writer is writing. */
      if (svc_getargs (dispatch_xprt, (xdrproc_t) xdr_long,
                       (char *) &cms_server->check_if_read_req.
                       buffer_number) != TRUE)
        {
          rcs_print_error ("CMSserver: Couldn't getargs.\n");
          svcerr_decode (dispatch_xprt);
          return;
        }

#if 0
      cms_local_port = cms_server->find_local_port (long_arg);
      if (NULL == cms_local_port)
        {
          rcs_print_error ("CMSserver: Invalid buffer number (%d).\n",
                           long_arg);
          svcerr_systemerr (dispatch_xprt);
          return;
        }
      int_ret = cms_local_port->cms->check_if_read ();
#endif
      cms_server->check_if_read_reply =
        (REMOTE_CHECK_IF_READ_REPLY
         *) (cms_server->process_request (&cms_server->check_if_read_req));

      /* Send an integer back to the remote writer. */
      if (svc_sendreply (dispatch_xprt, (xdrproc_t) xdr_int,
                         (char *) &cms_server->check_if_read_reply->
                         was_read) != TRUE)
        {
          rcs_print_error ("CMSserver: Couldn't sendreply.\n");
          return;
        }
      break;
    case 4:                     /* clean */
      cms_server->spawner_pid = cms_server->server_pid;
      cms_server->kill_server ();
      break;
    case 5:                     /* clear */
      /* Get the buffer that the remote writer is writing. */
      if (svc_getargs (dispatch_xprt, (xdrproc_t) xdr_long,
                       (char *) &cms_server->clear_req.buffer_number) != TRUE)
        {
          rcs_print_error ("CMSserver: Couldn't getargs.\n");
          svcerr_decode (dispatch_xprt);
          return;
        }

#if 0
      cms_local_port = cms_server->find_local_port (long_arg);
      if (NULL == cms_local_port)
        {
          rcs_print_error ("CMSserver: Invalid buffer number (%d).\n",
                           long_arg);
          svcerr_systemerr (dispatch_xprt);
          return;
        }
      int_ret = cms_local_port->cms->clear ();
#endif
      cms_server->clear_reply =
        (REMOTE_CLEAR_REPLY
         *) (cms_server->process_request (&cms_server->clear_req));


      /* Send an integer back to the remote writer. */
      if (svc_sendreply (dispatch_xprt, (xdrproc_t) xdr_int,
                         (char *) &cms_server->clear_reply->status) != TRUE)
        {
          rcs_print_error ("CMSserver: Couldn't sendreply.\n");
          return;
        }
      break;
    case 6:                     /* Get Keys */
      if (svc_getargs (dispatch_xprt, (xdrproc_t) xdr_REMOTE_GET_KEYS_REQUEST,
                       (char *) &cms_server->get_keys_req) != TRUE)
        {
          rcs_print_error ("CMSserver: Couldn't getargs.\n");
          svcerr_decode (dispatch_xprt);
          return;
        }

      /* Write to local CMS buffer. */
      cms_server->get_keys_reply =
        (REMOTE_GET_KEYS_REPLY
         *) (cms_server->process_request (&cms_server->get_keys_req));


      if (NULL == cms_server->get_keys_reply)
        {
          rcs_print_error ("CMSserver: Get_Keys returned NULL.\n");
          svcerr_systemerr (dispatch_xprt);
          return;
        }

      /* Send reply  back to the remote get_keysr. */
      if (svc_sendreply (dispatch_xprt, (xdrproc_t) xdr_REMOTE_GET_KEYS_REPLY,
                         (char *) cms_server->get_keys_reply) != TRUE)
        {
          rcs_print_error ("CMSserver: Couldn't sendreply.\n");
          return;
        }
      break;
    case 7:                     /* Login */
      if (svc_getargs (dispatch_xprt, (xdrproc_t) xdr_REMOTE_LOGIN_REQUEST,
                       (char *) &cms_server->login_req) != TRUE)
        {
          rcs_print_error ("CMSserver: Couldn't getargs.\n");
          svcerr_decode (dispatch_xprt);
          return;
        }

      /* Write to local CMS buffer. */
      cms_server->login_reply =
        (REMOTE_LOGIN_REPLY
         *) (cms_server->process_request (&cms_server->login_req));


      if (NULL == cms_server->login_reply)
        {
          rcs_print_error ("CMSserver: Login returned NULL.\n");
          svcerr_systemerr (dispatch_xprt);
          return;
        }

      /* Send reply  back to the remote loginr. */
      if (svc_sendreply (dispatch_xprt, (xdrproc_t) xdr_REMOTE_LOGIN_REPLY,
                         (char *) cms_server->login_reply) != TRUE)
        {
          rcs_print_error ("CMSserver: Couldn't sendreply.\n");
          return;
        }
      break;

    default:
      rcs_print_error ("CMS_server: Invalid RPC procedure number. (%d)\n",
                       request->rq_proc);
      svcerr_noproc (dispatch_xprt);
      break;
    }
}

---