RPC_SOC(3) | Library Functions Manual | RPC_SOC(3) |
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
—
#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);
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
()auth_destroy
().authnone_create
()authunix_create
()authunix_create_default
()authunix_create
() with the appropriate
parameters.callrpc
()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
()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
()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
()clnt_destroy
(). If the RPC
library opened the associated socket, it will close it also. Otherwise,
the socket remains open.clnt_create
()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
()Note: if you set the timeout using
clnt_control
(), the timeout parameter passed
to clnt_call
() will be ignored in all future
calls.
The following operations are valid for UDP only:
The retry timeout is the time that UDP RPC waits for the server to reply before retransmitting the request.
clnt_freeres
()clnt_geterr
()clnt_pcreateerror
()clnt_create
(),
clntraw_create
(),
clnttcp_create
(), or
clntudp_create
() call fails.clnt_perrno
()callrpc
().clnt_perror
()clnt_call
().clnt_spcreateerror
()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
()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
()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
()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
()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
()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
()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
()htons
(PMAPPORT). Returns
zero on success, non-zero on failure.pmap_getmaps
()NULL
. The command
rpcinfo
-p
pmap_getport
()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
()callrpc
() and
clnt_call
(). This procedure should be used for a
“ping” and nothing else. See also
clnt_broadcast
().pmap_set
()IPPROTO_UDP
or
IPPROTO_TCP
. This routine returns one if it
succeeds, zero otherwise. Automatically done by
svc_register
().pmap_unset
()registerrpc
()Warning: remote procedures registered in this form are
accessed using the UDP/IP transport; see
svcudp_bufcreate
() for restrictions.
clnt_pcreateerror
() to print the reason why.svc_destroy
()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.svc_fedset
(), but limited to 32
descriptors. This interface is obsoleted by
svc_fdset
().svc_freeargs
()svc_getargs
(). This routine returns 1 if the
results were successfully freed, and zero otherwise.svc_getargs
()svc_getcaller
()svc_getrpccaller
().svc_getreqset
()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
()svc_getreqset
(), but limited to 32
descriptors. This interface is obsoleted by
svc_getreqset
().svc_getrpccaller
()svc_register
()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
()svc_getreq
() when one arrives. This procedure is
usually waiting for a
select(2) system call to
return.svc_sendreply
()svc_unregister
()svcerr_auth
()svcerr_decode
()svc_getargs
().svcerr_noproc
()svcerr_noprog
()svcerr_progvers
()svcerr_systemerr
()svcerr_weakauth
()svcerr_auth
(xprt,
AUTH_TOOWEAK).svcraw_create
()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
()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
()svcudp_bufcreate
()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
()svcudp_bufcreate
() with predefined
sizes for the maximum packet sizes.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
()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.
December 29, 2016 | NetBSD 9.2 |