rpc_com.h File Reference

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

Go to the source code of this file.

Macros
#define	RPC_MAXDATASIZE   9000
#define	RPC_MAXADDRSIZE   1024
#define	__RPC_GETXID(now)

Functions
__BEGIN_DECLS u_int	__rpc_get_a_size (int)
int	__rpc_dtbsize (void)
struct netconfig *	__rpcgettp (SOCKET)
int	__rpc_get_default_domain (char **)
struct netbuf *	__rpc_set_netbuf (struct netbuf *, const void *, size_t)
char *	__rpc_taddr2uaddr_af (int, const struct netbuf *)
struct netbuf *	__rpc_uaddr2taddr_af (int, const char *)
int	__rpc_fixup_addr (struct netbuf *, const struct netbuf *)
int	__rpc_sockinfo2netid (struct __rpc_sockinfo *, const char **)
int	__rpc_seman2socktype (int)
int	__rpc_socktype2seman (int)
void *	rpc_nullproc (CLIENT *)
int	__rpc_sockisbound (SOCKET)
struct netbuf *	__rpcb_findaddr (rpcprog_t, rpcvers_t, const struct netconfig *, const char *, CLIENT **)
struct netbuf *	__rpcb_findaddr_timed (rpcprog_t, rpcvers_t, const struct netconfig *, const char *host, CLIENT **clpp, struct timeval *tp)
bool_t	__rpc_control (int, void *)
char *	_get_next_token (char *, int)
bool_t	__svc_clean_idle (fd_set *, int, bool_t)
bool_t	__xdrrec_setnonblock (XDR *, int)
bool_t	__xdrrec_setblock (XDR *)
bool_t	__xdrrec_getrec (XDR *, enum xprt_stat *, bool_t)
void	__xprt_unregister_unlocked (SVCXPRT *)
void	__xprt_set_raddr (SVCXPRT *, const struct sockaddr_storage *)

Variables
SVCXPRT **	__svc_xports
int	__svc_maxrec

Macro Definition Documentation

__RPC_GETXID

#define __RPC_GETXID

(

now

)

Value:

        ((u_int32_t)getpid() ^ (u_int32_t)(now)->tv_sec ^ \
        (u_int32_t)(now)->tv_usec)

Definition at line 58 of file rpc_com.h.

RPC_MAXADDRSIZE

#define RPC_MAXADDRSIZE   1024

Definition at line 52 of file rpc_com.h.

RPC_MAXDATASIZE

#define RPC_MAXDATASIZE   9000

Definition at line 51 of file rpc_com.h.

Function Documentation

__rpc_control()

bool_t __rpc_control	(	int	request,
		void *	info
	)

Definition at line 108 of file rpcb_clnt.c.

{
    switch (request) {
    case CLCR_GET_RPCB_TIMEOUT:
        *(struct timeval *)info = tottimeout;
        break;
    case CLCR_SET_RPCB_TIMEOUT:
        tottimeout = *(struct timeval *)info;
        break;
    case CLCR_SET_LOWVERS:
        __rpc_lowvers = *(int *)info;
        break;
    case CLCR_GET_LOWVERS:
        *(int *)info = __rpc_lowvers;
        break;
    default:
        return (FALSE);
    }
    return (TRUE);
}

__rpc_dtbsize()

int __rpc_dtbsize

(

void

)

Definition at line 110 of file rpc_generic.c.

{
#ifdef _WIN32
    return (WINSOCK_HANDLE_HASH_SIZE);
#else
 
    static int tbsize;
    struct rlimit rl;
 
    if (tbsize) {
        return (tbsize);
    }
    if (getrlimit(RLIMIT_NOFILE, &rl) == 0) {
        return (tbsize = (int)rl.rlim_max);
    }
    /*
     * Something wrong.  I'll try to save face by returning a
     * pessimistic number.
     */
    return (32);
#endif
}

Referenced by clnt_dg_create(), and clnt_vc_create().

__rpc_fixup_addr()

int __rpc_fixup_addr	(	struct netbuf *	new,
		const struct netbuf *	svc
	)

Definition at line 883 of file rpc_generic.c.

