svc.h File Reference

#include <rpc/svc_soc.h>

Include dependency graph for svc.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	__rpc_svcxprt
struct	__rpc_svcxprt::xp_ops
struct	__rpc_svcxprt::xp_ops2
struct	svc_req

Macros
#define	SVCGET_VERSQUIET   1
#define	SVCSET_VERSQUIET   2
#define	SVCGET_CONNMAXREC   3
#define	SVCSET_CONNMAXREC   4
#define	RPC_SVC_CONNMAXREC_SET   0 /* set max rec size, enable nonblock */
#define	RPC_SVC_CONNMAXREC_GET   1
#define	svc_getrpccaller(x)   (&(x)->xp_rtaddr)
#define	SVC_RECV(xprt, msg)    (*(xprt)->xp_ops->xp_recv)((xprt), (msg))
#define	svc_recv(xprt, msg)    (*(xprt)->xp_ops->xp_recv)((xprt), (msg))
#define	SVC_STAT(xprt)    (*(xprt)->xp_ops->xp_stat)(xprt)
#define	svc_stat(xprt)    (*(xprt)->xp_ops->xp_stat)(xprt)
#define	SVC_GETARGS(xprt, xargs, argsp)    (*(xprt)->xp_ops->xp_getargs)((xprt), (xargs), (argsp))
#define	svc_getargs(xprt, xargs, argsp)    (*(xprt)->xp_ops->xp_getargs)((xprt), (xargs), (argsp))
#define	SVC_REPLY(xprt, msg)    (*(xprt)->xp_ops->xp_reply) ((xprt), (msg))
#define	svc_reply(xprt, msg)    (*(xprt)->xp_ops->xp_reply) ((xprt), (msg))
#define	SVC_FREEARGS(xprt, xargs, argsp)    (*(xprt)->xp_ops->xp_freeargs)((xprt), (xargs), (argsp))
#define	svc_freeargs(xprt, xargs, argsp)    (*(xprt)->xp_ops->xp_freeargs)((xprt), (xargs), (argsp))
#define	SVC_DESTROY(xprt)    (*(xprt)->xp_ops->xp_destroy)(xprt)
#define	svc_destroy(xprt)    (*(xprt)->xp_ops->xp_destroy)(xprt)
#define	SVC_CONTROL(xprt, rq, in)    (*(xprt)->xp_ops2->xp_control)((xprt), (rq), (in))
#define	RPC_ANYSOCK   INVALID_SOCKET /* -1 */
#define	RPC_ANYFD   RPC_ANYSOCK

Typedefs
typedef struct __rpc_svcxprt	SVCXPRT

Enumerations
enum	xprt_stat { XPRT_DIED , XPRT_MOREREQS , XPRT_IDLE }

Functions
__BEGIN_DECLS bool_t	svc_reg (SVCXPRT *, const rpcprog_t, const rpcvers_t, void(*)(struct svc_req *, SVCXPRT *), const struct netconfig *)
__END_DECLS __BEGIN_DECLS void	svc_unreg (const rpcprog_t, const rpcvers_t)
__END_DECLS __BEGIN_DECLS void	xprt_register (SVCXPRT *)
__END_DECLS __BEGIN_DECLS void	xprt_unregister (SVCXPRT *)
__END_DECLS __BEGIN_DECLS bool_t	svc_sendreply (SVCXPRT *, xdrproc_t, void *)
void	svcerr_decode (SVCXPRT *)
void	svcerr_weakauth (SVCXPRT *)
void	svcerr_noproc (SVCXPRT *)
void	svcerr_progvers (SVCXPRT *, rpcvers_t, rpcvers_t)
void	svcerr_auth (SVCXPRT *, enum auth_stat)
void	svcerr_noprog (SVCXPRT *)
void	svcerr_systemerr (SVCXPRT *)
int	rpc_reg (rpcprog_t, rpcvers_t, rpcproc_t, char *(*)(char *), xdrproc_t, xdrproc_t, char *)
__BEGIN_DECLS void	rpctest_service (void)
__END_DECLS __BEGIN_DECLS void	svc_getreq (int)
void	svc_getreqset (fd_set *)
void	svc_getreq_common (SOCKET)
void	svc_getreq_poll (struct pollfd *, int)
void	svc_run (void)
void	svc_exit (void)
__BEGIN_DECLS int	svc_create (void(*)(struct svc_req *, SVCXPRT *), const rpcprog_t, const rpcvers_t, const char *)
SVCXPRT *	svc_tp_create (void(*)(struct svc_req *, SVCXPRT *), const rpcprog_t, const rpcvers_t, const struct netconfig *)
SVCXPRT *	svc_tli_create (const SOCKET, const struct netconfig *, const struct t_bind *, const u_int, const u_int)
SVCXPRT *	svc_vc_create (const SOCKET, const u_int, const u_int)
SVCXPRT *	svcunix_create (int, u_int, u_int, char *)
SVCXPRT *	svc_dg_create (const SOCKET, const u_int, const u_int)
SVCXPRT *	svc_fd_create (const SOCKET, const u_int, const u_int)
SVCXPRT *	svcunixfd_create (int, u_int, u_int)
SVCXPRT *	svc_raw_create (void)
int	svc_dg_enablecache (SVCXPRT *, const u_int)
int	__rpc_get_local_uid (SVCXPRT *_transp, uid_t *_uid)

