pmap_clnt.h File Reference

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

Go to the source code of this file.

Functions
__BEGIN_DECLS bool_t	pmap_set (u_long, u_long, int, int)
bool_t	pmap_unset (u_long, u_long)
struct pmaplist *	pmap_getmaps (struct sockaddr_in *)
enum clnt_stat	pmap_rmtcall (struct sockaddr_in *, u_long, u_long, u_long, xdrproc_t, caddr_t, xdrproc_t, caddr_t, struct timeval, u_long *)
enum clnt_stat	clnt_broadcast (u_long, u_long, u_long, xdrproc_t, void *, xdrproc_t, void *, resultproc_t)
u_short	pmap_getport (struct sockaddr_in *, u_long, u_long, u_int)

Function Documentation

clnt_broadcast()

enum clnt_stat clnt_broadcast	(	u_long	,
		u_long	,
		u_long	,
		xdrproc_t	,
		void *	,
		xdrproc_t	,
		void *	,
		resultproc_t
	)

pmap_getmaps()

struct pmaplist * pmap_getmaps

(

struct sockaddr_in *

address

)

Definition at line 65 of file pmap_getmaps.c.

{
    struct pmaplist *head = NULL;
    SOCKET sock = INVALID_SOCKET;
    struct timeval minutetimeout;
    CLIENT *client;
 
    assert(address != NULL);
 
    minutetimeout.tv_sec = 60;
    minutetimeout.tv_usec = 0;
    address->sin_port = htons(PMAPPORT);
    client = clnttcp_create(address, PMAPPROG,
        PMAPVERS, &sock, 50, 500);
    if (client != NULL) {
        if (CLNT_CALL(client, (rpcproc_t)PMAPPROC_DUMP,
            (xdrproc_t)xdr_void, NULL,
            (xdrproc_t)xdr_pmaplist, &head, minutetimeout) !=
            RPC_SUCCESS) {
            clnt_perror(client, "pmap_getmaps rpc problem");
        }
        CLNT_DESTROY(client);
    }
    address->sin_port = 0;
    return (head);
}

pmap_getport()

u_short pmap_getport	(	struct sockaddr_in *	address,
		u_long	program,
		u_long	version,
		u_int	protocol
	)

Definition at line 74 of file pmap_getport.c.

{
    u_short port = 0;
    int sock = -1;
    CLIENT *client;
    struct pmap parms;
 
    assert(address != NULL);
 
    address->sin_port = htons(PMAPPORT);
    client = clntudp_bufcreate(address, PMAPPROG,
        PMAPVERS, timeout, &sock, RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
    if (client != NULL) {
        parms.pm_prog = program;
        parms.pm_vers = version;
        parms.pm_prot = protocol;
        parms.pm_port = 0;  /* not needed or used */
        if (CLNT_CALL(client, (rpcproc_t)PMAPPROC_GETPORT,
            (xdrproc_t)xdr_pmap,
            &parms, (xdrproc_t)xdr_u_short, &port, tottimeout) !=
            RPC_SUCCESS){
            rpc_createerr.cf_stat = RPC_PMAPFAILURE;
            clnt_geterr(client, &rpc_createerr.cf_error);
        } else if (port == 0) {
            rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED;
        }
        CLNT_DESTROY(client);
    }
    address->sin_port = 0;
    return (port);
}

Referenced by getrpcport().

pmap_rmtcall()

enum clnt_stat pmap_rmtcall	(	struct sockaddr_in *	addr,
		u_long	prog,
		u_long	vers,
		u_long	proc,
		xdrproc_t	xdrargs,
		caddr_t	argsp,
		xdrproc_t	xdrres,
		caddr_t	resp,
		struct timeval	tout,
		u_long *	port_ptr
	)

Definition at line 73 of file pmap_rmt.c.

{
    int sock = -1;
    CLIENT *client;
    struct rmtcallargs a;
    struct rmtcallres r;
    enum clnt_stat stat;
 
    assert(addr != NULL);
    assert(port_ptr != NULL);
 
    addr->sin_port = htons(PMAPPORT);
    client = clntudp_create(addr, PMAPPROG, PMAPVERS, timeout, &sock);
    if (client != NULL) {
        a.prog = prog;
        a.vers = vers;
        a.proc = proc;
        a.args_ptr = argsp;
        a.xdr_args = xdrargs;
        r.port_ptr = port_ptr;
        r.results_ptr = resp;
        r.xdr_results = xdrres;
        stat = CLNT_CALL(client, (rpcproc_t)PMAPPROC_CALLIT,
            (xdrproc_t)xdr_rmtcall_args, &a, (xdrproc_t)xdr_rmtcallres,
            &r, tout);
        CLNT_DESTROY(client);
    } else {
        stat = RPC_FAILED;
    }
    addr->sin_port = 0;
    return (stat);
}

pmap_set()

__BEGIN_DECLS bool_t pmap_set	(	u_long	program,
		u_long	version,
		int	protocol,
		int	port
	)

Definition at line 55 of file pmap_clnt.c.

{
    bool_t rslt;
    struct netbuf *na;
    struct netconfig *nconf;
    char buf[32];
 
    if ((protocol != IPPROTO_UDP) && (protocol != IPPROTO_TCP)) {
        return (FALSE);
    }
    nconf = __rpc_getconfip(protocol == IPPROTO_UDP ? "udp" : "tcp");
    if (nconf == NULL) {
        return (FALSE);
    }
    snprintf(buf, sizeof buf, "0.0.0.0.%d.%d", 
        (((u_int32_t)port) >> 8) & 0xff, port & 0xff);
    na = uaddr2taddr(nconf, buf);
    if (na == NULL) {
        freenetconfigent(nconf);
        return (FALSE);
    }
    rslt = rpcb_set((rpcprog_t)program, (rpcvers_t)version, nconf, na);
    free(na);
    freenetconfigent(nconf);
    return (rslt);
}

pmap_unset()

bool_t pmap_unset	(	u_long	program,
		u_long	version
	)

Definition at line 87 of file pmap_clnt.c.

{
    struct netconfig *nconf;
    bool_t udp_rslt = FALSE;
    bool_t tcp_rslt = FALSE;
 
    nconf = __rpc_getconfip("udp");
    if (nconf != NULL) {
        udp_rslt = rpcb_unset((rpcprog_t)program, (rpcvers_t)version,
            nconf);
        freenetconfigent(nconf);
    }
    nconf = __rpc_getconfip("tcp");
    if (nconf != NULL) {
        tcp_rslt = rpcb_unset((rpcprog_t)program, (rpcvers_t)version,
            nconf);
        freenetconfigent(nconf);
    }
    /*
     * XXX: The call may still succeed even if only one of the
     * calls succeeded.  This was the best that could be
     * done for backward compatibility.
     */
    return (tcp_rslt || udp_rslt);
}