{
#ifdef INET6
    struct sockaddr *sa_new, *sa_svc;
    struct sockaddr_in6 *sin6_new, *sin6_svc;
 
    sa_svc = (struct sockaddr *)svc->buf;
    sa_new = (struct sockaddr *)new->buf;
 
    if (sa_new->sa_family == sa_svc->sa_family &&
        sa_new->sa_family == AF_INET6) {
        sin6_new = (struct sockaddr_in6 *)new->buf;
        sin6_svc = (struct sockaddr_in6 *)svc->buf;
 
        if ((IN6_IS_ADDR_LINKLOCAL(&sin6_new->sin6_addr) &&
             IN6_IS_ADDR_LINKLOCAL(&sin6_svc->sin6_addr)) ||
            (IN6_IS_ADDR_SITELOCAL(&sin6_new->sin6_addr) &&
             IN6_IS_ADDR_SITELOCAL(&sin6_svc->sin6_addr))) {
            sin6_new->sin6_scope_id = sin6_svc->sin6_scope_id;
        }
    }
#endif
    return 1;
}

Referenced by __rpcb_findaddr_timed().

__rpc_get_a_size()

__BEGIN_DECLS u_int __rpc_get_a_size

(

int

af

)

Definition at line 172 of file rpc_generic.c.

{
    switch (af) {
    case AF_INET:
        return sizeof (struct sockaddr_in);
#ifdef INET6
    case AF_INET6:
        return sizeof (struct sockaddr_in6);
#endif
#ifdef AF_LOCAL
    case AF_LOCAL:
        return sizeof (struct sockaddr_un);
#endif
    default:
        break;
    }
    return ((u_int)RPC_MAXADDRSIZE);
}

Referenced by rpc_broadcast_exp().

__rpc_get_default_domain()

int __rpc_get_default_domain

(

char **

domain

)

Definition at line 72 of file rpcdname.c.

{
    if ((*domain = get_default_domain()) != 0)
        return (0);
    return (-1);
}

Referenced by host2netname(), netname2host(), netname2user(), and user2netname().

__rpc_seman2socktype()

int __rpc_seman2socktype

(

int

semantics

)

Definition at line 842 of file rpc_generic.c.

{
    switch (semantics) {
    case NC_TPI_CLTS:
        return SOCK_DGRAM;
    case NC_TPI_COTS_ORD:
        return SOCK_STREAM;
    case NC_TPI_RAW:
        return SOCK_RAW;
    default:
        break;
    }
 
    return -1;
}

__rpc_set_netbuf()

struct netbuf * __rpc_set_netbuf	(	struct netbuf *	nb,
		const void *	ptr,
		size_t	len
	)

Definition at line 951 of file rpc_generic.c.

{
    if (nb->len != len) {
        if (nb->len)
            mem_free(nb->buf, nb->len);
        nb->buf = mem_alloc(len);
        if (nb->buf == NULL)
            return NULL;
 
        nb->maxlen = nb->len = len;
    }
    memcpy(nb->buf, ptr, len);
    return nb;
}

Referenced by rendezvous_request(), svc_dg_create(), svc_dg_recv(), svc_fd_create(), and svc_vc_create().

__rpc_sockinfo2netid()

int __rpc_sockinfo2netid	(	struct __rpc_sockinfo *	sip,
		const char **	netid
	)

Definition at line 580 of file rpc_generic.c.

{
    int i;
    struct netconfig *nconf;
 
    nconf = getnetconfigent("local");
 
    for (i = 0; i < (sizeof na_cvt) / (sizeof (struct netid_af)); i++) {
        if (na_cvt[i].af == sip->si_af &&
            na_cvt[i].protocol == sip->si_proto) {
            if (strcmp(na_cvt[i].netid, "local") == 0 && nconf == NULL) {
                if (netid)
                    *netid = "unix";
            } else {
                if (netid)
                    *netid = na_cvt[i].netid;
            }
            if (nconf != NULL)
                freenetconfigent(nconf);
            return 1;
        }
    }
    if (nconf != NULL)
        freenetconfigent(nconf);
 
    return 0;
}

Referenced by makefd_xprt().

__rpc_sockisbound()

int __rpc_sockisbound