Variables
__END_DECLS int	svc_maxfd
int	svc_fds

Macro Definition Documentation

RPC_ANYFD

#define RPC_ANYFD   RPC_ANYSOCK

Definition at line 328 of file svc.h.

RPC_ANYSOCK

#define RPC_ANYSOCK   INVALID_SOCKET /* -1 */

Definition at line 327 of file svc.h.

RPC_SVC_CONNMAXREC_GET

#define RPC_SVC_CONNMAXREC_GET   1

Definition at line 79 of file svc.h.

RPC_SVC_CONNMAXREC_SET

#define RPC_SVC_CONNMAXREC_SET   0 /* set max rec size, enable nonblock */

Definition at line 78 of file svc.h.

SVC_CONTROL

#define SVC_CONTROL	(		xprt,
			rq,
			in
	)		(*(xprt)->xp_ops2->xp_control)((xprt), (rq), (in))

Definition at line 189 of file svc.h.

SVC_DESTROY

#define SVC_DESTROY

(

xprt

)

(*(xprt)->xp_ops->xp_destroy)(xprt)

Definition at line 184 of file svc.h.

svc_destroy

#define svc_destroy

(

xprt

)

(*(xprt)->xp_ops->xp_destroy)(xprt)

Definition at line 186 of file svc.h.

SVC_FREEARGS

#define SVC_FREEARGS	(		xprt,
			xargs,
			argsp
	)		(*(xprt)->xp_ops->xp_freeargs)((xprt), (xargs), (argsp))

Definition at line 179 of file svc.h.

svc_freeargs

#define svc_freeargs	(		xprt,
			xargs,
			argsp
	)		(*(xprt)->xp_ops->xp_freeargs)((xprt), (xargs), (argsp))

Definition at line 181 of file svc.h.

SVC_GETARGS

#define SVC_GETARGS	(		xprt,
			xargs,
			argsp
	)		(*(xprt)->xp_ops->xp_getargs)((xprt), (xargs), (argsp))

Definition at line 169 of file svc.h.

svc_getargs

#define svc_getargs	(		xprt,
			xargs,
			argsp
	)		(*(xprt)->xp_ops->xp_getargs)((xprt), (xargs), (argsp))

Definition at line 171 of file svc.h.

svc_getrpccaller

#define svc_getrpccaller

(

x

)

(&(x)->xp_rtaddr)

Definition at line 149 of file svc.h.

SVC_RECV

#define SVC_RECV	(		xprt,
			msg
	)		(*(xprt)->xp_ops->xp_recv)((xprt), (msg))

Definition at line 159 of file svc.h.

svc_recv

#define svc_recv	(		xprt,
			msg
	)		(*(xprt)->xp_ops->xp_recv)((xprt), (msg))

Definition at line 161 of file svc.h.

SVC_REPLY

#define SVC_REPLY	(		xprt,
			msg
	)		(*(xprt)->xp_ops->xp_reply) ((xprt), (msg))

Definition at line 174 of file svc.h.

svc_reply

#define svc_reply	(		xprt,
			msg
	)		(*(xprt)->xp_ops->xp_reply) ((xprt), (msg))

Definition at line 176 of file svc.h.

SVC_STAT

#define SVC_STAT

(

xprt

)

(*(xprt)->xp_ops->xp_stat)(xprt)

Definition at line 164 of file svc.h.

svc_stat

#define svc_stat

(

xprt

)

(*(xprt)->xp_ops->xp_stat)(xprt)

Definition at line 166 of file svc.h.

SVCGET_CONNMAXREC

#define SVCGET_CONNMAXREC   3

Definition at line 72 of file svc.h.

SVCGET_VERSQUIET

#define SVCGET_VERSQUIET   1

Definition at line 70 of file svc.h.

SVCSET_CONNMAXREC

