1RPC(3) Linux Programmer's Manual RPC(3)
2
6 rpc - library routines for remote procedure calls
7
9 These routines allow C programs to make procedure calls on other ma‐
10 chines across the network. First, the client calls a procedure to send
11 a data packet to the server. Upon receipt of the packet, the server
12 calls a dispatch routine to perform the requested service, and then
13 sends back a reply. Finally, the procedure call returns to the client.
14 To take use of these routines, include the header file <rpc/rpc.h>.
16 The prototypes below make use of the following types:
18 typedef int bool_t;
20 typedef bool_t (*xdrproc_t) (XDR *, void *, ...);
22 typedef bool_t (*resultproc_t) (caddr_t resp,
24 struct sockaddr_in *raddr);
25 See the header files for the declarations of the AUTH, CLIENT, SVCXPRT,
27 and XDR types.
28 void auth_destroy(AUTH *auth);
30 A macro that destroys the authentication information associated
32 with auth. Destruction usually involves deallocation of private
33 data structures. The use of auth is undefined after calling
34 auth_destroy().
35 AUTH *authnone_create(void);
37 Create and return an RPC authentication handle that passes
39 nonusable authentication information with each remote procedure
40 call. This is the default authentication used by RPC.
41 AUTH *authunix_create(char *host, int uid, int gid,
43 int len, int *aup_gids);
44 Create and return an RPC authentication handle that contains au‐
46 thentication information. The parameter host is the name of the
47 machine on which the information was created; uid is the user's
48 user ID; gid is the user's current group ID; len and aup_gids
49 refer to a counted array of groups to which the user belongs.
50 It is easy to impersonate a user.
51 AUTH *authunix_create_default(void);
53 Calls authunix_create() with the appropriate parameters.
55 int callrpc(char *host, unsigned long prognum,
57 unsigned long versnum, unsigned long procnum,
58 xdrproc_t inproc, char *in,
59 xdrproc_t outproc, char *out);
60 Call the remote procedure associated with prognum, versnum, and
62 procnum on the machine, host. The parameter in is the address
63 of the procedure's argument(s), and out is the address of where
64 to place the result(s); inproc is used to encode the procedure's
65 parameters, and outproc is used to decode the procedure's re‐
66 sults. This routine returns zero if it succeeds, or the value
67 of enum clnt_stat cast to an integer if it fails. The routine
68 clnt_perrno() is handy for translating failure statuses into
69 messages.
70 Warning: calling remote procedures with this routine uses UDP/IP
72 as a transport; see clntudp_create() for restrictions. You do
73 not have control of timeouts or authentication using this rou‐
74 tine.
75 enum clnt_stat clnt_broadcast(unsigned long prognum,
77 unsigned long versnum, unsigned long procnum,
78 xdrproc_t inproc, char *in,
79 xdrproc_t outproc, char *out,
80 resultproc_t eachresult);
81 Like callrpc(), except the call message is broadcast to all lo‐
83 cally connected broadcast nets. Each time it receives a re‐
84 sponse, this routine calls eachresult(), whose form is:
85 eachresult(char *out, struct sockaddr_in *addr);
87 where out is the same as out passed to clnt_broadcast(), except
89 that the remote procedure's output is decoded there; addr points
90 to the address of the machine that sent the results. If eachre‐
91 sult() returns zero, clnt_broadcast() waits for more replies;
92 otherwise it returns with appropriate status.
93 Warning: broadcast sockets are limited in size to the maximum
95 transfer unit of the data link. For ethernet, this value is
96 1500 bytes.
97 enum clnt_stat clnt_call(CLIENT *clnt, unsigned long procnum,
99 xdrproc_t inproc, char *in,
100 xdrproc_t outproc, char *out,
101 struct timeval tout);
102 A macro that calls the remote procedure procnum associated with
104 the client handle, clnt, which is obtained with an RPC client
105 creation routine such as clnt_create(). The parameter in is the
106 address of the procedure's argument(s), and out is the address
107 of where to place the result(s); inproc is used to encode the
108 procedure's parameters, and outproc is used to decode the proce‐
109 dure's results; tout is the time allowed for results to come
110 back.
111 clnt_destroy(CLIENT *clnt);
113 A macro that destroys the client's RPC handle. Destruction usu‐
115 ally involves deallocation of private data structures, including
116 clnt itself. Use of clnt is undefined after calling clnt_de‐
117 stroy(). If the RPC library opened the associated socket, it
118 will close it also. Otherwise, the socket remains open.
119 CLIENT *clnt_create(char *host, unsigned long prog,
121 unsigned long vers, char *proto);
122 Generic client creation routine. host identifies the name of
124 the remote host where the server is located. proto indicates
125 which kind of transport protocol to use. The currently sup‐
126 ported values for this field are “udp” and “tcp”. Default time‐
127 outs are set, but can be modified using clnt_control().
128 Warning: using UDP has its shortcomings. Since UDP-based RPC
130 messages can hold only up to 8 Kbytes of encoded data, this
131 transport cannot be used for procedures that take large argu‐
132 ments or return huge results.
133 bool_t clnt_control(CLIENT *cl, int req, char *info);
135 A macro used to change or retrieve various information about a
137 client object. req indicates the type of operation, and info is
138 a pointer to the information. For both UDP and TCP, the sup‐
139 ported values of req and their argument types and what they do
140 are:
141 CLSET_TIMEOUT struct timeval // set total timeout
143 CLGET_TIMEOUT struct timeval // get total timeout
144 Note: if you set the timeout using clnt_control(), the timeout
146 parameter passed to clnt_call() will be ignored in all future
147 calls.
148 CLGET_SERVER_ADDR struct sockaddr_in // get server's address
150 The following operations are valid for UDP only:
152 CLSET_RETRY_TIMEOUT struct timeval // set the retry timeout
154 CLGET_RETRY_TIMEOUT struct timeval // get the retry timeout
155 The retry timeout is the time that "UDP RPC" waits for the
157 server to reply before retransmitting the request.
158 clnt_freeres(CLIENT * clnt, xdrproc_t outproc, char *out);
160 A macro that frees any data allocated by the RPC/XDR system when
162 it decoded the results of an RPC call. The parameter out is the
163 address of the results, and outproc is the XDR routine describ‐
164 ing the results. This routine returns one if the results were
165 successfully freed, and zero otherwise.
166 void clnt_geterr(CLIENT *clnt, struct rpc_err *errp);
168 A macro that copies the error structure out of the client handle
170 to the structure at address errp.
171 void clnt_pcreateerror(char *s);
173 Print a message to standard error indicating why a client RPC
175 handle could not be created. The message is prepended with
176 string s and a colon. Used when a clnt_create(), clntraw_cre‐
177 ate(), clnttcp_create(), or clntudp_create() call fails.
178 void clnt_perrno(enum clnt_stat stat);
180 Print a message to standard error corresponding to the condition
182 indicated by stat. Used after callrpc().
183 clnt_perror(CLIENT *clnt, char *s);
185 Print a message to standard error indicating why an RPC call
187 failed; clnt is the handle used to do the call. The message is
188 prepended with string s and a colon. Used after clnt_call().
189 char *clnt_spcreateerror(char *s);
191 Like clnt_pcreateerror(), except that it returns a string in‐
193 stead of printing to the standard error.
194 Bugs: returns pointer to static data that is overwritten on each
196 call.
197 char *clnt_sperrno(enum clnt_stat stat);
199 Take the same arguments as clnt_perrno(), but instead of sending
201 a message to the standard error indicating why an RPC call
202 failed, return a pointer to a string which contains the message.
203 The string ends with a NEWLINE.
204 clnt_sperrno() is used instead of clnt_perrno() if the program
206 does not have a standard error (as a program running as a server
207 quite likely does not), or if the programmer does not want the
208 message to be output with printf(3), or if a message format dif‐
209 ferent than that supported by clnt_perrno() is to be used.
210 Note: unlike clnt_sperror() and clnt_spcreateerror(), clnt_sper‐
211 rno() returns pointer to static data, but the result will not
212 get overwritten on each call.
213 char *clnt_sperror(CLIENT *rpch, char *s);
215 Like clnt_perror(), except that (like clnt_sperrno()) it returns
217 a string instead of printing to standard error.
218 Bugs: returns pointer to static data that is overwritten on each
220 call.
221 CLIENT *clntraw_create(unsigned long prognum, unsigned long versnum);
223 This routine creates a toy RPC client for the remote program
225 prognum, version versnum. The transport used to pass messages
226 to the service is actually a buffer within the process's address
227 space, so the corresponding RPC server should live in the same
228 address space; see svcraw_create(). This allows simulation of
229 RPC and acquisition of RPC overheads, such as round trip times,
230 without any kernel interference. This routine returns NULL if
231 it fails.
232 CLIENT *clnttcp_create(struct sockaddr_in *addr,
234 unsigned long prognum, unsigned long versnum,
235 int *sockp, unsigned int sendsz, unsigned int recvsz);
236 This routine creates an RPC client for the remote program
238 prognum, version versnum; the client uses TCP/IP as a transport.
239 The remote program is located at Internet address *addr. If
240 addr->sin_port is zero, then it is set to the actual port that
241 the remote program is listening on (the remote portmap service
242 is consulted for this information). The parameter sockp is a
243 socket; if it is RPC_ANYSOCK, then this routine opens a new one
244 and sets sockp. Since TCP-based RPC uses buffered I/O, the user
245 may specify the size of the send and receive buffers with the
246 parameters sendsz and recvsz; values of zero choose suitable de‐
247 faults. This routine returns NULL if it fails.
248 CLIENT *clntudp_create(struct sockaddr_in *addr,
250 unsigned long prognum, unsigned long versnum,
251 struct timeval wait, int *sockp);
252 This routine creates an RPC client for the remote program
254 prognum, version versnum; the client uses use UDP/IP as a trans‐
255 port. The remote program is located at Internet address addr.
256 If addr->sin_port is zero, then it is set to actual port that
257 the remote program is listening on (the remote portmap service
258 is consulted for this information). The parameter sockp is a
259 socket; if it is RPC_ANYSOCK, then this routine opens a new one
260 and sets sockp. The UDP transport resends the call message in
261 intervals of wait time until a response is received or until the
262 call times out. The total time for the call to time out is
263 specified by clnt_call().
264 Warning: since UDP-based RPC messages can hold only up to 8
266 Kbytes of encoded data, this transport cannot be used for proce‐
267 dures that take large arguments or return huge results.
268 CLIENT *clntudp_bufcreate(struct sockaddr_in *addr,
270 unsigned long prognum, unsigned long versnum,
271 struct timeval wait, int *sockp,
272 unsigned int sendsize, unsigned int recosize);
273 This routine creates an RPC client for the remote program
275 prognum, on versnum; the client uses use UDP/IP as a transport.
276 The remote program is located at Internet address addr. If
277 addr->sin_port is zero, then it is set to actual port that the
278 remote program is listening on (the remote portmap service is
279 consulted for this information). The parameter sockp is a
280 socket; if it is RPC_ANYSOCK, then this routine opens a new one
281 and sets sockp. The UDP transport resends the call message in
282 intervals of wait time until a response is received or until the
283 call times out. The total time for the call to time out is
284 specified by clnt_call().
285 This allows the user to specify the maximum packet size for
287 sending and receiving UDP-based RPC messages.
288 void get_myaddress(struct sockaddr_in *addr);
290 Stuff the machine's IP address into *addr, without consulting
292 the library routines that deal with /etc/hosts. The port number
293 is always set to htons(PMAPPORT).
294 struct pmaplist *pmap_getmaps(struct sockaddr_in *addr);
296 A user interface to the portmap service, which returns a list of
298 the current RPC program-to-port mappings on the host located at
299 IP address *addr. This routine can return NULL. The command
300 rpcinfo -p uses this routine.
301 unsigned short pmap_getport(struct sockaddr_in *addr,
303 unsigned long prognum, unsigned long versnum,
304 unsigned int protocol);
305 A user interface to the portmap service, which returns the port
307 number on which waits a service that supports program number
308 prognum, version versnum, and speaks the transport protocol as‐
309 sociated with protocol. The value of protocol is most likely
310 IPPROTO_UDP or IPPROTO_TCP. A return value of zero means that
311 the mapping does not exist or that the RPC system failed to con‐
312 tact the remote portmap service. In the latter case, the global
313 variable rpc_createerr contains the RPC status.
314 enum clnt_stat pmap_rmtcall(struct sockaddr_in *addr,
316 unsigned long prognum, unsigned long versnum,
317 unsigned long procnum,
318 xdrproc_t inproc, char *in,
319 xdrproc_t outproc, char *out,
320 struct timeval tout, unsigned long *portp);
321 A user interface to the portmap service, which instructs portmap
323 on the host at IP address *addr to make an RPC call on your be‐
324 half to a procedure on that host. The parameter *portp will be
325 modified to the program's port number if the procedure succeeds.
326 The definitions of other parameters are discussed in callrpc()
327 and clnt_call(). This procedure should be used for a “ping” and
328 nothing else. See also clnt_broadcast().
329 bool_t pmap_set(unsigned long prognum, unsigned long versnum,
331 unsigned int protocol, unsigned short port);
332 A user interface to the portmap service, which establishes a
334 mapping between the triple [prognum,versnum,protocol] and port
335 on the machine's portmap service. The value of protocol is most
336 likely IPPROTO_UDP or IPPROTO_TCP. This routine returns one if
337 it succeeds, zero otherwise. Automatically done by svc_regis‐
338 ter().
339 bool_t pmap_unset(unsigned long prognum, unsigned long versnum);
341 A user interface to the portmap service, which destroys all map‐
343 ping between the triple [prognum,versnum,*] and ports on the ma‐
344 chine's portmap service. This routine returns one if it suc‐
345 ceeds, zero otherwise.
346 int registerrpc(unsigned long prognum, unsigned long versnum,
348 unsigned long procnum, char *(*procname)(char *),
349 xdrproc_t inproc, xdrproc_t outproc);
350 Register procedure procname with the RPC service package. If a
352 request arrives for program prognum, version versnum, and proce‐
353 dure procnum, procname is called with a pointer to its parame‐
354 ter(s); procname should return a pointer to its static re‐
355 sult(s); inproc is used to decode the parameters while outproc
356 is used to encode the results. This routine returns zero if the
357 registration succeeded, -1 otherwise.
358 Warning: remote procedures registered in this form are accessed
360 using the UDP/IP transport; see svcudp_create() for restric‐
361 tions.
362 struct rpc_createerr rpc_createerr;
364 A global variable whose value is set by any RPC client creation
366 routine that does not succeed. Use the routine clnt_pcreateer‐
367 ror() to print the reason why.
368 void svc_destroy(SVCXPRT *xprt);
370 A macro that destroys the RPC service transport handle, xprt.
372 Destruction usually involves deallocation of private data struc‐
373 tures, including xprt itself. Use of xprt is undefined after
374 calling this routine.
375 fd_set svc_fdset;
377 A global variable reflecting the RPC service side's read file
379 descriptor bit mask; it is suitable as a parameter to the se‐
380 lect(2) system call. This is of interest only if a service im‐
381 plementor does their own asynchronous event processing, instead
382 of calling svc_run(). This variable is read-only (do not pass
383 its address to select(2)!), yet it may change after calls to
384 svc_getreqset() or any creation routines.
385 int svc_fds;
387 Similar to svc_fdset, but limited to 32 file descriptors. This
389 interface is obsoleted by svc_fdset.
390 svc_freeargs(SVCXPRT *xprt, xdrproc_t inproc, char *in);
392 A macro that frees any data allocated by the RPC/XDR system when
394 it decoded the arguments to a service procedure using
395 svc_getargs(). This routine returns 1 if the results were suc‐
396 cessfully freed, and zero otherwise.
397 svc_getargs(SVCXPRT *xprt, xdrproc_t inproc, char *in);
399 A macro that decodes the arguments of an RPC request associated
401 with the RPC service transport handle, xprt. The parameter in
402 is the address where the arguments will be placed; inproc is the
403 XDR routine used to decode the arguments. This routine returns
404 one if decoding succeeds, and zero otherwise.
405 struct sockaddr_in *svc_getcaller(SVCXPRT *xprt);
407 The approved way of getting the network address of the caller of
409 a procedure associated with the RPC service transport handle,
410 xprt.
411 void svc_getreqset(fd_set *rdfds);
413 This routine is of interest only if a service implementor does
415 not call svc_run(), but instead implements custom asynchronous
416 event processing. It is called when the select(2) system call
417 has determined that an RPC request has arrived on some RPC
418 socket(s); rdfds is the resultant read file descriptor bit mask.
419 The routine returns when all sockets associated with the value
420 of rdfds have been serviced.
421 void svc_getreq(int rdfds);
423 Similar to svc_getreqset(), but limited to 32 file descriptors.
425 This interface is obsoleted by svc_getreqset().
426 bool_t svc_register(SVCXPRT *xprt, unsigned long prognum,
428 unsigned long versnum,
429 void (*dispatch)(svc_req *, SVCXPRT *),
430 unsigned long protocol);
431 Associates prognum and versnum with the service dispatch proce‐
433 dure, dispatch. If protocol is zero, the service is not regis‐
434 tered with the portmap service. If protocol is nonzero, then a
435 mapping of the triple [prognum,versnum,protocol] to
436 xprt->xp_port is established with the local portmap service
437 (generally protocol is zero, IPPROTO_UDP or IPPROTO_TCP). The
438 procedure dispatch has the following form:
439 dispatch(struct svc_req *request, SVCXPRT *xprt);
441 The svc_register() routine returns one if it succeeds, and zero
443 otherwise.
444 void svc_run(void);
446 This routine never returns. It waits for RPC requests to ar‐
448 rive, and calls the appropriate service procedure using svc_ge‐
449 treq() when one arrives. This procedure is usually waiting for
450 a select(2) system call to return.
451 bool_t svc_sendreply(SVCXPRT *xprt, xdrproc_t outproc, char *out);
453 Called by an RPC service's dispatch routine to send the results
455 of a remote procedure call. The parameter xprt is the request's
456 associated transport handle; outproc is the XDR routine which is
457 used to encode the results; and out is the address of the re‐
458 sults. This routine returns one if it succeeds, zero otherwise.
459 void svc_unregister(unsigned long prognum, unsigned long versnum);
461 Remove all mapping of the double [prognum,versnum] to dispatch
463 routines, and of the triple [prognum,versnum,*] to port number.
464 void svcerr_auth(SVCXPRT *xprt, enum auth_stat why);
466 Called by a service dispatch routine that refuses to perform a
468 remote procedure call due to an authentication error.
469 void svcerr_decode(SVCXPRT *xprt);
471 Called by a service dispatch routine that cannot successfully
473 decode its parameters. See also svc_getargs().
474 void svcerr_noproc(SVCXPRT *xprt);
476 Called by a service dispatch routine that does not implement the
478 procedure number that the caller requests.
479 void svcerr_noprog(SVCXPRT *xprt);
481 Called when the desired program is not registered with the RPC
483 package. Service implementors usually do not need this routine.
484 void svcerr_progvers(SVCXPRT *xprt);
486 Called when the desired version of a program is not registered
488 with the RPC package. Service implementors usually do not need
489 this routine.
490 void svcerr_systemerr(SVCXPRT *xprt);
492 Called by a service dispatch routine when it detects a system
494 error not covered by any particular protocol. For example, if a
495 service can no longer allocate storage, it may call this rou‐
496 tine.
497 void svcerr_weakauth(SVCXPRT *xprt);
499 Called by a service dispatch routine that refuses to perform a
501 remote procedure call due to insufficient authentication parame‐
502 ters. The routine calls svcerr_auth(xprt, AUTH_TOOWEAK).
503 SVCXPRT *svcfd_create(int fd, unsigned int sendsize,
505 unsigned int recvsize);
506 Create a service on top of any open file descriptor. Typically,
508 this file descriptor is a connected socket for a stream protocol
509 such as TCP. sendsize and recvsize indicate sizes for the send
510 and receive buffers. If they are zero, a reasonable default is
511 chosen.
512 SVCXPRT *svcraw_create(void);
514 This routine creates a toy RPC service transport, to which it
516 returns a pointer. The transport is really a buffer within the
517 process's address space, so the corresponding RPC client should
518 live in the same address space; see clntraw_create(). This rou‐
519 tine allows simulation of RPC and acquisition of RPC overheads
520 (such as round trip times), without any kernel interference.
521 This routine returns NULL if it fails.
522 SVCXPRT *svctcp_create(int sock, unsigned int send_buf_size,
524 unsigned int recv_buf_size);
525 This routine creates a TCP/IP-based RPC service transport, to
527 which it returns a pointer. The transport is associated with
528 the socket sock, which may be RPC_ANYSOCK, in which case a new
529 socket is created. If the socket is not bound to a local TCP
530 port, then this routine binds it to an arbitrary port. Upon
531 completion, xprt->xp_sock is the transport's socket descriptor,
532 and xprt->xp_port is the transport's port number. This routine
533 returns NULL if it fails. Since TCP-based RPC uses buffered
534 I/O, users may specify the size of buffers; values of zero
535 choose suitable defaults.
536 SVCXPRT *svcudp_bufcreate(int sock, unsigned int sendsize,
538 unsigned int recosize);
539 This routine creates a UDP/IP-based RPC service transport, to
541 which it returns a pointer. The transport is associated with
542 the socket sock, which may be RPC_ANYSOCK, in which case a new
543 socket is created. If the socket is not bound to a local UDP
544 port, then this routine binds it to an arbitrary port. Upon
545 completion, xprt->xp_sock is the transport's socket descriptor,
546 and xprt->xp_port is the transport's port number. This routine
547 returns NULL if it fails.
548 This allows the user to specify the maximum packet size for
550 sending and receiving UDP-based RPC messages.
551 SVCXPRT *svcudp_create(int sock);
553 This call is equivalent to svcudp_bufcreate(sock,SZ,SZ) for some
555 default size SZ.
556 bool_t xdr_accepted_reply(XDR *xdrs, struct accepted_reply *ar);
558 Used for encoding RPC reply messages. This routine is useful
560 for users who wish to generate RPC-style messages without using
561 the RPC package.
562 bool_t xdr_authunix_parms(XDR *xdrs, struct authunix_parms *aupp);
564 Used for describing UNIX credentials. This routine is useful
566 for users who wish to generate these credentials without using
567 the RPC authentication package.
568 void xdr_callhdr(XDR *xdrs, struct rpc_msg *chdr);
570 Used for describing RPC call header messages. This routine is
572 useful for users who wish to generate RPC-style messages without
573 using the RPC package.
574 bool_t xdr_callmsg(XDR *xdrs, struct rpc_msg *cmsg);
576 Used for describing RPC call messages. This routine is useful
578 for users who wish to generate RPC-style messages without using
579 the RPC package.
580 bool_t xdr_opaque_auth(XDR *xdrs, struct opaque_auth *ap);
582 Used for describing RPC authentication information messages.
584 This routine is useful for users who wish to generate RPC-style
585 messages without using the RPC package.
586 bool_t xdr_pmap(XDR *xdrs, struct pmap *regs);
588 Used for describing parameters to various portmap procedures,
590 externally. This routine is useful for users who wish to gener‐
591 ate these parameters without using the pmap interface.
592 bool_t xdr_pmaplist(XDR *xdrs, struct pmaplist **rp);
594 Used for describing a list of port mappings, externally. This
596 routine is useful for users who wish to generate these parame‐
597 ters without using the pmap interface.
598 bool_t xdr_rejected_reply(XDR *xdrs, struct rejected_reply *rr);
600 Used for describing RPC reply messages. This routine is useful
602 for users who wish to generate RPC-style messages without using
603 the RPC package.
604 bool_t xdr_replymsg(XDR *xdrs, struct rpc_msg *rmsg);
606 Used for describing RPC reply messages. This routine is useful
608 for users who wish to generate RPC style messages without using
609 the RPC package.
610 void xprt_register(SVCXPRT *xprt);
612 After RPC service transport handles are created, they should
614 register themselves with the RPC service package. This routine
615 modifies the global variable svc_fds. Service implementors usu‐
616 ally do not need this routine.
617 void xprt_unregister(SVCXPRT *xprt);
619 Before an RPC service transport handle is destroyed, it should
621 unregister itself with the RPC service package. This routine
622 modifies the global variable svc_fds. Service implementors usu‐
623 ally do not need this routine.
624
626 For an explanation of the terms used in this section, see at‐
627 tributes(7).
628 ┌────────────────────────────────────┬───────────────┬─────────┐
630 │Interface │ Attribute │ Value │
631 ├────────────────────────────────────┼───────────────┼─────────┤
632 │auth_destroy(), authnone_create(), │ Thread safety │ MT-Safe │
633 │authunix_create(), │ │ │
634 │authunix_create_default(), │ │ │
635 │callrpc(), clnt_broadcast(), │ │ │
636 │clnt_call(), clnt_destroy(), │ │ │
637 │clnt_create(), clnt_control(), │ │ │
638 │clnt_freeres(), clnt_geterr(), │ │ │
639 │clnt_pcreateerror(), clnt_perrno(), │ │ │
640 │clnt_perror(), │ │ │
641 │clnt_spcreateerror(), │ │ │
642 │clnt_sperrno(), clnt_sperror(), │ │ │
643 │clntraw_create(), clnttcp_create(), │ │ │
644 │clntudp_create(), │ │ │
645 │clntudp_bufcreate(), │ │ │
646 │get_myaddress(), pmap_getmaps(), │ │ │
647 │pmap_getport(), pmap_rmtcall(), │ │ │
648 │pmap_set(), pmap_unset(), │ │ │
649 │registerrpc(), svc_destroy(), │ │ │
650 │svc_freeargs(), svc_getargs(), │ │ │
651 │svc_getcaller(), svc_getreqset(), │ │ │
652 │svc_getreq(), svc_register(), │ │ │
653 │svc_run(), svc_sendreply(), │ │ │
654 │svc_unregister(), svcerr_auth(), │ │ │
655 │svcerr_decode(), svcerr_noproc(), │ │ │
656 │svcerr_noprog(), svcerr_progvers(), │ │ │
657 │svcerr_systemerr(), │ │ │
658 │svcerr_weakauth(), │ │ │
659 │svcfd_create(), svcraw_create(), │ │ │
660 │svctcp_create(), │ │ │
661 │svcudp_bufcreate(), │ │ │
662 │svcudp_create(), xdr_accepted_re‐ │ │ │
663 │ply(), │ │ │
664 │xdr_authunix_parms(), │ │ │
665 │xdr_callhdr(), │ │ │
666 │xdr_callmsg(), xdr_opaque_auth(), │ │ │
667 │xdr_pmap(), xdr_pmaplist(), │ │ │
668 │xdr_rejected_reply(), │ │ │
669 │xdr_replymsg(), │ │ │
670 │xprt_register(), xprt_unregister() │ │ │
671 └────────────────────────────────────┴───────────────┴─────────┘
673 xdr(3)
674 The following manuals:
676 Remote Procedure Calls: Protocol Specification
677 Remote Procedure Call Programming Guide
678 rpcgen Programming Guide
679 RPC: Remote Procedure Call Protocol Specification, RFC 1050, Sun Mi‐
681 crosystems, Inc., USC-ISI.
682
684 This page is part of release 5.10 of the Linux man-pages project. A
685 description of the project, information about reporting bugs, and the
686 latest version of this page, can be found at
687 https://www.kernel.org/doc/man-pages/.
688 2020-11-01 RPC(3)