(

SOCKET

fd

)

Definition at line 909 of file rpc_generic.c.

{
    struct sockaddr_storage ss;
    union {
        struct sockaddr_in  sin;
        struct sockaddr_in6 sin6;
#ifdef AF_LOCAL
        struct sockaddr_un  usin;
#endif
    } u_addr;
    socklen_t slen;
 
    slen = sizeof (struct sockaddr_storage);
    if (getsockname(fd, (struct sockaddr *)(void *)&ss, &slen) == SOCKET_ERROR)
        return 0;
 
    switch (ss.ss_family) {
        case AF_INET:
            memcpy(&u_addr.sin, &ss, sizeof(u_addr.sin)); 
            return (u_addr.sin.sin_port != 0);
#ifdef INET6
        case AF_INET6:
            memcpy(&u_addr.sin6, &ss, sizeof(u_addr.sin6)); 
            return (u_addr.sin6.sin6_port != 0);
#endif
#ifdef AF_LOCAL
        case AF_LOCAL:
            /* XXX check this */
            memcpy(&u_addr.usin, &ss, sizeof(u_addr.usin)); 
            return (u_addr.usin.sun_path[0] != 0);
#endif
        default:
            break;
    }
 
    return 0;
}

Referenced by svc_tli_create().

__rpc_socktype2seman()

int __rpc_socktype2seman

(

int

socktype

)

Definition at line 859 of file rpc_generic.c.

{
    switch (socktype) {
    case SOCK_DGRAM:
        return NC_TPI_CLTS;
    case SOCK_STREAM:
        return NC_TPI_COTS_ORD;
    case SOCK_RAW:
        return NC_TPI_RAW;
    default:
        break;
    }
 
    return -1;
}

Referenced by clnt_tli_create(), and svc_tli_create().

__rpc_taddr2uaddr_af()

char * __rpc_taddr2uaddr_af	(	int	af,
		const struct netbuf *	nbuf
	)

Definition at line 663 of file rpc_generic.c.

{
    char *ret;
    struct sockaddr_in *sin;
#ifdef AF_LOCAL
    struct sockaddr_un *sun;
#endif
    char namebuf[INET_ADDRSTRLEN];
#ifdef INET6
    struct sockaddr_in6 *sin6;
    char namebuf6[INET6_ADDRSTRLEN];
#endif
    u_int16_t port;
 
    if (nbuf->len <= 0)
        return NULL;
 
    switch (af) {
    case AF_INET:
#ifdef __REACTOS__ // CVE-2017-8779
        if (nbuf->len < sizeof(*sin)) {
            return NULL;
        }
#endif
        sin = nbuf->buf;
        if (inet_ntop(af, &sin->sin_addr, namebuf, sizeof namebuf)
            == NULL)
            return NULL;
        port = ntohs(sin->sin_port);
        if (asprintf(&ret, "%s.%u.%u", namebuf, ((u_int32_t)port) >> 8,
            port & 0xff) < 0)
            return NULL;
        break;
#ifdef INET6
    case AF_INET6:
#ifdef __REACTOS__ // CVE-2017-8779
        if (nbuf->len < sizeof(*sin6)) {
            return NULL;
        }
#endif
        sin6 = nbuf->buf;
        if (inet_ntop(af, &sin6->sin6_addr, namebuf6, sizeof namebuf6)
            == NULL)
            return NULL;
        port = ntohs(sin6->sin6_port);
        if (asprintf(&ret, "%s.%u.%u", namebuf6, ((u_int32_t)port) >> 8,
            port & 0xff) < 0)
            return NULL;
        break;
#endif
#ifdef AF_LOCAL
    case AF_LOCAL:
        sun = nbuf->buf;
        /*  if (asprintf(&ret, "%.*s", (int)(sun->sun_len -
            offsetof(struct sockaddr_un, sun_path)),
            sun->sun_path) < 0)*/
        if (asprintf(&ret, "%.*s", (int)(sizeof(*sun) -
                         offsetof(struct sockaddr_un, sun_path)),
                 sun->sun_path) < 0)
 
            return (NULL);
        break;
#endif
    default:
        return NULL;
    }
 
    return ret;
}