#define SVCSET_CONNMAXREC   4

Definition at line 73 of file svc.h.

SVCSET_VERSQUIET

#define SVCSET_VERSQUIET   2

Definition at line 71 of file svc.h.

Typedef Documentation

SVCXPRT

typedef struct __rpc_svcxprt SVCXPRT

Enumeration Type Documentation

xprt_stat

enum xprt_stat

Enumerator
XPRT_DIED
XPRT_MOREREQS
XPRT_IDLE

Definition at line 81 of file svc.h.

               {
    XPRT_DIED,
    XPRT_MOREREQS,
    XPRT_IDLE
};

Function Documentation

__rpc_get_local_uid()

int __rpc_get_local_uid	(	SVCXPRT *	_transp,
		uid_t *	_uid
	)

Definition at line 783 of file svc_vc.c.

                                                 {
    SOCKET sock;
    int ret;
    gid_t egid;
    uid_t euid;
    struct sockaddr *sa;
 
    sock = transp->xp_fd;
    sa = (struct sockaddr *)transp->xp_rtaddr.buf;
    if (sa->sa_family == AF_UNIX) {
        ret = getpeereid(sock, &euid, &egid);
        if (ret == 0)
            *uid = euid;
        return (ret);
    } else
        return (-1);
}

rpc_reg()

int rpc_reg	(	rpcprog_t	,
		rpcvers_t	,
		rpcproc_t	,
		char *	*)(char *,
		xdrproc_t	,
		xdrproc_t	,
		char *
	)

rpctest_service()

__BEGIN_DECLS void rpctest_service

(

void

)

svc_create()

__BEGIN_DECLS int svc_create	(	void(*)(struct svc_req *, SVCXPRT *)	,
		const	rpcprog_t,
		const	rpcvers_t,
		const char *
	)

svc_dg_create()

SVCXPRT * svc_dg_create	(	const	SOCKET,
		const	u_int,
		const	u_int
	)

svc_dg_enablecache()

int svc_dg_enablecache	(	SVCXPRT *	transp,
		const	u_int
	)

Definition at line 386 of file svc_dg.c.

{
    struct svc_dg_data *su = su_data(transp);
    struct cl_cache *uc;
 
    mutex_lock(&dupreq_lock);
    if (su->su_cache != NULL) {
        // XXX (void) warnx(cache_enable_str, enable_err, " ");
        mutex_unlock(&dupreq_lock);
        return (0);
    }
    uc = ALLOC(struct cl_cache, 1);
    if (uc == NULL) {
        // XXX warnx(cache_enable_str, alloc_err, " ");
        mutex_unlock(&dupreq_lock);
        return (0);
    }
    uc->uc_size = size;
    uc->uc_nextvictim = 0;
    uc->uc_entries = ALLOC(cache_ptr, size * SPARSENESS);
    if (uc->uc_entries == NULL) {
        // XXX warnx(cache_enable_str, alloc_err, "data");
        FREE(uc, struct cl_cache, 1);
        mutex_unlock(&dupreq_lock);
        return (0);
    }
    MEMZERO(uc->uc_entries, cache_ptr, size * SPARSENESS);
    uc->uc_fifo = ALLOC(cache_ptr, size);
    if (uc->uc_fifo == NULL) {
        // XXX warnx(cache_enable_str, alloc_err, "fifo");
        FREE(uc->uc_entries, cache_ptr, size * SPARSENESS);
        FREE(uc, struct cl_cache, 1);
        mutex_unlock(&dupreq_lock);
        return (0);
    }
    MEMZERO(uc->uc_fifo, cache_ptr, size);
    su->su_cache = (char *)(void *)uc;
    mutex_unlock(&dupreq_lock);
    return (1);
}

svc_exit()

void svc_exit

(

void

)

Definition at line 84 of file svc_run.c.

{
    extern rwlock_t svc_fd_lock;
 
    rwlock_wrlock(&svc_fd_lock);
    FD_ZERO(&svc_fdset);
    rwlock_unlock(&svc_fd_lock);
}

svc_fd_create()

SVCXPRT * svc_fd_create	(	const	SOCKET,
		const	u_int,
		const	u_int
	)

Definition at line 204 of file svc_vc.c.

