svc.c File Reference

#include <wintirpc.h>
#include <reentrant.h>
#include <sys/types.h>
#include <assert.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <rpc/rpc.h>
#include "rpc_com.h"

Include dependency graph for svc.c:

Go to the source code of this file.

Classes
struct	svc_callout

Macros
#define	RQCRED_SIZE   400 /* this size is excessive */
#define	SVC_VERSQUIET   0x0001 /* keep quiet about vers mismatch */
#define	version_keepquiet(xp)   ((u_long)(xp)->xp_p3 & SVC_VERSQUIET)
#define	max(a, b)   (a > b ? a : b)

Functions
static struct svc_callout *	svc_find (rpcprog_t, rpcvers_t, struct svc_callout **, char *)
static void	__xprt_do_unregister (SVCXPRT *xprt, bool_t dolock)
void	xprt_register (SVCXPRT *xprt)
void	xprt_unregister (SVCXPRT *xprt)
void	__xprt_unregister_unlocked (SVCXPRT *xprt)
bool_t	svc_reg (SVCXPRT *xprt, const rpcprog_t prog, const rpcvers_t vers, void *dispatch, const struct netconfig *nconf)
void	svc_unreg (rpcprog_t prog, const rpcvers_t vers) const
bool_t	svc_sendreply (SVCXPRT *xprt, xdrproc_t xdr_results, void *xdr_location)
void	svcerr_noproc (SVCXPRT *xprt)
void	svcerr_decode (SVCXPRT *xprt)
void	svcerr_systemerr (SVCXPRT *xprt)
void	svcerr_auth (SVCXPRT *xprt, enum auth_stat why)
void	svcerr_weakauth (SVCXPRT *xprt)
void	svcerr_noprog (SVCXPRT *xprt)
void	svcerr_progvers (SVCXPRT *xprt, rpcvers_t low_vers, rpcvers_t high_vers)
void	svc_getreq (int rdfds)
void	svc_getreqset (fd_set *readfds)
void	svc_getreq_common (SOCKET fd)
void	svc_getreq_poll (struct pollfd *pfdp, int pollretval)
bool_t	rpc_control (int what, void *arg)

Variables
static struct svc_callout *	svc_head
rwlock_t	svc_lock
rwlock_t	svc_fd_lock

Macro Definition Documentation

max

#define max	(		a,
			b
	)		(a > b ? a : b)

Definition at line 63 of file svc.c.

RQCRED_SIZE

#define RQCRED_SIZE   400 /* this size is excessive */

Definition at line 57 of file svc.c.

SVC_VERSQUIET

#define SVC_VERSQUIET   0x0001 /* keep quiet about vers mismatch */

Definition at line 59 of file svc.c.

version_keepquiet

#define version_keepquiet

(

xp

)

((u_long)(xp)->xp_p3 & SVC_VERSQUIET)

Definition at line 60 of file svc.c.

Function Documentation

__xprt_do_unregister()

static void __xprt_do_unregister ( SVCXPRT *  xprt, bool_t  dolock  )

static

Definition at line 143 of file svc.c.

{
  SOCKET sock;

  assert (xprt != NULL);

  sock = xprt->xp_fd;

#ifndef _WIN32
  if (dolock)
    rwlock_wrlock (&svc_fd_lock);
  if ((sock < FD_SETSIZE) && (__svc_xports[sock] == xprt)) {
    __svc_xports[sock] = NULL;
    FD_CLR (sock, &svc_fdset);
    if (sock >= svc_maxfd) {
      for (svc_maxfd--; svc_maxfd >= 0; svc_maxfd--)
        if (__svc_xports[svc_maxfd])
          break;
    }
  }
  if (dolock)
    rwlock_unlock (&svc_fd_lock);
#else
  fprintf(stderr, "%s: Yikes!  Figure out __svc_xports[] issue!!\n", __FUNCTION__);
#endif
}

Referenced by __xprt_unregister_unlocked(), and xprt_unregister().

__xprt_unregister_unlocked()

void __xprt_unregister_unlocked

(

SVCXPRT *

xprt

)

Definition at line 134 of file svc.c.

{
  __xprt_do_unregister (xprt, FALSE);
}

