1 .\" This page was taken from the 4.4BSD-Lite CDROM (BSD license)
3 .\" %%%LICENSE_START(BSD_ONELINE_CDROM)
4 .\" This page was taken from the 4.4BSD-Lite CDROM (BSD license)
7 .\" @(#)rpc.3n 2.4 88/08/08 4.0 RPCSRC; from 1.19 88/06/24 SMI
9 .\" 2007-12-30, mtk, Convert function prototypes to modern C syntax
11 .TH RPC 3 2017-09-15 "" "Linux Programmer's Manual"
13 rpc \- library routines for remote procedure calls
14 .SH SYNOPSIS AND DESCRIPTION
15 These routines allow C programs to make procedure
16 calls on other machines across the network.
17 First, the client calls a procedure to send a data packet to the server.
18 Upon receipt of the packet, the server calls a dispatch routine
19 to perform the requested service, and then sends back a reply.
20 Finally, the procedure call returns to the client.
22 .\" We don't have an rpc_secure.3 page at the moment -- MTK, 19 Sep 05
23 .\" Routines that are used for Secure RPC (DES authentication) are described in
24 .\" .BR rpc_secure (3).
25 .\" Secure RPC can be used only if DES encryption is available.
27 To take use of these routines, include the header file
30 The prototypes below make use of the following types:
34 .BI "typedef int " bool_t ;
36 .BI "typedef bool_t (*" xdrproc_t ") (XDR *, void *, ...);"
38 .BI "typedef bool_t (*" resultproc_t ") (caddr_t " resp ,
39 .BI " struct sockaddr_in *" raddr );
43 See the header files for the declarations of the
52 .BI "void auth_destroy(AUTH *" auth );
55 A macro that destroys the authentication information associated with
57 Destruction usually involves deallocation of private data structures.
60 is undefined after calling
64 .BI "AUTH *authnone_create(void);"
67 Create and return an RPC
68 authentication handle that passes nonusable authentication
69 information with each remote procedure call.
70 This is the default authentication used by RPC.
73 .BI "AUTH *authunix_create(char *" host ", int " uid ", int " gid ,
74 .BI " int " len ", int *" aup_gids );
77 Create and return an RPC authentication handle that contains
78 authentication information.
81 is the name of the machine on which the information was created;
83 is the user's user ID;
85 is the user's current group ID;
89 refer to a counted array of groups to which the user belongs.
90 It is easy to impersonate a user.
93 .BI "AUTH *authunix_create_default(void);"
97 .BR authunix_create ()
98 with the appropriate parameters.
101 .BI "int callrpc(char *" host ", unsigned long " prognum ,
102 .BI " unsigned long " versnum ", unsigned long " procnum ,
103 .BI " xdrproc_t " inproc ", char *" in ,
104 .BI " xdrproc_t " outproc ", char *" out );
107 Call the remote procedure associated with
116 is the address of the procedure's argument(s), and
118 is the address of where to place the result(s);
120 is used to encode the procedure's parameters, and
122 is used to decode the procedure's results.
123 This routine returns zero if it succeeds, or the value of
125 cast to an integer if it fails.
128 is handy for translating failure statuses into messages.
130 Warning: calling remote procedures with this routine
131 uses UDP/IP as a transport; see
132 .BR clntudp_create ()
134 You do not have control of timeouts or authentication using this routine.
137 .BI "enum clnt_stat clnt_broadcast(unsigned long " prognum ,
138 .BI " unsigned long " versnum ", unsigned long " procnum ,
139 .BI " xdrproc_t " inproc ", char *" in ,
140 .BI " xdrproc_t " outproc ", char *" out ,
141 .BI " resultproc_t " eachresult );
146 except the call message is broadcast to all locally
147 connected broadcast nets.
148 Each time it receives a response, this routine calls
154 .BI "eachresult(char *" out ", struct sockaddr_in *" addr );
163 .BR clnt_broadcast (),
164 except that the remote procedure's output is decoded there;
166 points to the address of the machine that sent the results.
170 .BR clnt_broadcast ()
171 waits for more replies; otherwise it returns with appropriate status.
173 Warning: broadcast sockets are limited in size to the
174 maximum transfer unit of the data link.
175 For ethernet, this value is 1500 bytes.
178 .BI "enum clnt_stat clnt_call(CLIENT *" clnt ", unsigned long " procnum ,
179 .BI " xdrproc_t " inproc ", char *" in ,
180 .BI " xdrproc_t " outproc ", char *" out ,
181 .BI " struct timeval " tout );
184 A macro that calls the remote procedure
186 associated with the client handle,
188 which is obtained with an RPC client creation routine such as
192 is the address of the procedure's argument(s), and
194 is the address of where to place the result(s);
196 is used to encode the procedure's parameters, and
198 is used to decode the procedure's results;
200 is the time allowed for results to come back.
203 .BI "clnt_destroy(CLIENT *" clnt );
206 A macro that destroys the client's RPC handle.
207 Destruction usually involves deallocation
208 of private data structures, including
213 is undefined after calling
215 If the RPC library opened the associated socket, it will close it also.
216 Otherwise, the socket remains open.
219 .BI "CLIENT *clnt_create(char *" host ", unsigned long " prog ,
220 .BI " unsigned long " vers ", char *" proto );
223 Generic client creation routine.
225 identifies the name of the remote host where the server is located.
227 indicates which kind of transport protocol to use.
228 The currently supported values for this field are \(lqudp\(rq
230 Default timeouts are set, but can be modified using
233 Warning: using UDP has its shortcomings.
234 Since UDP-based RPC messages can hold only up to 8 Kbytes of encoded data,
235 this transport cannot be used for procedures that take
236 large arguments or return huge results.
239 .BI "bool_t clnt_control(CLIENT *" cl ", int " req ", char *" info );
242 A macro used to change or retrieve various information
243 about a client object.
245 indicates the type of operation, and
247 is a pointer to the information.
248 For both UDP and TCP, the supported values of
250 and their argument types and what they do are:
254 \fBCLSET_TIMEOUT\fP \fIstruct timeval\fP // set total timeout
255 \fBCLGET_TIMEOUT\fP \fIstruct timeval\fP // get total timeout
259 Note: if you set the timeout using
261 the timeout parameter passed to
263 will be ignored in all future calls.
267 \fBCLGET_SERVER_ADDR\fP \fIstruct sockaddr_in \fP // get server's address
271 The following operations are valid for UDP only:
275 \fBCLSET_RETRY_TIMEOUT\fP \fIstruct timeval\fP // set the retry timeout
276 \fBCLGET_RETRY_TIMEOUT\fP \fIstruct timeval\fP // get the retry timeout
280 The retry timeout is the time that "UDP RPC"
281 waits for the server to reply before
282 retransmitting the request.
285 .BI "clnt_freeres(CLIENT * " clnt ", xdrproc_t " outproc ", char *" out );
288 A macro that frees any data allocated by the RPC/XDR
289 system when it decoded the results of an RPC call.
292 is the address of the results, and
294 is the XDR routine describing the results.
295 This routine returns one if the results were successfully freed,
299 .BI "void clnt_geterr(CLIENT *" clnt ", struct rpc_err *" errp );
302 A macro that copies the error structure out of the client
303 handle to the structure at address
307 .BI "void clnt_pcreateerror(char *" s );
310 Print a message to standard error indicating why a client RPC
311 handle could not be created.
312 The message is prepended with string
317 .BR clntraw_create (),
318 .BR clnttcp_create (),
320 .BR clntudp_create ()
324 .BI "void clnt_perrno(enum clnt_stat " stat );
327 Print a message to standard error corresponding
328 to the condition indicated by
334 .BI "clnt_perror(CLIENT *" clnt ", char *" s );
337 Print a message to standard error indicating why an RPC call failed;
339 is the handle used to do the call.
340 The message is prepended with string
347 .BI "char *clnt_spcreateerror(char *" s );
351 .BR clnt_pcreateerror (),
352 except that it returns a string instead of printing to the standard error.
354 Bugs: returns pointer to static data that is overwritten on each call.
357 .BI "char *clnt_sperrno(enum clnt_stat " stat );
360 Take the same arguments as
362 but instead of sending a message to the standard error indicating why an RPC
363 call failed, return a pointer to a string which contains the message.
364 The string ends with a NEWLINE.
369 if the program does not have a standard error (as a program
370 running as a server quite likely does not), or if the programmer
371 does not want the message to be output with
373 or if a message format different than that supported by
379 .BR clnt_spcreateerror (),
381 returns pointer to static data, but the
382 result will not get overwritten on each call.
385 .BI "char *clnt_sperror(CLIENT *" rpch ", char *" s );
392 it returns a string instead of printing to standard error.
394 Bugs: returns pointer to static data that is overwritten on each call.
397 .BI "CLIENT *clntraw_create(unsigned long " prognum \
398 ", unsigned long " versnum );
401 This routine creates a toy RPC client for the remote program
405 The transport used to pass messages to the service is
406 actually a buffer within the process's address space, so the
407 corresponding RPC server should live in the same address space; see
408 .BR svcraw_create ().
409 This allows simulation of RPC and acquisition of RPC
410 overheads, such as round trip times, without any kernel interference.
411 This routine returns NULL if it fails.
414 .BI "CLIENT *clnttcp_create(struct sockaddr_in *" addr ,
415 .BI " unsigned long " prognum ", unsigned long " versnum ,
416 .BI " int *" sockp ", unsigned int " sendsz \
417 ", unsigned int " recvsz );
420 This routine creates an RPC client for the remote program
424 the client uses TCP/IP as a transport.
425 The remote program is located at Internet address
428 .\"The following inline font conversion is necessary for the hyphen indicator
430 is zero, then it is set to the actual port that the remote
431 program is listening on (the remote
433 service is consulted for this information).
436 is a socket; if it is
438 then this routine opens a new one and sets
440 Since TCP-based RPC uses buffered I/O,
441 the user may specify the size of the send and receive buffers
446 values of zero choose suitable defaults.
447 This routine returns NULL if it fails.
450 .BI "CLIENT *clntudp_create(struct sockaddr_in *" addr ,
451 .BI " unsigned long " prognum ", unsigned long " versnum ,
452 .BI " struct timeval " wait ", int *" sockp );
455 This routine creates an RPC client for the remote program
459 the client uses use UDP/IP as a transport.
460 The remote program is located at Internet address
464 is zero, then it is set to actual port that the remote
465 program is listening on (the remote
467 service is consulted for this information).
470 is a socket; if it is
472 then this routine opens a new one and sets
474 The UDP transport resends the call message in intervals of
476 time until a response is received or until the call times out.
477 The total time for the call to time out is specified by
480 Warning: since UDP-based RPC messages can hold only up to 8 Kbytes
481 of encoded data, this transport cannot be used for procedures
482 that take large arguments or return huge results.
485 .BI "CLIENT *clntudp_bufcreate(struct sockaddr_in *" addr ,
486 .BI " unsigned long " prognum ", unsigned long " versnum ,
487 .BI " struct timeval " wait ", int *" sockp ,
488 .BI " unsigned int " sendsize ", unsigned int "recosize );
491 This routine creates an RPC client for the remote program
495 the client uses use UDP/IP as a transport.
496 The remote program is located at Internet address
500 is zero, then it is set to actual port that the remote
501 program is listening on (the remote
503 service is consulted for this information).
506 is a socket; if it is
508 then this routine opens a new one and sets
510 The UDP transport resends the call message in intervals of
512 time until a response is received or until the call times out.
513 The total time for the call to time out is specified by
516 This allows the user to specify the maximum packet
517 size for sending and receiving UDP-based RPC messages.
520 .BI "void get_myaddress(struct sockaddr_in *" addr );
523 Stuff the machine's IP address into
525 without consulting the library routines that deal with
527 The port number is always set to
528 .BR htons(PMAPPORT) .
531 .BI "struct pmaplist *pmap_getmaps(struct sockaddr_in *" addr );
534 A user interface to the
536 service, which returns a list of the current RPC
537 program-to-port mappings on the host located at IP address
539 This routine can return NULL.
545 .BI "unsigned short pmap_getport(struct sockaddr_in *" addr ,
546 .BI " unsigned long " prognum ", unsigned long " versnum ,
547 .BI " unsigned int " protocol );
550 A user interface to the
552 service, which returns the port number
553 on which waits a service that supports program number
557 and speaks the transport protocol associated with
565 A return value of zero means that the mapping does not exist
566 or that the RPC system failed to contact the remote
569 In the latter case, the global variable
571 contains the RPC status.
574 .BI "enum clnt_stat pmap_rmtcall(struct sockaddr_in *" addr ,
575 .BI " unsigned long " prognum ", unsigned long " versnum ,
576 .BI " unsigned long " procnum ,
577 .BI " xdrproc_t " inproc ", char *" in ,
578 .BI " xdrproc_t " outproc ", char *" out ,
579 .BI " struct timeval " tout ", unsigned long *" portp );
582 A user interface to the
584 service, which instructs
586 on the host at IP address
588 to make an RPC call on your behalf to a procedure on that host.
591 will be modified to the program's port number if the procedure succeeds.
592 The definitions of other parameters are discussed
597 This procedure should be used for a \(lqping\(rq and nothing else.
599 .BR clnt_broadcast ().
602 .BI "bool_t pmap_set(unsigned long " prognum ", unsigned long " versnum ,
603 .BI " unsigned int " protocol ", unsigned short " port );
606 A user interface to the
608 service, which establishes a mapping between the triple
609 .RI [ prognum , versnum , protocol ]
621 This routine returns one if it succeeds, zero otherwise.
622 Automatically done by
626 .BI "bool_t pmap_unset(unsigned long " prognum ", unsigned long " versnum );
629 A user interface to the
631 service, which destroys all mapping between the triple
632 .RI [ prognum , versnum , * ]
638 This routine returns one if it succeeds, zero otherwise.
641 .BI "int registerrpc(unsigned long " prognum ", unsigned long " versnum ,
642 .BI " unsigned long " procnum ", char *(*" procname ")(char *),"
643 .BI " xdrproc_t " inproc ", xdrproc_t " outproc );
648 with the RPC service package.
649 If a request arrives for program
656 is called with a pointer to its parameter(s);
658 should return a pointer to its static result(s);
660 is used to decode the parameters while
662 is used to encode the results.
663 This routine returns zero if the registration succeeded, \-1 otherwise.
665 Warning: remote procedures registered in this form
666 are accessed using the UDP/IP transport; see
671 .BI "struct rpc_createerr " rpc_createerr ;
674 A global variable whose value is set by any RPC client creation routine
675 that does not succeed.
677 .BR clnt_pcreateerror ()
678 to print the reason why.
681 .BI "void svc_destroy(SVCXPRT *" xprt );
684 A macro that destroys the RPC service transport handle,
686 Destruction usually involves deallocation
687 of private data structures, including
692 is undefined after calling this routine.
695 .BI "fd_set " svc_fdset ;
698 A global variable reflecting the RPC service side's
699 read file descriptor bit mask; it is suitable as a parameter to the
702 This is of interest only if a service implementor does their own
703 asynchronous event processing, instead of calling
705 This variable is read-only (do not pass its address to
707 yet it may change after calls to
709 or any creation routines.
717 but limited to 32 file descriptors.
718 This interface is obsoleted by
722 .BI "svc_freeargs(SVCXPRT *" xprt ", xdrproc_t " inproc ", char *" in );
725 A macro that frees any data allocated by the RPC/XDR
726 system when it decoded the arguments to a service procedure using
728 This routine returns 1 if the results were successfully freed,
732 .BI "svc_getargs(SVCXPRT *" xprt ", xdrproc_t " inproc ", char *" in );
735 A macro that decodes the arguments of an RPC request
736 associated with the RPC service transport handle,
740 is the address where the arguments will be placed;
742 is the XDR routine used to decode the arguments.
743 This routine returns one if decoding succeeds, and zero otherwise.
746 .BI "struct sockaddr_in *svc_getcaller(SVCXPRT *" xprt );
749 The approved way of getting the network address of the caller
750 of a procedure associated with the RPC service transport handle,
754 .BI "void svc_getreqset(fd_set *" rdfds );
757 This routine is of interest only if a service implementor does not call
759 but instead implements custom asynchronous event processing.
760 It is called when the
762 system call has determined that an RPC request has arrived on some
765 is the resultant read file descriptor bit mask.
766 The routine returns when all sockets associated with the value of
771 .BI "void svc_getreq(int " rdfds );
775 .BR svc_getreqset (),
776 but limited to 32 file descriptors.
777 This interface is obsoleted by
778 .BR svc_getreqset ().
781 .BI "bool_t svc_register(SVCXPRT *" xprt ", unsigned long " prognum ,
782 .BI " unsigned long " versnum ,
783 .BI " void (*" dispatch ")(svc_req *, SVCXPRT *),"
784 .BI " unsigned long " protocol );
791 with the service dispatch procedure,
795 is zero, the service is not registered with the
800 is nonzero, then a mapping of the triple
801 .RI [ prognum , versnum , protocol ]
804 is established with the local
814 has the following form:
818 dispatch(struct svc_req *request, SVCXPRT *xprt);
824 routine returns one if it succeeds, and zero otherwise.
827 .B "void svc_run(void);"
830 This routine never returns.
831 It waits for RPC requests to arrive, and calls the appropriate service
835 This procedure is usually waiting for a
837 system call to return.
840 .BI "bool_t svc_sendreply(SVCXPRT *" xprt ", xdrproc_t " outproc \
844 Called by an RPC service's dispatch routine to send the results of a
845 remote procedure call.
848 is the request's associated transport handle;
850 is the XDR routine which is used to encode the results; and
852 is the address of the results.
853 This routine returns one if it succeeds, zero otherwise.
856 .BI "void svc_unregister(unsigned long " prognum ", unsigned long " versnum );
859 Remove all mapping of the double
860 .RI [ prognum , versnum ]
861 to dispatch routines, and of the triple
862 .RI [ prognum , versnum , * ]
866 .BI "void svcerr_auth(SVCXPRT *" xprt ", enum auth_stat " why );
869 Called by a service dispatch routine that refuses to perform
870 a remote procedure call due to an authentication error.
873 .BI "void svcerr_decode(SVCXPRT *" xprt );
876 Called by a service dispatch routine that cannot successfully
877 decode its parameters.
882 .BI "void svcerr_noproc(SVCXPRT *" xprt );
885 Called by a service dispatch routine that does not implement
886 the procedure number that the caller requests.
889 .BI "void svcerr_noprog(SVCXPRT *" xprt );
892 Called when the desired program is not registered with the RPC package.
893 Service implementors usually do not need this routine.
896 .BI "void svcerr_progvers(SVCXPRT *" xprt );
899 Called when the desired version of a program is not registered
900 with the RPC package.
901 Service implementors usually do not need this routine.
904 .BI "void svcerr_systemerr(SVCXPRT *" xprt );
907 Called by a service dispatch routine when it detects a system
908 error not covered by any particular protocol.
909 For example, if a service can no longer allocate storage,
910 it may call this routine.
913 .BI "void svcerr_weakauth(SVCXPRT *" xprt );
916 Called by a service dispatch routine that refuses to perform
917 a remote procedure call due to insufficient authentication parameters.
919 .BR "svcerr_auth(xprt, AUTH_TOOWEAK)" .
922 .BI "SVCXPRT *svcfd_create(int " fd ", unsigned int " sendsize ,
923 .BI " unsigned int " recvsize );
926 Create a service on top of any open file descriptor.
927 Typically, this file descriptor is a connected socket for a stream protocol such
932 indicate sizes for the send and receive buffers.
933 If they are zero, a reasonable default is chosen.
936 .BI "SVCXPRT *svcraw_create(void);"
939 This routine creates a toy RPC
940 service transport, to which it returns a pointer.
941 The transport is really a buffer within the process's address space,
942 so the corresponding RPC client should live in the same address space; see
943 .BR clntraw_create ().
944 This routine allows simulation of RPC and acquisition of RPC
945 overheads (such as round trip times), without any kernel interference.
946 This routine returns NULL if it fails.
949 .BI "SVCXPRT *svctcp_create(int " sock ", unsigned int " send_buf_size ,
950 .BI " unsigned int " recv_buf_size );
953 This routine creates a TCP/IP-based RPC
954 service transport, to which it returns a pointer.
955 The transport is associated with the socket
959 in which case a new socket is created.
960 If the socket is not bound to a local TCP
961 port, then this routine binds it to an arbitrary port.
964 is the transport's socket descriptor, and
966 is the transport's port number.
967 This routine returns NULL if it fails.
968 Since TCP-based RPC uses buffered I/O,
969 users may specify the size of buffers; values of zero
970 choose suitable defaults.
973 .BI "SVCXPRT *svcudp_bufcreate(int " sock ", unsigned int " sendsize ,
974 .BI " unsigned int " recosize );
977 This routine creates a UDP/IP-based RPC
978 service transport, to which it returns a pointer.
979 The transport is associated with the socket
983 in which case a new socket is created.
984 If the socket is not bound to a local UDP
985 port, then this routine binds it to an arbitrary port.
988 is the transport's socket descriptor, and
990 is the transport's port number.
991 This routine returns NULL if it fails.
993 This allows the user to specify the maximum packet size for sending and
994 receiving UDP-based RPC messages.
997 .BI "SVCXPRT *svcudp_create(int " sock );
1000 This call is equivalent to
1001 .I svcudp_bufcreate(sock,SZ,SZ)
1002 for some default size
1006 .BI "bool_t xdr_accepted_reply(XDR *" xdrs ", struct accepted_reply *" ar );
1009 Used for encoding RPC reply messages.
1010 This routine is useful for users who wish to generate
1011 RPC-style messages without using the RPC package.
1014 .BI "bool_t xdr_authunix_parms(XDR *" xdrs ", struct authunix_parms *" aupp );
1017 Used for describing UNIX credentials.
1018 This routine is useful for users
1019 who wish to generate these credentials without using the RPC
1020 authentication package.
1023 .BI "void xdr_callhdr(XDR *" xdrs ", struct rpc_msg *" chdr );
1026 Used for describing RPC call header messages.
1027 This routine is useful for users who wish to generate
1028 RPC-style messages without using the RPC package.
1031 .BI "bool_t xdr_callmsg(XDR *" xdrs ", struct rpc_msg *" cmsg );
1034 Used for describing RPC call messages.
1035 This routine is useful for users who wish to generate RPC-style
1036 messages without using the RPC package.
1039 .BI "bool_t xdr_opaque_auth(XDR *" xdrs ", struct opaque_auth *" ap );
1042 Used for describing RPC authentication information messages.
1043 This routine is useful for users who wish to generate
1044 RPC-style messages without using the RPC package.
1047 .BI "bool_t xdr_pmap(XDR *" xdrs ", struct pmap *" regs );
1050 Used for describing parameters to various
1052 procedures, externally.
1053 This routine is useful for users who wish to generate
1054 these parameters without using the
1059 .BI "bool_t xdr_pmaplist(XDR *" xdrs ", struct pmaplist **" rp );
1062 Used for describing a list of port mappings, externally.
1063 This routine is useful for users who wish to generate
1064 these parameters without using the
1069 .BI "bool_t xdr_rejected_reply(XDR *" xdrs ", struct rejected_reply *" rr );
1072 Used for describing RPC reply messages.
1073 This routine is useful for users who wish to generate
1074 RPC-style messages without using the RPC package.
1077 .BI "bool_t xdr_replymsg(XDR *" xdrs ", struct rpc_msg *" rmsg );
1080 Used for describing RPC reply messages.
1081 This routine is useful for users who wish to generate
1082 RPC style messages without using the RPC package.
1085 .BI "void xprt_register(SVCXPRT *" xprt );
1088 After RPC service transport handles are created,
1089 they should register themselves with the RPC service package.
1090 This routine modifies the global variable
1092 Service implementors usually do not need this routine.
1095 .BI "void xprt_unregister(SVCXPRT *" xprt );
1098 Before an RPC service transport handle is destroyed,
1099 it should unregister itself with the RPC service package.
1100 This routine modifies the global variable
1102 Service implementors usually do not need this routine.
1104 For an explanation of the terms used in this section, see
1111 Interface Attribute Value
1113 .BR auth_destroy (),
1114 .BR authnone_create (),
1116 .BR authunix_create (),
1118 .BR authunix_create_default (),
1121 .BR clnt_broadcast (),
1124 .BR clnt_destroy (),
1127 .BR clnt_control (),
1129 .BR clnt_freeres (),
1132 .BR clnt_pcreateerror (),
1137 .BR clnt_spcreateerror (),
1139 .BR clnt_sperrno (),
1140 .BR clnt_sperror (),
1142 .BR clntraw_create (),
1143 .BR clnttcp_create (),
1145 .BR clntudp_create (),
1147 .BR clntudp_bufcreate (),
1149 .BR get_myaddress (),
1150 .BR pmap_getmaps (),
1152 .BR pmap_getport (),
1153 .BR pmap_rmtcall (),
1161 .BR svc_freeargs (),
1164 .BR svc_getcaller (),
1165 .BR svc_getreqset (),
1168 .BR svc_register (),
1171 .BR svc_sendreply (),
1173 .BR svc_unregister (),
1176 .BR svcerr_decode (),
1177 .BR svcerr_noproc (),
1179 .BR svcerr_noprog (),
1180 .BR svcerr_progvers (),
1182 .BR svcerr_systemerr (),
1183 .BR svcerr_weakauth (),
1185 .BR svcfd_create (),
1186 .BR svcraw_create (),
1188 .BR svctcp_create (),
1190 .BR svcudp_bufcreate (),
1192 .BR svcudp_create (),
1193 .BR xdr_accepted_reply (),
1195 .BR xdr_authunix_parms (),
1200 .BR xdr_opaque_auth (),
1203 .BR xdr_pmaplist (),
1205 .BR xdr_rejected_reply (),
1207 .BR xdr_replymsg (),
1209 .BR xprt_register (),
1210 .BR xprt_unregister ()
1211 T} Thread safety MT-Safe
1215 .\" We don't have an rpc_secure.3 page in the set at the moment -- MTK, 19 Sep 05
1216 .\" .BR rpc_secure (3),
1219 The following manuals:
1221 Remote Procedure Calls: Protocol Specification
1223 Remote Procedure Call Programming Guide
1225 rpcgen Programming Guide
1229 .IR "RPC: Remote Procedure Call Protocol Specification" ,
1230 RFC\ 1050, Sun Microsystems, Inc.,