{
    struct sockaddr_storage ss;
    socklen_t slen;
    SVCXPRT *ret;
 
    assert(fd != -1);
 
    ret = makefd_xprt(fd, sendsize, recvsize);
    if (ret == NULL)
        return NULL;
 
    slen = sizeof (struct sockaddr_storage);
    if (getsockname(fd, (struct sockaddr *)(void *)&ss, &slen) == SOCKET_ERROR) {
        // XXX warnx("svc_fd_create: could not retrieve local addr");
        goto freedata;
    }
    if (!__rpc_set_netbuf(&ret->xp_ltaddr, &ss, sizeof(ss))) {
        // XXX warnx("svc_fd_create: no mem for local addr");
        goto freedata;
    }
 
    slen = sizeof (struct sockaddr_storage);
    if (getpeername(fd, (struct sockaddr *)(void *)&ss, &slen) == SOCKET_ERROR) {
        // XXX warnx("svc_fd_create: could not retrieve remote addr");
        goto freedata;
    }
    if (!__rpc_set_netbuf(&ret->xp_rtaddr, &ss, sizeof(ss))) {
        // XXX warnx("svc_fd_create: no mem for local addr");
        goto freedata;
    }
 
    /* Set xp_raddr for compatibility */
    __xprt_set_raddr(ret, &ss);
 
    return ret;
 
freedata:
    if (ret->xp_ltaddr.buf != NULL)
        mem_free(ret->xp_ltaddr.buf, rep->xp_ltaddr.maxlen);
 
    return NULL;
}

Referenced by svc_tli_create().

svc_getreq()

__END_DECLS __BEGIN_DECLS 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_raw_create()

SVCXPRT * svc_raw_create

(

void

)

Definition at line 76 of file svc_raw.c.

{
    struct svc_raw_private *srp;
/* VARIABLES PROTECTED BY svcraw_lock: svc_raw_private, srp */
 
    mutex_lock(&svcraw_lock);
    srp = svc_raw_private;
    if (srp == NULL) {
        srp = (struct svc_raw_private *)calloc(1, sizeof (*srp));
        if (srp == NULL) {
            mutex_unlock(&svcraw_lock);
            return (NULL);
        }
        if (__rpc_rawcombuf == NULL)
            __rpc_rawcombuf = calloc(UDPMSGSIZE, sizeof (char));
        srp->raw_buf = __rpc_rawcombuf; /* Share it with the client */
        svc_raw_private = srp;
    }
    srp->server.xp_fd = FD_SETSIZE;
    srp->server.xp_port = 0;
    srp->server.xp_p3 = NULL;
    svc_raw_ops(&srp->server);
    srp->server.xp_verf.oa_base = srp->verf_body;
    xdrmem_create(&srp->xdr_stream, srp->raw_buf, UDPMSGSIZE, XDR_DECODE);
    xprt_register(&srp->server);
    mutex_unlock(&svcraw_lock);
    return (&srp->server);
}

svc_reg()

__BEGIN_DECLS bool_t svc_reg	(	SVCXPRT *	,
		const	rpcprog_t,
		const	rpcvers_t,
		void(*)(struct svc_req *, SVCXPRT *)	,
		const struct netconfig *
	)

svc_run()

void svc_run

(

void

)

Definition at line 48 of file svc_run.c.

{
    fd_set readfds, cleanfds;
    struct timeval timeout;
    extern rwlock_t svc_fd_lock;
 
 
    for (;;) {
        rwlock_rdlock(&svc_fd_lock);
        readfds = svc_fdset;
        cleanfds = svc_fdset;
        rwlock_unlock(&svc_fd_lock);
        timeout.tv_sec = 30;
        timeout.tv_usec = 0;
        switch (select(svc_maxfd+1, &readfds, NULL, NULL, &timeout)) {
        case SOCKET_ERROR:
            FD_ZERO(&readfds);
            if (WSAGetLastError() == WSAEINTR) {
                continue;
            }
            // XXX warn("svc_run: - select failed");
            return;
        case 0:
            __svc_clean_idle(&cleanfds, 30, FALSE);
            continue;
        default:
            svc_getreqset(&readfds);
        }
    }
}

svc_sendreply()

__END_DECLS __BEGIN_DECLS 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_tli_create()

SVCXPRT * svc_tli_create	(	const	SOCKET,
		const struct netconfig *	nconf,
		const struct t_bind *	bindaddr,
		const	u_int,
		const	u_int
	)

Definition at line 182 of file svc_generic.c.