Referenced by __svc_clean_idle().

rpc_control()

bool_t rpc_control	(	int	what,
		void *	arg
	)

Definition at line 784 of file svc.c.

{
  int val;

  switch (what)
    {
    case RPC_SVC_CONNMAXREC_SET:
      val = *(int *) arg;
      if (val <= 0)
    return FALSE;
      __svc_maxrec = val;
      return TRUE;
    case RPC_SVC_CONNMAXREC_GET:
      *(int *) arg = __svc_maxrec;
      return TRUE;
    default:
      break;
    }
  return FALSE;
}

svc_find()

static struct svc_callout * svc_find ( rpcprog_t  prog, rpcvers_t  vers, struct svc_callout **  prev, char *  netid  )

static

Definition at line 370 of file svc.c.

{
  struct svc_callout *s, *p;

  assert (prev != NULL);

  p = NULL;
  for (s = svc_head; s != NULL; s = s->sc_next)
    {
      if (((s->sc_prog == prog) && (s->sc_vers == vers)) &&
      ((netid == NULL) || (s->sc_netid == NULL) ||
       (strcmp (netid, s->sc_netid) == 0)))
    break;
      p = s;
    }
  *prev = p;
  return (s);
}

Referenced by svc_reg(), and svc_unreg().

svc_getreq()

void svc_getreq

(

int

rdfds

)

Definition at line 604 of file svc.c.

{
  fd_set readfds;

  FD_ZERO (&readfds);
  //XXX Windows!! readfds.fds_bits[0] = rdfds;
  svc_getreqset (&readfds);
}

svc_getreq_common()

void svc_getreq_common

(

SOCKET

fd

)

Definition at line 641 of file svc.c.

{
  SVCXPRT *xprt;
  struct svc_req r;
  struct rpc_msg msg;
  int prog_found;
  rpcvers_t low_vers;
  rpcvers_t high_vers;
  enum xprt_stat stat;
  char cred_area[2 * MAX_AUTH_BYTES + RQCRED_SIZE];

  msg.rm_call.cb_cred.oa_base = cred_area;
  msg.rm_call.cb_verf.oa_base = &(cred_area[MAX_AUTH_BYTES]);
  r.rq_clntcred = &(cred_area[2 * MAX_AUTH_BYTES]);

  rwlock_rdlock (&svc_fd_lock);
  xprt = __svc_xports[fd];
  rwlock_unlock (&svc_fd_lock);
  if (xprt == NULL)
    /* But do we control sock? */
    return;
  /* now receive msgs from xprtprt (support batch calls) */
  do
    {
      if (SVC_RECV (xprt, &msg))
    {

      /* now find the exported program and call it */
      struct svc_callout *s;
      enum auth_stat why;

      r.rq_xprt = xprt;
      r.rq_prog = msg.rm_call.cb_prog;
      r.rq_vers = msg.rm_call.cb_vers;
      r.rq_proc = msg.rm_call.cb_proc;
      r.rq_cred = msg.rm_call.cb_cred;
      /* first authenticate the message */
      if ((why = _authenticate (&r, &msg)) != AUTH_OK)
        {
          svcerr_auth (xprt, why);
          goto call_done;
        }
      /* now match message with a registered service */
      prog_found = FALSE;
      low_vers = (rpcvers_t) - 1L;
      high_vers = (rpcvers_t) 0L;
      for (s = svc_head; s != NULL; s = s->sc_next)
        {
          if (s->sc_prog == r.rq_prog)
        {
          if (s->sc_vers == r.rq_vers)
            {
              (*s->sc_dispatch) (&r, xprt);
              goto call_done;
            }       /* found correct version */
          prog_found = TRUE;
          if (s->sc_vers < low_vers)
            low_vers = s->sc_vers;
          if (s->sc_vers > high_vers)
            high_vers = s->sc_vers;
        }       /* found correct program */
        }
      /*
       * if we got here, the program or version
       * is not served ...
       */
      if (prog_found)
        svcerr_progvers (xprt, low_vers, high_vers);
      else
        svcerr_noprog (xprt);
      /* Fall through to ... */
    }
      /*
       * Check if the xprt has been disconnected in a
       * recursive call in the service dispatch routine.
       * If so, then break.
       */
      rwlock_rdlock (&svc_fd_lock);
      
      if (xprt != __svc_xports[fd])
    {
      rwlock_unlock (&svc_fd_lock);
      break;
    }
      rwlock_unlock (&svc_fd_lock);
    call_done:
      if ((stat = SVC_STAT (xprt)) == XPRT_DIED)
    {
      SVC_DESTROY (xprt);
      break;
    }
    else if ((xprt->xp_auth != NULL) 
#ifdef HAVE_LIBGSSAPI
        && (xprt->xp_auth->svc_ah_ops != &svc_auth_gss_ops)
#endif
    ) {
      xprt->xp_auth = NULL;
    }
    }
  while (stat == XPRT_MOREREQS);
}

