NAME
rpc_soc,
auth_destroy,
authnone_create,
authunix_create,
authunix_create_default,
callrpc,
clnt_broadcast,
clnt_call,
clnt_control,
clnt_create,
clnt_destroy,
clnt_freeres,
clnt_geterr,
clnt_pcreateerror,
clnt_perrno,
clnt_perror,
clnt_spcreateerror,
clnt_sperrno,
clnt_sperror,
clntraw_create,
clnttcp_create,
clntudp_bufcreate,
clntudp_create,
get_myaddress,
pmap_getmaps,
pmap_getport,
pmap_rmtcall,
pmap_set,
pmap_unset,
registerrpc,
rpc_createerr,
svc_destroy,
svc_fds,
svc_fdset,
svc_getargs,
svc_getcaller,
svc_getreg,
svc_getregset,
svc_getrpccaller,
svc_register,
svc_run,
svc_sendreply,
svc_unregister,
svcerr_auth,
svcerr_decode,
svcerr_noproc,
svcerr_noprog,
svcerr_progvers,
svcerr_systemerr,
svcerr_weakauth,
svcfd_create,
svcraw_create,
xdr_accepted_reply,
xdr_authunix_parms,
xdr_callhdr,
xdr_callmsg,
xdr_opaque_auth,
xdr_pmap,
xdr_pmaplist,
xdr_rejected_reply,
xdr_replymsg,
xprt_register,
xprt_unregister —
library routines
for remote procedure calls
SYNOPSIS
#include <rpc/rpc.h>
void
auth_destroy(
AUTH
*auth);
AUTH *
authnone_create(
void);
AUTH *
authunix_create(
char
*host,
int uid,
int gid,
int len,
int *aup_gids);
AUTH *
authunix_create_default(
void);
int
callrpc(
char
*host,
int prognum,
int versnum,
int procnum,
xdrproc_t inproc,
char *in,
xdrproc_t outproc,
char *out);
enum clnt_stat
clnt_broadcast(
u_long
prognum,
u_long
versnum,
u_long
procnum,
xdrproc_t
inproc,
char *in,
xdrproc_t outproc,
char *out,
resultproc_t eachresult);
enum clnt_stat
clnt_call(
CLIENT
*clnt,
u_long
procnum,
xdrproc_t
inproc,
char *in,
xdrproc_t outproc,
char *out,
struct timeval tout);
int
clnt_destroy(
CLIENT
*clnt);
CLIENT *
clnt_create(
const
char *host,
rpcprog_t
prog,
rpcvers_t vers,
const char *proto);
bool_t
clnt_control(
CLIENT
*cl,
u_int req,
char *info);
int
clnt_freeres(
CLIENT
*clnt,
xdrproc_t
outproc,
char *out);
void
clnt_geterr(
CLIENT
*clnt,
struct rpc_err
errp);
void
clnt_pcreateerror(
const
char *s);
void
clnt_perrno(
enum
clnt_stat stat);
void
clnt_perror(
CLIENT
*clnt,
const char
*s);
char *
clnt_spcreateerror(
const
char *s);
char *
clnt_sperrno(
enum
clnt_stat stat);
char *
clnt_sperror(
CLIENT
*rpch,
const char
*s);
CLIENT *
clntraw_create(
u_long
prognum,
u_long
versnum);
CLIENT *
clnttcp_create(
struct
sockaddr_in *addr,
u_long
prognum,
u_long
versnum,
int *sockp,
u_int sendsz,
u_int recvsz);
CLIENT *
clntudp_create(
struct
sockaddr_in *addr,
u_long
prognum,
u_long
versnum,
struct timeval
wait,
int *sockp);
CLIENT *
clntudp_bufcreate(
struct
sockaddr_in *addr,
u_long
prognum,
u_long
versnum,
struct timeval
wait,
int *sockp,
unsigned int sendsize,
unsigned int recosize);
int
get_myaddress(
struct
sockaddr_in *addr);
struct pmaplist *
pmap_getmaps(
struct
sockaddr_in *addr);
u_short
pmap_getport(
struct
sockaddr_in *addr,
u_long
prognum,
u_long
versnum,
u_int
protocol);
enum clnt_stat
pmap_rmtcall(
struct sockaddr_in *addr,
u_long prognum,
u_long versnum,
u_long procnum,
xdrproc_t inproc,
char *in,
xdrproc_t outproc,
char *out,
struct timeval tout,
u_long *portp);
int
pmap_set(
u_long
prognum,
u_long
versnum,
int
protocol,
int port);
int
pmap_unset(
u_long
prognum,
u_long
versnum);
int
registerrpc(
int
prognum,
int versnum,
int procnum,
char *(*procname)(),
xdrproc_t inproc,
xdrproc_t outproc);
struct rpc_createerr rpc_createerr;
int
svc_destroy(
SVCXPRT
*xprt);
fd_set svc_fdset;
int svc_fds;
int
svc_freeargs(
SVCXPRT
*xprt,
xdrproc_t
inproc,
char *in);
int
svc_getargs(
SVCXPRT
*xprt,
xdrproc_t
inproc,
char *in);
struct sockaddr_in *
svc_getcaller(
SVCXPRT
*xprt);
void
svc_getreqset(
fd_set
*rdfds);
void
svc_getreq(
int
rdfds);
struct netbuf *
svc_getrpccaller(
SVCXPRT
*xprt);
bool_t
svc_register(
SVCXPRT
*xprt,
u_long
prognum,
u_long
versnum,
void
(*dispatch)(),
int
protocol);
void
svc_run(
void);
bool_t
svc_sendreply(
SVCXPRT
*xprt,
xdrproc_t
xdr_results,
const char
*location);
void
svc_unregister(
u_long
prognum,
u_long
versnum);
void
svcerr_auth(
SVCXPRT
*xprt,
enum auth_stat
why);
void
svcerr_decode(
SVCXPRT
*xprt);
void
svcerr_noproc(
SVCXPRT
*xprt);
void
svcerr_noprog(
SVCXPRT
*xprt);
void
svcerr_progvers(
SVCXPRT
*xprt,
rpcvers_t
low_vers,
rpcvers_t
high_vers);
void
svcerr_systemerr(
SVCXPRT
*xprt);
void
svcerr_weakauth(
SVCXPRT
*xprt);
SVCXPRT *
svcraw_create(
void);
SVCXPRT *
svctcp_create(
int
sock,
u_int
send_buf_size,
u_int
recv_buf_size);
SVCXPRT *
svcfd_create(
int
fd,
u_int sendsize,
u_int recvsize);
SVCXPRT *
svcudp_bufcreate(
int
sock,
u_int sendsize,
u_int recosize);
SVCXPRT *
svcudp_create(
int
sock);
int
xdr_accepted_reply(
XDR
*xdrs,
struct
accepted_reply *ar);
int
xdr_authunix_parms(
XDR
*xdrs,
struct
authunix_parms *aupp);
bool_t
xdr_callhdr(
XDR
*xdrs,
struct rpc_msg
*chdr);
int
xdr_callmsg(
XDR
*xdrs,
struct rpc_msg
*cmsg);
int
xdr_opaque_auth(
XDR
*xdrs,
struct opaque_auth
*ap);
int
xdr_pmap(
XDR
*xdrs,
struct pmap
*regs);
int
xdr_pmaplist(
XDR
*xdrs,
struct pmaplist
**rp);
int
xdr_rejected_reply(
XDR
*xdrs,
struct
rejected_reply *rr);
int
xdr_replymsg(
XDR
*xdrs,
struct rpc_msg
*rmsg);
bool_t
xprt_register(
SVCXPRT
*xprt);
void
xprt_unregister(
SVCXPRT
*xprt);
DESCRIPTION
The svc and clnt functions described in this page are the old,
TS-RPC interface to the XDR and RPC library, and exist for
backward compatibility. The new interface is described in
the pages referenced from
rpc(3).
These routines allow C programs to make procedure calls on other machines across
the network. First, the client calls a procedure to send a data packet to the
server. Upon receipt of the packet, the server calls a dispatch routine to
perform the requested service, and then sends back a reply. Finally, the
procedure call returns to the client.
-
-
- auth_destroy()
- A macro that destroys the authentication information
associated with auth. Destruction usually involves
deallocation of private data structures. The use of
auth is undefined after calling
auth_destroy().
-
-
- authnone_create()
- Create and returns an RPC authentication handle that passes
nonusable authentication information with each remote procedure call. This
is the default authentication used by RPC.
-
-
- authunix_create()
- Create and return an RPC authentication handle that
contains authentication information. The parameter
host is the name of the machine on which the
information was created; uid is the user's user ID;
gid is the user's current group id;
len and aup_gids refer to a
counted array of groups to which the user belongs. It is easy to
impersonate a user.
-
-
- authunix_create_default()
- Calls authunix_create() with the
appropriate parameters.
-
-
- callrpc()
- Call the remote procedure associated with
prognum, versnum, and
procnum on the machine, host.
The parameter in is the address of the procedure's
argument(s), and out is the address of where to
place the result(s); inproc is used to encode the
procedure's parameters, and outproc is used to
decode the procedure's results. This routine returns zero if it succeeds,
or the value of enum clnt_stat cast to an integer if
it fails. The routine clnt_perrno() is handy for
translating failure statuses into messages.
Warning: calling remote procedures with this routine uses UDP/IP as a
transport; see clntudp_create() for restrictions. You do
not have control of timeouts or authentication using this routine.
-
-
- clnt_broadcast()
- Like callrpc(), except the call message
is broadcast to all locally connected broadcast nets. Each time it
receives a response, this routine calls eachresult(),
whose form is int
eachresult(char *out,
struct sockaddr_in *addr) where
out is the same as out passed
to clnt_broadcast(), except that the remote procedure's
output is decoded there; addr points to the address
of the machine that sent the results. If eachresult()
returns zero, clnt_broadcast() waits for more replies;
otherwise it returns with appropriate status.
Warning: broadcast sockets are limited in size to the maximum transfer unit
of the data link. For ethernet, this value is 1500 bytes.
-
-
- clnt_call()
- A macro that calls the remote procedure
procnum associated with the client handle,
clnt, which is obtained with an RPC client creation
routine such as clnt_create(). The parameter
in is the address of the procedure's argument(s),
and out is the address of where to place the
result(s); inproc is used to encode the procedure's
parameters, and outproc is used to decode the
procedure's results; tout is the time allowed for
results to come back.
-
-
- clnt_destroy()
- A macro that destroys the client's RPC handle. Destruction
usually involves deallocation of private data structures, including
clnt itself. Use of clnt is
undefined after calling clnt_destroy(). If the RPC
library opened the associated socket, it will close it also. Otherwise,
the socket remains open.
-
-
- clnt_create()
- Generic client creation routine. host
identifies the name of the remote host where the server is located.
proto indicates which kind of transport protocol to
use. The currently supported values for this field are “udp”
and “tcp”. Default timeouts are set, but can be modified using
clnt_control().
Warning: Using UDP has its shortcomings. Since UDP-based
RPC messages can only hold up to 8 Kbytes of encoded data, this transport
cannot be used for procedures that take large arguments or return huge
results.
-
-
- clnt_control()
- A macro used to change or retrieve various information
about a client object. req indicates the type of
operation, and info is a pointer to the information.
For both UDP and TCP the supported values of req and
their argument types and what they do are:
-
-
- CLSET_TIMEOUT
- struct timeval; set total
timeout.
-
-
- CLGET_TIMEOUT
- struct timeval; get total
timeout.
Note: if you set the timeout using clnt_control(), the
timeout parameter passed to clnt_call() will be
ignored in all future calls.
-
-
- CLGET_SERVER_ADDR
- struct sockaddr_in; get server's
address.
The following operations are valid for UDP only:
-
-
- CLSET_RETRY_TIMEOUT
- struct timeval; set the retry
timeout.
-
-
- CLGET_RETRY_TIMEOUT
- struct timeval; get the retry
timeout.
The retry timeout is the time that UDP RPC waits for the server to reply
before retransmitting the request.
-
-
- clnt_freeres()
- A macro that frees any data allocated by the RPC/XDR system
when it decoded the results of an RPC call. The parameter
out is the address of the results, and
outproc is the XDR routine describing the results.
This routine returns one if the results were successfully freed, and zero
otherwise.
-
-
- clnt_geterr()
- A macro that copies the error structure out of the client
handle to the structure at address errp.
-
-
- clnt_pcreateerror()
- Print a message to standard error indicating why a client
RPC handle could not be created. The message is prepended with string
s and a colon. A newline character is appended at
the end of the message. Used when a clnt_create(),
clntraw_create(), clnttcp_create(), or
clntudp_create() call fails.
-
-
- clnt_perrno()
- Print a message to standard error corresponding to the
condition indicated by stat. A newline character is
appended at the end of the message. Used after
callrpc().
-
-
- clnt_perror()
- Print a message to standard error indicating why an RPC
call failed; clnt is the handle used to do the call.
The message is prepended with string s and a colon.
A newline character is appended at the end of the message. Used after
clnt_call().
-
-
- clnt_spcreateerror()
- Like clnt_pcreateerror(), except that it
returns a string instead of printing to the standard error.
Bugs: returns pointer to static data that is overwritten on each call.
-
-
- clnt_sperrno()
- Take the same arguments as clnt_perrno(),
but instead of sending a message to the standard error indicating why an
RPC call failed, return a pointer to a string which contains the message.
clnt_sperrno() is used instead of
clnt_perrno() if the program does not have a standard
error (as a program running as a server quite likely does not), or if the
programmer does not want the message to be output with
printf(3), or if a message
format different than that supported by clnt_perrno() is
to be used. Note: unlike clnt_sperror() and
clnt_spcreateerror(), clnt_sperrno()
returns a pointer to static data, but the result will not get overwritten
on each call.
-
-
- clnt_sperror()
- Like clnt_perror(), except that (like
clnt_sperrno()) it returns a string instead of printing
to standard error.
Bugs: returns pointer to static data that is overwritten on each call.
-
-
- clntraw_create()
- This routine creates a toy RPC client for the remote
program prognum, version
versnum. The transport used to pass messages to the
service is actually a buffer within the process's address space, so the
corresponding RPC server should live in the same address space; see
svcraw_create(). This allows simulation of RPC and
acquisition of RPC overheads, such as round trip times, without any kernel
interference. This routine returns
NULL
if it
fails.
-
-
- clnttcp_create()
- This routine creates an RPC client for the remote program
prognum, version versnum; the
client uses TCP/IP as a transport. The remote program is located at
Internet address *addr. If
addr->sin_port is zero, then it is set to the
actual port that the remote program is listening on (the remote
rpcbind(8) or
portmap service is consulted for this information). The
parameter sockp is a socket; if it is
RPC_ANYSOCK
, then this routine opens a new one and
sets sockp. Since TCP-based RPC uses buffered I/O ,
the user may specify the size of the send and receive buffers with the
parameters sendsz and recvsz;
values of zero choose suitable defaults. This routine returns
NULL
if it fails.
-
-
- clntudp_create()
- This routine creates an RPC client for the remote program
prognum, version versnum; the
client uses UDP/IP as a transport. The remote program is located at
Internet address addr. If
addr->sin_port is zero, then it is set to actual
port that the remote program is listening on (the remote
rpcbind(8) or
portmap service is consulted for this information). The
parameter sockp is a socket; if it is
RPC_ANYSOCK
, then this routine opens a new one and
sets sockp. The UDP transport resends the call
message in intervals of wait time until a response
is received or until the call times out. The total time for the call to
time out is specified by clnt_call.
Warning: since UDP-based RPC messages can only hold up to 8 Kbytes of
encoded data, this transport cannot be used for procedures that take large
arguments or return huge results.
-
-
- clntudp_bufcreate()
- This routine creates an RPC client for the remote program
prognum, on versnum; the
client uses UDP/IP as a transport. The remote program is located at
Internet address addr. If
addr->sin_port is zero, then it is set to actual
port that the remote program is listening on (the remote
rpcbind(8) or
portmap service is consulted for this information). The
parameter sockp is a socket; if it is
RPC_ANYSOCK
, then this routine opens a new one and
sets sockp. The UDP transport resends the call
message in intervals of wait time until a response
is received or until the call times out. The total time for the call to
time out is specified by clnt_call.
This allows the user to specify the maximum packet size for sending and
receiving UDP-based RPC messages.
-
-
- get_myaddress()
- Stuff the machine's IP address into
*addr, without consulting the library routines that
deal with /etc/hosts. The port number is always set to
htons(PMAPPORT). Returns zero on
success, non-zero on failure.
-
-
- pmap_getmaps()
- A user interface to the
rpcbind(8) service, which
returns a list of the current RPC program-to-port mappings on the host
located at IP address *addr. This routine can return
NULL
. The command
rpcinfo
-p
uses this routine.
-
-
- pmap_getport()
- A user interface to the
rpcbind(8) service, which
returns the port number on which waits a service that supports program
number prognum, version
versnum, and speaks the transport protocol
associated with protocol. The value of
protocol is most likely
IPPROTO_UDP
or
IPPROTO_TCP
. A return value of zero means that the
mapping does not exist or that the RPC system failured to contact the
remote rpcbind(8) service.
In the latter case, the global variable rpc_createerr()
contains the RPC status.
-
-
- pmap_rmtcall()
- A user interface to the
rpcbind(8) service, which
instructs rpcbind(8) on the
host at IP address *addr to make an RPC call on your
behalf to a procedure on that host. The parameter
*portp will be modified to the program's port number
if the procedure succeeds. The definitions of other parameters are
discussed in callrpc() and
clnt_call(). This procedure should be used for a
“ping” and nothing else. See also
clnt_broadcast().
-
-
- pmap_set()
- A user interface to the
rpcbind(8) service, which
establishes a mapping between the triple [prognum,
versnum, protocol] and
port on the machine's
rpcbind(8) service. The
value of protocol is most likely
IPPROTO_UDP
or
IPPROTO_TCP
. This routine returns one if it
succeeds, zero otherwise. Automatically done by
svc_register().
-
-
- pmap_unset()
- A user interface to the
rpcbind(8) service, which
destroys all mapping between the triple [prognum,
versnum, *] and
ports on the machine's
rpcbind(8) service. This
routine returns one if it succeeds, zero otherwise.
-
-
- registerrpc()
- Register procedure procname with the
RPC service package. If a request arrives for program
prognum, version versnum, and
procedure procnum, procname is
called with a pointer to its parameter(s); progname
should return a pointer to its static result(s);
inproc is used to decode the parameters while
outproc is used to encode the results. This routine
returns zero if the registration succeeded, -1 otherwise.
Warning: remote procedures registered in this form are accessed using the
UDP/IP transport; see svcudp_bufcreate() for
restrictions.
-
-
- struct rpc_createerr
rpc_createerr;
- A global variable whose value is set by any RPC client
creation routine that does not succeed. Use the routine
clnt_pcreateerror() to print the reason why.
-
-
- svc_destroy()
- A macro that destroys the RPC service transport handle,
xprt. Destruction usually involves deallocation of
private data structures, including xprt itself. Use
of xprt is undefined after calling this
routine.
-
-
- fd_set svc_fdset;
- A global variable reflecting the RPC service side's read
file descriptor bit mask; it is suitable as a parameter to the
select(2) system call. This
is only of interest if a service implementor does not call
svc_run(), but rather does his own asynchronous event
processing. This variable is read-only (do not pass its address to
select(2)!), yet it may
change after calls to svc_getreqset() or any creation
routines.
-
-
- int svc_fds;
- Similar to svc_fedset(), but limited to
32 descriptors. This interface is obsoleted by
svc_fdset().
-
-
- svc_freeargs()
- A macro that frees any data allocated by the RPC/XDR system
when it decoded the arguments to a service procedure using
svc_getargs(). This routine returns 1 if the results
were successfully freed, and zero otherwise.
-
-
- svc_getargs()
- A macro that decodes the arguments of an RPC request
associated with the RPC service transport handle,
xprt. The parameter in is the
address where the arguments will be placed; inproc
is the XDR routine used to decode the arguments. This routine returns one
if decoding succeeds, and zero otherwise.
-
-
- svc_getcaller()
- The obsolete way of getting the network address of the
caller of a procedure associated with the RPC service transport handle,
xprt, use svc_getrpccaller().
-
-
- svc_getreqset()
- This routine is only of interest if a service implementor
does not call svc_run(), but instead implements custom
asynchronous event processing. It is called when the
select(2) system call has
determined that an RPC request has arrived on some RPC socket(s) ;
rdfds is the resultant read file descriptor bit
mask. The routine returns when all sockets associated with the value of
rdfds have been serviced.
-
-
- svc_getreq()
- Similar to svc_getreqset(), but limited
to 32 descriptors. This interface is obsoleted by
svc_getreqset().
-
-
- svc_getrpccaller()
- The approved way of getting the network address of the
caller of a procedure associated with the RPC service transport handle,
xprt.
-
-
- svc_register()
- Associates prognum and
versnum with the service dispatch procedure,
dispatch. If protocol is zero,
the service is not registered with the
rpcbind(8) service. If
protocol is non-zero, then a mapping of the triple
[prognum, versnum,
protocol] to xprt->xp_port
is established with the local
rpcbind(8) service
(generally protocol is zero,
IPPROTO_UDP
or
IPPROTO_TCP
). The procedure
dispatch has the following form:
int
dispatch(struct svc_req *request,
SVCXPRT *xprt).
The svc_register() routine returns one if it succeeds, and
zero otherwise.
-
-
- svc_run()
- This routine never returns. It waits for RPC requests to
arrive, and calls the appropriate service procedure using
svc_getreq() when one arrives. This procedure is usually
waiting for a select(2)
system call to return.
-
-
- svc_sendreply()
- Called by an RPC service's dispatch routine to send the
results of a remote procedure call. The parameter
xprt is the request's associated transport handle;
xdr_results is the XDR routine which is used to
encode the results; and xdr_location is the address
of the results. This routine returns one if it succeeds, zero
otherwise.
-
-
- svc_unregister()
- Remove all mapping of the double
[prognum, versnum] to dispatch
routines, and of the triple [prognum,
versnum, *] to port
number.
-
-
- svcerr_auth()
- Called by a service dispatch routine that refuses to
perform a remote procedure call due to an authentication error.
-
-
- svcerr_decode()
- Called by a service dispatch routine that cannot
successfully decode its parameters. See also
svc_getargs().
-
-
- svcerr_noproc()
- Called by a service dispatch routine that does not
implement the procedure number that the caller requests.
-
-
- svcerr_noprog()
- Called when the desired program is not registered with the
RPC package. Service implementors usually do not need this routine.
-
-
- svcerr_progvers()
- Called when the desired version of a program is not
registered with the RPC package. Service implementors usually do not need
this routine.
-
-
- svcerr_systemerr()
- Called by a service dispatch routine when it detects a
system error not covered by any particular protocol. For example, if a
service can no longer allocate storage, it may call this routine.
-
-
- svcerr_weakauth()
- Called by a service dispatch routine that refuses to
perform a remote procedure call due to insufficient authentication
parameters. The routine calls
svcerr_auth(xprt,
AUTH_TOOWEAK).
-
-
- svcraw_create()
- This routine creates a toy RPC service transport, to which
it returns a pointer. The transport is really a buffer within the
process's address space, so the corresponding RPC client should live in
the same address space; see clntraw_create(). This
routine allows simulation of RPC and acquisition of RPC overheads (such as
round trip times), without any kernel interference. This routine returns
NULL
if it fails.
-
-
- svctcp_create()
- This routine creates a TCP/IP-based RPC service transport,
to which it returns a pointer. The transport is associated with the socket
sock, which may be
RPC_ANYSOCK
, in which case a new socket is
created. If the socket is not bound to a local TCP port, then this routine
binds it to an arbitrary port. Upon completion,
xprt->xp_sock is the transport's socket
descriptor, and xprt->xp_port is the transport's
port number. This routine returns NULL
if it
fails. Since TCP-based RPC uses buffered I/O , users may specify the size
of buffers; values of zero choose suitable defaults.
-
-
- svcfd_create()
- Create a service on top of any open descriptor. Typically,
this descriptor is a connected socket for a stream protocol such as TCP.
sendsize and recvsize indicate
sizes for the send and receive buffers. If they are zero, a reasonable
default is chosen.
-
-
- svcudp_bufcreate()
- This routine creates a UDP/IP-based RPC service transport,
to which it returns a pointer. The transport is associated with the socket
sock, which may be
RPC_ANYSOCK
, in which case a new socket is
created. If the socket is not bound to a local UDP port, then this routine
binds it to an arbitrary port. Upon completion,
xprt->xp_sock is the transport's socket
descriptor, and xprt->xp_port is the transport's
port number. This routine returns NULL
if it
fails.
This allows the user to specify the maximum packet size for sending and
receiving UDP-based RPC messages.
-
-
- svcudp_create()
- This acts as svcudp_bufcreate() with
predefined sizes for the maximum packet sizes.
-
-
- xdr_accepted_reply()
- Used for encoding RPC reply messages. This routine is
useful for users who wish to generate RPC-style messages without using the
RPC package.
-
-
- xdr_authunix_parms()
- Used for describing UNIX credentials. This routine is
useful for users who wish to generate these credentials without using the
RPC authentication package.
-
-
- xdr_callhdr()
- Used for describing RPC call header messages. This routine
is useful for users who wish to generate RPC-style messages without using
the RPC package.
-
-
- xdr_callmsg()
- Used for describing RPC call messages. This routine is
useful for users who wish to generate RPC-style messages without using the
RPC package.
-
-
- xdr_opaque_auth()
- Used for describing RPC authentication information
messages. This routine is useful for users who wish to generate RPC-style
messages without using the RPC package.
-
-
- xdr_pmap()
- Used for describing parameters to various
rpcbind(8) procedures,
externally. This routine is useful for users who wish to generate these
parameters without using the pmap interface.
-
-
- xdr_pmaplist()
- Used for describing a list of port mappings, externally.
This routine is useful for users who wish to generate these parameters
without using the pmap interface.
-
-
- xdr_rejected_reply()
- Used for describing RPC reply messages. This routine is
useful for users who wish to generate RPC-style messages without using the
RPC package.
-
-
- xdr_replymsg()
- Used for describing RPC reply messages. This routine is
useful for users who wish to generate RPC-style messages without using the
RPC package.
-
-
- xprt_register()
- After RPC service transport handles are created, they
should register themselves with the RPC service package. This routine
modifies the global variable svc_fds. Service
implementors usually do not need this routine.
-
-
- xprt_unregister()
- Before an RPC service transport handle is destroyed, it
should unregister itself with the RPC service package. This routine
modifies the global variable svc_fds. Service
implementors usually do not need this routine.
SEE ALSO
xdr(3)
The following manuals:
Remote Procedure Calls: Protocol
Specification.
Remote Procedure Call Programming
Guide.
rpcgen Programming Guide.
Sun Microsystems, Inc., USC-ISI,
RPC: Remote Procedure Call Protocol Specification,
RFC, 1050.