{
    SVCXPRT *xprt = NULL;       /* service handle */
    bool_t madefd = FALSE;      /* whether fd opened here  */
    struct __rpc_sockinfo si;
    struct sockaddr_storage ss;
    socklen_t slen;
 
    if (fd == RPC_ANYFD) {
        if (nconf == NULL) {
            // XXX warnx("svc_tli_create: invalid netconfig");
            return (NULL);
        }
        fd = __rpc_nconf2fd(nconf);
        if (fd == -1) {
            // XXX warnx(
//              "svc_tli_create: could not open connection for %s",
//                  nconf->nc_netid);
            return (NULL);
        }
        __rpc_nconf2sockinfo(nconf, &si);
        madefd = TRUE;
    } else {
        /*
         * It is an open descriptor. Get the transport info.
         */
        if (!__rpc_fd2sockinfo(fd, &si)) {
            // XXX warnx(
//      "svc_tli_create: could not get transport information");
            return (NULL);
        }
    }
 
    /*
     * If the fd is unbound, try to bind it.
     */
    if (madefd || !__rpc_sockisbound(fd)) {
        if (bindaddr == NULL) {
            if (bindresvport(fd, NULL) < 0) {
                memset(&ss, 0, sizeof ss);
                ss.ss_family = si.si_af;
                if (bind(fd, (struct sockaddr *)(void *)&ss,
                    (socklen_t)si.si_alen) == SOCKET_ERROR) {
                    // XXX warnx(
//          "svc_tli_create: could not bind to anonymous port");
                    goto freedata;
                }
            }
            listen(fd, SOMAXCONN);
        } else {
            if (bind(fd,
                (struct sockaddr *)bindaddr->addr.buf,
                (socklen_t)si.si_alen) == SOCKET_ERROR) {
                // XXX warnx(
//      "svc_tli_create: could not bind to requested address");
                goto freedata;
            }
            listen(fd, (int)bindaddr->qlen);
        }
            
    }
    /*
     * call transport specific function.
     */
    switch (si.si_socktype) {
        case SOCK_STREAM:
            slen = sizeof ss;
            if (getpeername(fd, (struct sockaddr *)(void *)&ss, &slen)
                == 0) {
                /* accepted socket */
                xprt = svc_fd_create(fd, sendsz, recvsz);
            } else
                xprt = svc_vc_create(fd, sendsz, recvsz);
            if (!nconf || !xprt)
                break;
#if 0
            /* XXX fvdl */
            if (strcmp(nconf->nc_protofmly, "inet") == 0 ||
                strcmp(nconf->nc_protofmly, "inet6") == 0)
                (void) __svc_vc_setflag(xprt, TRUE);
#endif
            break;
        case SOCK_DGRAM:
            xprt = svc_dg_create(fd, sendsz, recvsz);
            break;
        default:
            // XXX warnx("svc_tli_create: bad service type");
            goto freedata;
    }
 
    if (xprt == NULL)
        /*
         * The error messages here are spitted out by the lower layers:
         * svc_vc_create(), svc_fd_create() and svc_dg_create().
         */
        goto freedata;
 
    /* Fill in type of service */
    xprt->xp_type = __rpc_socktype2seman(si.si_socktype);
 
    if (nconf) {
        xprt->xp_netid = strdup(nconf->nc_netid);
        xprt->xp_tp = strdup(nconf->nc_device);
    }
    return (xprt);
 
freedata:
    if (madefd)
        (void)closesocket(fd);
    if (xprt) {
        if (!madefd) /* so that svc_destroy doesnt close fd */
            xprt->xp_fd = RPC_ANYFD;
        SVC_DESTROY(xprt);
    }
    return (NULL);
}

Referenced by rpc_reg(), and svc_tp_create().

svc_tp_create()

SVCXPRT * svc_tp_create	(	void(*)(struct svc_req *, SVCXPRT *)	,
		const	rpcprog_t,
		const	rpcvers_t,
		const struct netconfig *
	)

svc_unreg()

__END_DECLS __BEGIN_DECLS void svc_unreg	(	const	rpcprog_t,
		const	rpcvers_t
	)

svc_vc_create()

SVCXPRT * svc_vc_create	(	const	SOCKET,
		const	u_int,
		const	u_int
	)

svcerr_auth()

void svcerr_auth	(	SVCXPRT *	xprt,
		enum	auth_stat
	)

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);
}

svcunix_create()

SVCXPRT * svcunix_create	(	int	,
		u_int	,
		u_int	,
		char *
	)

svcunixfd_create()

SVCXPRT * svcunixfd_create	(	int	,
		u_int	,
		u_int
	)

xprt_register()

__END_DECLS __BEGIN_DECLS 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()

__END_DECLS __BEGIN_DECLS 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_fds

int svc_fds

extern

svc_maxfd

__END_DECLS int svc_maxfd

extern

Definition at line 39 of file rpc_commondata.c.

Referenced by __svc_clean_idle(), __xprt_do_unregister(), svc_run(), and xprt_register().