Referenced by svc_getreq_poll(), and svc_getreqset().

svc_getreq_poll()

void svc_getreq_poll	(	struct pollfd *	pfdp,
		int	pollretval
	)

Definition at line 745 of file svc.c.

{
  int i;
  int fds_found;

  for (i = fds_found = 0; fds_found < pollretval; i++)
    {
      struct pollfd *p = &pfdp[i];

      if (p->revents)
    {
      /* fd has input waiting */
      fds_found++;
      /*
       *      We assume that this function is only called
       *      via someone _select()ing from svc_fdset or
       *      _poll()ing from svc_pollset[].  Thus it's safe
       *      to handle the POLLNVAL event by simply turning
       *      the corresponding bit off in svc_fdset.  The
       *      svc_pollset[] array is derived from svc_fdset
       *      and so will also be updated eventually.
       *
       *      XXX Should we do an xprt_unregister() instead?
       */
      if (p->revents & POLLNVAL)
        {
          rwlock_wrlock (&svc_fd_lock);
          FD_CLR (p->fd, &svc_fdset);
          rwlock_unlock (&svc_fd_lock);
        }
      else
        svc_getreq_common (p->fd);
    }
    }
}

svc_getreqset()

void svc_getreqset

(

fd_set *

readfds

)

Definition at line 615 of file svc.c.

{
#ifndef _WIN32
  int bit, fd;
  fd_mask mask, *maskp;
  int sock;

  assert (readfds != NULL);

  maskp = readfds->fds_bits;
  for (sock = 0; sock < FD_SETSIZE; sock += NFDBITS)
    {
      for (mask = *maskp++; (bit = ffs (mask)) != 0; mask ^= (1 << (bit - 1)))
    {
      /* sock has input waiting */
      fd = sock + bit - 1;
      svc_getreq_common (fd);
    }
    }
#else
    fprintf(stderr, "%s: Yikes!\n", __FUNCTION__);
#endif
}

Referenced by svc_getreq(), and svc_run().

svc_reg()

bool_t svc_reg	(	SVCXPRT *	xprt,
		const rpcprog_t	prog,
		const rpcvers_t	vers,
		void *	dispatch,
		const struct netconfig *	nconf
	)

Definition at line 178 of file svc.c.

{
  bool_t dummy;
  struct svc_callout *prev;
  struct svc_callout *s;
  struct netconfig *tnconf;
  char *netid = NULL;
  int flag = 0;

/* VARIABLES PROTECTED BY svc_lock: s, prev, svc_head */
  if (xprt->xp_netid)
    {
      netid = strdup (xprt->xp_netid);
      flag = 1;
    }
  else if (nconf && nconf->nc_netid)
    {
      netid = strdup (nconf->nc_netid);
      flag = 1;
    }
  else if ((tnconf = __rpcgettp (xprt->xp_fd)) != NULL)
    {
      netid = strdup (tnconf->nc_netid);
      flag = 1;
      freenetconfigent (tnconf);
    }               /* must have been created with svc_raw_create */
  if ((netid == NULL) && (flag == 1))
    {
      return (FALSE);
    }

  rwlock_wrlock (&svc_lock);
  if ((s = svc_find (prog, vers, &prev, netid)) != NULL)
    {
      if (netid)
    free (netid);
      if (s->sc_dispatch == dispatch)
    goto rpcb_it;       /* he is registering another xptr */
      rwlock_unlock (&svc_lock);
      return (FALSE);
    }
  s = mem_alloc (sizeof (struct svc_callout));
  if (s == NULL)
    {
      if (netid)
    free (netid);
      rwlock_unlock (&svc_lock);
      return (FALSE);
    }

  s->sc_prog = prog;
  s->sc_vers = vers;
  s->sc_dispatch = dispatch;
  s->sc_netid = netid;
  s->sc_next = svc_head;
  svc_head = s;

  if ((xprt->xp_netid == NULL) && (flag == 1) && netid)
    ((SVCXPRT *) xprt)->xp_netid = strdup (netid);

rpcb_it:
  rwlock_unlock (&svc_lock);
  /* now register the information with the local binder service */
  if (nconf)
    {
      /*LINTED const castaway */
      dummy = rpcb_set (prog, vers, (struct netconfig *) nconf,
            &((SVCXPRT *) xprt)->xp_ltaddr);
      return (dummy);
    }
  return (TRUE);
}