__rpc_uaddr2taddr_af()

struct netbuf * __rpc_uaddr2taddr_af	(	int	af,
		const char *	uaddr
	)

Definition at line 734 of file rpc_generic.c.

{
    struct netbuf *ret = NULL;
    char *addrstr, *p;
    unsigned short port, portlo, porthi;
    struct sockaddr_in *sin;
#ifdef INET6
    struct sockaddr_in6 *sin6;
#endif
#ifdef AF_LOCAL
    struct sockaddr_un *sun;
#endif
 
    port = 0;
    sin = NULL;
#ifdef __REACTOS__ // CVE-2017-8779
    if (uaddr == NULL)
        return NULL;
#endif
    addrstr = strdup(uaddr);
    if (addrstr == NULL)
        return NULL;
 
    /*
     * AF_LOCAL addresses are expected to be absolute
     * pathnames, anything else will be AF_INET or AF_INET6.
     */
    if (*addrstr != '/') {
        p = strrchr(addrstr, '.');
        if (p == NULL)
            goto out;
        portlo = (unsigned)atoi(p + 1);
        *p = '\0';
 
        p = strrchr(addrstr, '.');
        if (p == NULL)
            goto out;
        porthi = (unsigned)atoi(p + 1);
        *p = '\0';
        port = (porthi << 8) | portlo;
    }
 
    ret = (struct netbuf *)malloc(sizeof *ret);
    if (ret == NULL)
        goto out;
    
    switch (af) {
    case AF_INET:
        sin = (struct sockaddr_in *)malloc(sizeof *sin);
        if (sin == NULL)
            goto out;
        memset(sin, 0, sizeof *sin);
        sin->sin_family = AF_INET;
        sin->sin_port = htons(port);
#ifndef __REACTOS__
        if (inet_pton(AF_INET, addrstr, &sin->sin_addr) <= 0) {
#else
        sin->sin_addr.S_un.S_addr = inet_addr(addrstr);
        if (sin->sin_addr.S_un.S_addr == INADDR_NONE) {
#endif
            free(sin);
            free(ret);
            ret = NULL;
            goto out;
        }
        ret->maxlen = ret->len = sizeof *sin;
        ret->buf = sin;
        break;
#ifdef INET6
    case AF_INET6:
        sin6 = (struct sockaddr_in6 *)malloc(sizeof *sin6);
        if (sin6 == NULL)
            goto out;
        memset(sin6, 0, sizeof *sin6);
        sin6->sin6_family = AF_INET6;
        sin6->sin6_port = htons(port);
        if (inet_pton(AF_INET6, addrstr, &sin6->sin6_addr) <= 0) {
            free(sin6);
            free(ret);
            ret = NULL;
            goto out;
        }
        ret->maxlen = ret->len = sizeof *sin6;
        ret->buf = sin6;
        break;
#endif
#ifdef AF_LOCAL
    case AF_LOCAL:
        sun = (struct sockaddr_un *)malloc(sizeof *sun);
        if (sun == NULL)
            goto out;
        memset(sun, 0, sizeof *sun);
        sun->sun_family = AF_LOCAL;
        strncpy(sun->sun_path, addrstr, sizeof(sun->sun_path) - 1);
        ret->len = SUN_LEN(sun);
        ret->maxlen = sizeof(struct sockaddr_un);
        ret->buf = sun;
        break;
#endif
    default:
        break;
    }
out:
    free(addrstr);
    return ret;
}

__rpcb_findaddr()

struct netbuf * __rpcb_findaddr	(	rpcprog_t	,
		rpcvers_t	,
		const struct netconfig *	,
		const char *	,
		CLIENT **
	)

__rpcb_findaddr_timed()

struct netbuf * __rpcb_findaddr_timed	(	rpcprog_t	program,
		rpcvers_t	version,
		const struct netconfig *	nconf,
		const char *	host,
		CLIENT **	clpp,
		struct timeval *	tp
	)

Definition at line 709 of file rpcb_clnt.c.

{
#ifdef NOTUSED
    static bool_t check_rpcbind = TRUE;
#endif
    CLIENT *client = NULL;
    RPCB parms;
    enum clnt_stat clnt_st;
    char *ua = NULL;
    rpcvers_t vers;
    struct netbuf *address = NULL;
    rpcvers_t start_vers = RPCBVERS4;
    struct netbuf servaddr;
 
    /* parameter checking */
    if (nconf == NULL) {
        rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
        return (NULL);
    }
 
    parms.r_addr = NULL;
 
    /*
     * Use default total timeout if no timeout is specified.
     */
    if (tp == NULL)
        tp = &tottimeout;
    
#ifdef PORTMAP
    /* Try version 2 for TCP or UDP */
    if (strcmp(nconf->nc_protofmly, NC_INET) == 0) {
        u_short port = 0;
        struct netbuf remote;
        rpcvers_t pmapvers = 2;
        struct pmap pmapparms;
 
        /*
         * Try UDP only - there are some portmappers out
         * there that use UDP only.
         */
        if (strcmp(nconf->nc_proto, NC_TCP) == 0) {
            struct netconfig *newnconf;
 
            if ((newnconf = getnetconfigent("udp")) == NULL) {
                rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
                return (NULL);
            }
            client = getclnthandle(host, newnconf, &parms.r_addr);
            freenetconfigent(newnconf);
        } else if (strcmp(nconf->nc_proto, NC_UDP) == 0)
            client = getclnthandle(host, nconf, &parms.r_addr);
        else
            goto try_rpcbind;
        if (client == NULL)
            return (NULL);
 
        /*
         * Set version and retry timeout.
         */
        CLNT_CONTROL(client, CLSET_RETRY_TIMEOUT, (char *)&rpcbrmttime);
        CLNT_CONTROL(client, CLSET_VERS, (char *)&pmapvers);
 
        pmapparms.pm_prog = program;
        pmapparms.pm_vers = version;
        pmapparms.pm_prot = strcmp(nconf->nc_proto, NC_TCP) ?
                    IPPROTO_UDP : IPPROTO_TCP;
        pmapparms.pm_port = 0;  /* not needed */
        clnt_st = CLNT_CALL(client, (rpcproc_t)PMAPPROC_GETPORT,
            (xdrproc_t) xdr_pmap, (caddr_t)(void *)&pmapparms,
            (xdrproc_t) xdr_u_short, (caddr_t)(void *)&port,
            *tp);
        if (clnt_st != RPC_SUCCESS) {
            if ((clnt_st == RPC_PROGVERSMISMATCH) ||
                (clnt_st == RPC_PROGUNAVAIL))
                goto try_rpcbind;
            rpc_createerr.cf_stat = RPC_PMAPFAILURE;
            clnt_geterr(client, &rpc_createerr.cf_error);
            goto error;
        } else if (port == 0) {
            address = NULL;
            rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED;
            goto error;
        }
        port = htons(port);
        CLNT_CONTROL(client, CLGET_SVC_ADDR, (char *)&remote);
        if (((address = (struct netbuf *)
            malloc(sizeof (struct netbuf))) == NULL) ||
            ((address->buf = (char *)
            malloc(remote.len)) == NULL)) {
            rpc_createerr.cf_stat = RPC_SYSTEMERROR;
            clnt_geterr(client, &rpc_createerr.cf_error);
            if (address) {
                free(address);
                address = NULL;
            }
            goto error;
        }
        memcpy(address->buf, remote.buf, remote.len);
        memcpy(&((char *)address->buf)[sizeof (short)],
                (char *)(void *)&port, sizeof (short));
        address->len = address->maxlen = remote.len;
        goto done;
    }
 
try_rpcbind:
#endif              /* PORTMAP */
 
    parms.r_prog = program;
    parms.r_vers = version;
    parms.r_netid = nconf->nc_netid;
 
    /*
     * rpcbind ignores the r_owner field in GETADDR requests, but we
     * need to give xdr_rpcb something to gnaw on. Might as well make
     * it something human readable for when we see these in captures.
     */
    parms.r_owner = RPCB_OWNER_STRING;
 
    /* Now the same transport is to be used to get the address */
    if (client && ((nconf->nc_semantics == NC_TPI_COTS_ORD) ||
            (nconf->nc_semantics == NC_TPI_COTS))) {
        /* A CLTS type of client - destroy it */
        CLNT_DESTROY(client);
        client = NULL;
        free(parms.r_addr);
        parms.r_addr = NULL;
    }
 
    if (client == NULL) {
        client = getclnthandle(host, nconf, &parms.r_addr);
        if (client == NULL) {
            goto error;
        }
    }
    if (parms.r_addr == NULL) {
        /*LINTED const castaway*/
        parms.r_addr = (char *) &nullstring[0];
    }
 
    /* First try from start_vers(4) and then version 3 (RPCBVERS) */
 
    CLNT_CONTROL(client, CLSET_RETRY_TIMEOUT, (char *) &rpcbrmttime);
    for (vers = start_vers;  vers >= RPCBVERS; vers--) {
        /* Set the version */
        CLNT_CONTROL(client, CLSET_VERS, (char *)(void *)&vers);
        clnt_st = CLNT_CALL(client, (rpcproc_t)RPCBPROC_GETADDR,
            (xdrproc_t) xdr_rpcb, (char *)(void *)&parms,
            (xdrproc_t) xdr_wrapstring, (char *)(void *) &ua, *tp);
        if (clnt_st == RPC_SUCCESS) {
            if ((ua == NULL) || (ua[0] == 0)) {
                /* address unknown */
                rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED;
                goto error;
            }
            address = uaddr2taddr(nconf, ua);
#ifdef ND_DEBUG
            fprintf(stderr, "\tRemote address is [%s]\n", ua);
            if (!address)
                fprintf(stderr,
                    "\tCouldn't resolve remote address!\n");
#endif
            xdr_free((xdrproc_t)xdr_wrapstring,
                (char *)(void *)&ua);
 
            if (! address) {
                /* We don't know about your universal address */
                rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
                goto error;
            }
            CLNT_CONTROL(client, CLGET_SVC_ADDR,
                (char *)(void *)&servaddr);
            __rpc_fixup_addr(address, &servaddr);
            goto done;
        } else if (clnt_st == RPC_PROGVERSMISMATCH) {
            struct rpc_err rpcerr;
            clnt_geterr(client, &rpcerr);
            if (rpcerr.re_vers.low > RPCBVERS4)
                goto error;  /* a new version, can't handle */
        } else if (clnt_st != RPC_PROGUNAVAIL) {
            /* Cant handle this error */
            rpc_createerr.cf_stat = clnt_st;
            clnt_geterr(client, &rpc_createerr.cf_error);
            goto error;
        }
    }
 
    if ((address == NULL) || (address->len == 0)) {
      rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED;
      clnt_geterr(client, &rpc_createerr.cf_error);
    }
 
error:
    if (client) {
        CLNT_DESTROY(client);
        client = NULL;
    }
done:
    if (nconf->nc_semantics != NC_TPI_CLTS) {
        /* This client is the connectionless one */
        if (client) {
            CLNT_DESTROY(client);
            client = NULL;
        }
    }
    if (clpp) {
        *clpp = client;
    } else if (client) {
        CLNT_DESTROY(client);
    }
    if (parms.r_addr != NULL && parms.r_addr != nullstring)
        free(parms.r_addr);
    return (address);
}

Referenced by clnt_tp_create_timed(), and rpcb_getaddr().

__rpcgettp()

struct netconfig * __rpcgettp

(

SOCKET

fd

)

Definition at line 464 of file rpc_generic.c.

{
    const char *netid;
    struct __rpc_sockinfo si;
 
    if (!__rpc_fd2sockinfo(fd, &si))
        return NULL;
 
    if (!__rpc_sockinfo2netid(&si, &netid))
        return NULL;
 
    /*LINTED const castaway*/
    return getnetconfigent((char *)netid);
}

Referenced by svc_reg().

__svc_clean_idle()

bool_t __svc_clean_idle	(	fd_set *	fds,
		int	timeout,
		bool_t	cleanblock
	)

Definition at line 820 of file svc_vc.c.

{
    int i, ncleaned;
    SVCXPRT *xprt, *least_active;
    struct timeval tv, tdiff, tmax;
    struct cf_conn *cd;
 
    gettimeofday(&tv, NULL);
    tmax.tv_sec = tmax.tv_usec = 0;
    least_active = NULL;
    rwlock_wrlock(&svc_fd_lock);
    for (i = ncleaned = 0; i <= svc_maxfd; i++) {
        if (FD_ISSET(i, fds)) {
            xprt = __svc_xports[i];
            if (xprt == NULL || xprt->xp_ops == NULL ||
                xprt->xp_ops->xp_recv != svc_vc_recv)
                continue;
            cd = (struct cf_conn *)xprt->xp_p1;
            if (!cleanblock && !cd->nonblock)
                continue;
            if (timeout == 0) {
                timersub(&tv, &cd->last_recv_time, &tdiff);
                if (timercmp(&tdiff, &tmax, >)) {
                    tmax = tdiff;
                    least_active = xprt;
                }
                continue;
            }
            if (tv.tv_sec - cd->last_recv_time.tv_sec > timeout) {
                __xprt_unregister_unlocked(xprt);
                __svc_vc_dodestroy(xprt);
                ncleaned++;
            }
        }
    }
    if (timeout == 0 && least_active != NULL) {
        __xprt_unregister_unlocked(least_active);
        __svc_vc_dodestroy(least_active);
        ncleaned++;
    }
    rwlock_unlock(&svc_fd_lock);
    return ncleaned > 0 ? TRUE : FALSE;
}

Referenced by rendezvous_request(), and svc_run().

__xdrrec_getrec()

bool_t __xdrrec_getrec	(	XDR *	xdrs,
		enum xprt_stat *	statp,
		bool_t	expectdata
	)

Definition at line 581 of file xdr_rec.c.

{
    RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
    int n;
    u_int fraglen;
 
    if (!rstrm->in_haveheader) {
        n = rstrm->readit(rstrm->tcp_handle, rstrm->in_hdrp,
            (int)sizeof (rstrm->in_header) - rstrm->in_hdrlen);
        if (n == 0) {
            *statp = expectdata ? XPRT_DIED : XPRT_IDLE;
            return FALSE;
        }
        if (n < 0) {
            *statp = XPRT_DIED;
            return FALSE;
        }
        rstrm->in_hdrp += n;
        rstrm->in_hdrlen += n;
        if (rstrm->in_hdrlen < sizeof (rstrm->in_header)) {
            *statp = XPRT_MOREREQS;
            return FALSE;
        }
        rstrm->in_header = ntohl(rstrm->in_header);
        fraglen = (int)(rstrm->in_header & ~LAST_FRAG);
        if (fraglen == 0 || fraglen > rstrm->in_maxrec ||
            (rstrm->in_reclen + fraglen) > rstrm->in_maxrec) {
            *statp = XPRT_DIED;
            return FALSE;
        }
        rstrm->fbtbc = rstrm->in_header & (~LAST_FRAG);
        rstrm->in_reclen += fraglen;
        if (rstrm->in_reclen > rstrm->recvsize)
            realloc_stream(rstrm, rstrm->in_reclen);
        if (rstrm->in_header & LAST_FRAG) {
            rstrm->in_header &= ~LAST_FRAG;
            rstrm->last_frag = TRUE;
        }
    }
 
    do {
        n =  rstrm->readit(rstrm->tcp_handle,
            rstrm->in_base + rstrm->in_received,
            (rstrm->in_reclen - rstrm->in_received));
 
        /* this case is needed for non-block as socket returns TIMEDOUT and -1
         * -2 is an error case and covered by the next if() statement */
        if (n == -1) continue;
 
        if (n < 0) {
            *statp = XPRT_DIED;
            return FALSE;
        }
 
        if (n == 0) {
            *statp = expectdata ? XPRT_DIED : XPRT_IDLE;
            return FALSE;
        }
 
        rstrm->in_received += n;
        if (rstrm->in_received == rstrm->in_reclen) {
            rstrm->in_haveheader = FALSE;
            rstrm->in_hdrp = (char *)(void *)&rstrm->in_header;
            rstrm->in_hdrlen = 0;
            if (rstrm->last_frag) {
                rstrm->in_boundry = rstrm->in_base + rstrm->in_reclen;
                rstrm->in_finger = rstrm->in_base;
                rstrm->in_reclen = rstrm->in_received = 0;
                *statp = XPRT_MOREREQS;
                return TRUE;
            }
        } 
    } while (1);
 
    *statp = XPRT_MOREREQS;
    return FALSE;
}

Referenced by svc_vc_recv(), and xdrrec_skiprecord().

__xdrrec_setblock()

bool_t __xdrrec_setblock

(

XDR *

xdrs

)

Definition at line 677 of file xdr_rec.c.

{
    RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
 
    rstrm->nonblock = FALSE;
    return TRUE;
}

Referenced by clnt_cb_thread().

__xdrrec_setnonblock()

bool_t __xdrrec_setnonblock	(	XDR *	xdrs,
		int	maxrec
	)

Definition at line 663 of file xdr_rec.c.

{
    RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
 
    rstrm->nonblock = TRUE;
    if (maxrec == 0)
        maxrec = rstrm->recvsize;
    rstrm->in_maxrec = maxrec;
    return TRUE;
}

Referenced by clnt_cb_thread(), and rendezvous_request().

__xprt_set_raddr()

void __xprt_set_raddr	(	SVCXPRT *	xprt,
		const struct sockaddr_storage *	ss
	)

Definition at line 111 of file svc_vc.c.

{
    switch (ss->ss_family) {
    case AF_INET6:
        memcpy(&xprt->xp_raddr, ss, sizeof(struct sockaddr_in6));
        xprt->xp_addrlen = sizeof (struct sockaddr_in6);
        break;
    case AF_INET:
        memcpy(&xprt->xp_raddr, ss, sizeof(struct sockaddr_in));
        xprt->xp_addrlen = sizeof (struct sockaddr_in);
        break;
    default:
        xprt->xp_raddr.sin6_family = AF_UNSPEC;
        xprt->xp_addrlen = sizeof (struct sockaddr);
        break;
    }
}

Referenced by rendezvous_request(), svc_dg_recv(), and svc_fd_create().

__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().

_get_next_token()

char * _get_next_token	(	char *	npp,
		int	token
	)

Definition at line 228 of file getnetpath.c.

{
    char  *cp;      /* char pointer */
    char  *np;      /* netpath pointer */
    char  *ep;      /* escape pointer */
 
    if ((cp = strchr(npp, token)) == NULL) {
    return (NULL);
    }
    /*
     * did find a token, but it might be escaped.
     */
    if ((cp > npp) && (cp[-1] == '\\')) {
        /* if slash was also escaped, carry on, otherwise find next token */
    if ((cp > npp + 1) && (cp[-2] != '\\')) {
        /* shift r-o-s  onto the escaped token */
        strcpy(&cp[-1], cp);    /* XXX: overlapping string copy */
        /*
         * Do a recursive call.
         * We don't know how many escaped tokens there might be.
         */
        return (_get_next_token(cp, token));
    }
    }
 
    *cp++ = '\0';       /* null-terminate token */
    /* get rid of any backslash escapes */
    ep = npp;
    while ((np = strchr(ep, '\\')) != 0) {
    if (np[1] == '\\')
        np++;
    strcpy(np, (ep = &np[1]));  /* XXX: overlapping string copy */
    }
    return (cp);        /* return ptr to r-o-s */
}

rpc_nullproc()

void * rpc_nullproc

(

CLIENT *

clnt

)

Definition at line 447 of file rpc_generic.c.

{
    struct timeval TIMEOUT = {25, 0};
 
    if (clnt_call(clnt, NULLPROC, (xdrproc_t) xdr_void, NULL,
        (xdrproc_t) xdr_void, NULL, TIMEOUT) != RPC_SUCCESS) {
        return (NULL);
    }
    return ((void *) clnt);
}

Variable Documentation

__svc_maxrec

int __svc_maxrec

extern

Definition at line 42 of file rpc_commondata.c.

Referenced by rpc_control(), and svc_vc_create().

__svc_xports

SVCXPRT** __svc_xports

extern

Definition at line 41 of file rpc_commondata.c.

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