clnt_simple.c File Reference

#include <wintirpc.h>
#include <reentrant.h>
#include <stdio.h>
#include <errno.h>
#include <rpc/rpc.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <rpc/clnt.h>

Include dependency graph for clnt_simple.c:

Go to the source code of this file.

Classes
struct	rpc_call_private

Macros
#define	MAXHOSTNAMELEN   64
#define	NETIDLEN   32

Functions
static void	rpc_call_destroy (void *)
enum clnt_stat	rpc_call (char *host, rpcprog_t prognum, rpcvers_t versnum, rpcproc_t procnum, xdrproc_t inproc, const char *in, xdrproc_t outproc, char *out, const char *nettype) const

Macro Definition Documentation

MAXHOSTNAMELEN

#define MAXHOSTNAMELEN   64

Definition at line 53 of file clnt_simple.c.

NETIDLEN

#define NETIDLEN   32

Definition at line 57 of file clnt_simple.c.

Function Documentation

rpc_call()

enum clnt_stat rpc_call	(	char *	host,
		rpcprog_t	prognum,
		rpcvers_t	versnum,
		rpcproc_t	procnum,
		xdrproc_t	inproc,
		const char *	in,
		xdrproc_t	outproc,
		char *	out,
		const char *	nettype
	)		const

Definition at line 92 of file clnt_simple.c.

{
    struct rpc_call_private *rcp = (struct rpc_call_private *) 0;
    enum clnt_stat clnt_stat;
    struct timeval timeout, tottimeout;
    extern thread_key_t rpc_call_key;
    extern mutex_t tsd_lock;

    if (rpc_call_key == -1) {
        mutex_lock(&tsd_lock);
        if (rpc_call_key == -1)
            thr_keycreate(&rpc_call_key, rpc_call_destroy);
        mutex_unlock(&tsd_lock);
    }
    rcp = (struct rpc_call_private *)thr_getspecific(rpc_call_key);
    if (rcp == NULL) {
        rcp = malloc(sizeof (*rcp));
        if (rcp == NULL) {
            rpc_createerr.cf_stat = RPC_SYSTEMERROR;
            rpc_createerr.cf_error.re_errno = errno;
            return (rpc_createerr.cf_stat);
        }
        thr_setspecific(rpc_call_key, (void *) rcp);
        rcp->valid = 0;
        rcp->client = NULL;
    }
    if ((nettype == NULL) || (nettype[0] == 0))
        nettype = "netpath";
    if (!(rcp->valid && rcp->pid == getpid() &&
        (rcp->prognum == prognum) &&
        (rcp->versnum == versnum) &&
        (!strcmp(rcp->host, host)) &&
        (!strcmp(rcp->nettype, nettype)))) {
        int fd;

        rcp->valid = 0;
        if (rcp->client)
            CLNT_DESTROY(rcp->client);
        /*
         * Using the first successful transport for that type
         */
        rcp->client = clnt_create(host, prognum, versnum, nettype);
        rcp->pid = getpid();
        if (rcp->client == NULL) {
            return (rpc_createerr.cf_stat);
        }
        /*
         * Set time outs for connectionless case.  Do it
         * unconditionally.  Faster than doing a t_getinfo()
         * and then doing the right thing.
         */
        timeout.tv_usec = 0;
        timeout.tv_sec = 5;
        (void) CLNT_CONTROL(rcp->client,
                CLSET_RETRY_TIMEOUT, (char *)(void *)&timeout);
        if (CLNT_CONTROL(rcp->client, CLGET_FD, (char *)(void *)&fd))
            ; // XXX fcntl(fd, F_SETFD, 1); /* make it "close on exec" */
        rcp->prognum = prognum;
        rcp->versnum = versnum;
        if ((strlen(host) < (size_t)MAXHOSTNAMELEN) &&
            (strlen(nettype) < (size_t)NETIDLEN)) {
            (void) strcpy(rcp->host, host);
            (void) strcpy(rcp->nettype, nettype);
            rcp->valid = 1;
        } else {
            rcp->valid = 0;
        }
    } /* else reuse old client */
    tottimeout.tv_sec = 25;
    tottimeout.tv_usec = 0;
    
    /* LINTED const castaway */
    clnt_stat = CLNT_CALL(rcp->client, procnum, inproc, (char *) in,
        outproc, out, tottimeout);
    /*
     * if call failed, empty cache
     */
    if (clnt_stat != RPC_SUCCESS)
        rcp->valid = 0;
    return (clnt_stat);
}

rpc_call_destroy()

static void rpc_call_destroy ( void *  vp )

static

Definition at line 73 of file clnt_simple.c.

{
    struct rpc_call_private *rcp = (struct rpc_call_private *)vp;

    if (rcp) {
        if (rcp->client)
            CLNT_DESTROY(rcp->client);
        free(rcp);
    }
}

Referenced by rpc_call().