Referenced by rpc_reg(), svc_create(), and svc_tp_create().

svc_sendreply()

bool_t svc_sendreply	(	SVCXPRT *	xprt,
		xdrproc_t	xdr_results,
		void *	xdr_location
	)

Definition at line 399 of file svc.c.

{
  struct rpc_msg rply;

  assert (xprt != NULL);

  rply.rm_direction = REPLY;
  rply.rm_reply.rp_stat = MSG_ACCEPTED;
  rply.acpted_rply.ar_verf = xprt->xp_verf;
  rply.acpted_rply.ar_stat = SUCCESS;
  rply.acpted_rply.ar_results.where = xdr_location;
  rply.acpted_rply.ar_results.proc = xdr_results;
  return (SVC_REPLY (xprt, &rply));
}

Referenced by _svcauth_gss(), and universal().

svc_unreg()

void svc_unreg	(	rpcprog_t	prog,
		const rpcvers_t	vers
	)		const

Definition at line 260 of file svc.c.

{
  struct svc_callout *prev;
  struct svc_callout *s;

  /* unregister the information anyway */
  (void) rpcb_unset (prog, vers, NULL);
  rwlock_wrlock (&svc_lock);
  while ((s = svc_find (prog, vers, &prev, NULL)) != NULL)
    {
      if (prev == NULL)
    {
      svc_head = s->sc_next;
    }
      else
    {
      prev->sc_next = s->sc_next;
    }
      s->sc_next = NULL;
      if (s->sc_netid)
    mem_free (s->sc_netid, sizeof (s->sc_netid) + 1);
      mem_free (s, sizeof (struct svc_callout));
    }
  rwlock_unlock (&svc_lock);
}

svcerr_auth()

void svcerr_auth	(	SVCXPRT *	xprt,
		enum auth_stat	why
	)

Definition at line 517 of file svc.c.

{
  struct rpc_msg rply;

  assert (xprt != NULL);

  rply.rm_direction = REPLY;
  rply.rm_reply.rp_stat = MSG_DENIED;
  rply.rjcted_rply.rj_stat = AUTH_ERROR;
  rply.rjcted_rply.rj_why = why;
  SVC_REPLY (xprt, &rply);
}

Referenced by svc_getreq_common(), and svcerr_weakauth().

svcerr_decode()

void svcerr_decode

(

SVCXPRT *

xprt

)

Definition at line 439 of file svc.c.

{
  struct rpc_msg rply;

  assert (xprt != NULL);

  rply.rm_direction = REPLY;
  rply.rm_reply.rp_stat = MSG_ACCEPTED;
  rply.acpted_rply.ar_verf = xprt->xp_verf;
  rply.acpted_rply.ar_stat = GARBAGE_ARGS;
  SVC_REPLY (xprt, &rply);
}

Referenced by universal().

svcerr_noproc()

void svcerr_noproc

(

SVCXPRT *

xprt

)

Definition at line 421 of file svc.c.

{
  struct rpc_msg rply;

  assert (xprt != NULL);

  rply.rm_direction = REPLY;
  rply.rm_reply.rp_stat = MSG_ACCEPTED;
  rply.acpted_rply.ar_verf = xprt->xp_verf;
  rply.acpted_rply.ar_stat = PROC_UNAVAIL;
  SVC_REPLY (xprt, &rply);
}

svcerr_noprog()

void svcerr_noprog

(

SVCXPRT *

xprt

)

Definition at line 549 of file svc.c.

{
  struct rpc_msg rply;

  assert (xprt != NULL);

  rply.rm_direction = REPLY;
  rply.rm_reply.rp_stat = MSG_ACCEPTED;
  rply.acpted_rply.ar_verf = xprt->xp_verf;
  rply.acpted_rply.ar_stat = PROG_UNAVAIL;
  SVC_REPLY (xprt, &rply);
}

Referenced by svc_getreq_common().

svcerr_progvers()

void svcerr_progvers	(	SVCXPRT *	xprt,
		rpcvers_t	low_vers,
		rpcvers_t	high_vers
	)

Definition at line 567 of file svc.c.

{
  struct rpc_msg rply;

  assert (xprt != NULL);

  rply.rm_direction = REPLY;
  rply.rm_reply.rp_stat = MSG_ACCEPTED;
  rply.acpted_rply.ar_verf = xprt->xp_verf;
  rply.acpted_rply.ar_stat = PROG_MISMATCH;
  rply.acpted_rply.ar_vers.low = (u_int32_t) low_vers;
  rply.acpted_rply.ar_vers.high = (u_int32_t) high_vers;
  SVC_REPLY (xprt, &rply);
}

Referenced by svc_getreq_common().

svcerr_systemerr()

void svcerr_systemerr

(

SVCXPRT *

xprt

)

Definition at line 457 of file svc.c.

{
  struct rpc_msg rply;

  assert (xprt != NULL);

  rply.rm_direction = REPLY;
  rply.rm_reply.rp_stat = MSG_ACCEPTED;
  rply.acpted_rply.ar_verf = xprt->xp_verf;
  rply.acpted_rply.ar_stat = SYSTEM_ERR;
  SVC_REPLY (xprt, &rply);
}

svcerr_weakauth()

void svcerr_weakauth

(

SVCXPRT *

xprt

)

Definition at line 536 of file svc.c.

{

  assert (xprt != NULL);

  svcerr_auth (xprt, AUTH_TOOWEAK);
}

xprt_register()

void xprt_register

(

SVCXPRT *

xprt

)

Definition at line 97 of file svc.c.

{
  SOCKET sock;

  assert (xprt != NULL);

  sock = xprt->xp_fd;

  rwlock_wrlock (&svc_fd_lock);
  if (__svc_xports == NULL) {
      __svc_xports = (SVCXPRT **) mem_alloc (FD_SETSIZE * sizeof (SVCXPRT *));
      if (__svc_xports == NULL) {
        // XXX Give an error indication?
        return;
      }
      memset (__svc_xports, 0, FD_SETSIZE * sizeof (SVCXPRT *));
  }
#ifndef _WIN32
  if (sock < FD_SETSIZE) {
    __svc_xports[sock] = xprt;
    FD_SET (sock, &svc_fdset);
    svc_maxfd = max (svc_maxfd, sock);
  }
#else
  fprintf(stderr, "%s: Yikes!  Figure out __svc_xports[] issue!!\n", __FUNCTION__);
#endif
  rwlock_unlock (&svc_fd_lock);
}

Referenced by makefd_xprt(), svc_dg_create(), svc_raw_create(), and svc_vc_create().

xprt_unregister()

void xprt_unregister

(

SVCXPRT *

xprt

)

Definition at line 128 of file svc.c.

{
  __xprt_do_unregister (xprt, TRUE);
}

Referenced by svc_dg_destroy(), and svc_vc_destroy().

Variable Documentation

svc_fd_lock

rwlock_t svc_fd_lock

Definition at line 22 of file mt_misc.c.

Referenced by __xprt_do_unregister(), svc_getreq_common(), svc_getreq_poll(), and xprt_register().

svc_head

struct svc_callout * svc_head

static

Referenced by svc_find(), svc_getreq_common(), svc_reg(), and svc_unreg().

svc_lock

rwlock_t svc_lock

Definition at line 19 of file mt_misc.c.

Referenced by svc_reg(), and svc_unreg().