2 .\" This page was taken from the 4.4BSD-Lite CDROM (BSD license)
4 .\" %%%LICENSE_START(BSD_ONELINE_CDROM)
5 .\" This page was taken from the 4.4BSD-Lite CDROM (BSD license)
8 .\" @(#)rpc.3n 2.4 88/08/08 4.0 RPCSRC; from 1.19 88/06/24 SMI
10 .\" 2007-12-30, mtk, Convert function prototypes to modern C syntax
12 .TH rpc 3 (date) "Linux man-pages (unreleased)"
14 rpc \- library routines for remote procedure calls
17 .RI ( libc ", " \-lc )
18 .SH SYNOPSIS AND DESCRIPTION
19 These routines allow C programs to make procedure
20 calls on other machines across the network.
21 First, the client calls a procedure to send a data packet to the server.
22 Upon receipt of the packet, the server calls a dispatch routine
23 to perform the requested service, and then sends back a reply.
24 Finally, the procedure call returns to the client.
26 .\" We don't have an rpc_secure.3 page at the moment -- MTK, 19 Sep 05
27 .\" Routines that are used for Secure RPC (DES authentication) are described in
28 .\" .BR rpc_secure (3).
29 .\" Secure RPC can be used only if DES encryption is available.
31 To take use of these routines, include the header file
34 The prototypes below make use of the following types:
38 .BI "typedef int " bool_t ;
40 .BI "typedef bool_t (*" xdrproc_t ")(XDR *, void *, ...);"
42 .BI "typedef bool_t (*" resultproc_t ")(caddr_t " resp ,
43 .BI " struct sockaddr_in *" raddr );
47 See the header files for the declarations of the
56 .BI "void auth_destroy(AUTH *" auth );
59 A macro that destroys the authentication information associated with
61 Destruction usually involves deallocation of private data structures.
64 is undefined after calling
68 .B AUTH *authnone_create(void);
71 Create and return an RPC
72 authentication handle that passes nonusable authentication
73 information with each remote procedure call.
74 This is the default authentication used by RPC.
77 .BI "AUTH *authunix_create(char *" host ", uid_t " uid ", gid_t " gid ,
78 .BI " int " len ", gid_t " aup_gids [. len ]);
81 Create and return an RPC authentication handle that contains
82 authentication information.
85 is the name of the machine on which the information was created;
87 is the user's user ID;
89 is the user's current group ID;
93 refer to a counted array of groups to which the user belongs.
94 It is easy to impersonate a user.
97 .B AUTH *authunix_create_default(void);
101 .BR authunix_create ()
102 with the appropriate parameters.
105 .BI "int callrpc(char *" host ", unsigned long " prognum ,
106 .BI " unsigned long " versnum ", unsigned long " procnum ,
107 .BI " xdrproc_t " inproc ", const char *" in ,
108 .BI " xdrproc_t " outproc ", char *" out );
111 Call the remote procedure associated with
120 is the address of the procedure's argument(s), and
122 is the address of where to place the result(s);
124 is used to encode the procedure's parameters, and
126 is used to decode the procedure's results.
127 This routine returns zero if it succeeds, or the value of
129 cast to an integer if it fails.
132 is handy for translating failure statuses into messages.
134 Warning: calling remote procedures with this routine
135 uses UDP/IP as a transport; see
136 .BR clntudp_create ()
138 You do not have control of timeouts or authentication using this routine.
141 .BI "enum clnt_stat clnt_broadcast(unsigned long " prognum ,
142 .BI " unsigned long " versnum ", unsigned long " procnum ,
143 .BI " xdrproc_t " inproc ", char *" in ,
144 .BI " xdrproc_t " outproc ", char *" out ,
145 .BI " resultproc_t " eachresult );
150 except the call message is broadcast to all locally
151 connected broadcast nets.
152 Each time it receives a response, this routine calls
158 .BI "eachresult(char *" out ", struct sockaddr_in *" addr );
167 .BR clnt_broadcast (),
168 except that the remote procedure's output is decoded there;
170 points to the address of the machine that sent the results.
174 .BR clnt_broadcast ()
175 waits for more replies; otherwise it returns with appropriate status.
177 Warning: broadcast sockets are limited in size to the
178 maximum transfer unit of the data link.
179 For ethernet, this value is 1500 bytes.
182 .BI "enum clnt_stat clnt_call(CLIENT *" clnt ", unsigned long " procnum ,
183 .BI " xdrproc_t " inproc ", char *" in ,
184 .BI " xdrproc_t " outproc ", char *" out ,
185 .BI " struct timeval " tout );
188 A macro that calls the remote procedure
190 associated with the client handle,
192 which is obtained with an RPC client creation routine such as
196 is the address of the procedure's argument(s), and
198 is the address of where to place the result(s);
200 is used to encode the procedure's parameters, and
202 is used to decode the procedure's results;
204 is the time allowed for results to come back.
207 .BI "clnt_destroy(CLIENT *" clnt );
210 A macro that destroys the client's RPC handle.
211 Destruction usually involves deallocation
212 of private data structures, including
217 is undefined after calling
219 If the RPC library opened the associated socket, it will close it also.
220 Otherwise, the socket remains open.
223 .BI "CLIENT *clnt_create(const char *" host ", unsigned long " prog ,
224 .BI " unsigned long " vers ", const char *" proto );
227 Generic client creation routine.
229 identifies the name of the remote host where the server is located.
231 indicates which kind of transport protocol to use.
232 The currently supported values for this field are \[lq]udp\[rq]
234 Default timeouts are set, but can be modified using
237 Warning: using UDP has its shortcomings.
238 Since UDP-based RPC messages can hold only up to 8 Kbytes of encoded data,
239 this transport cannot be used for procedures that take
240 large arguments or return huge results.
243 .BI "bool_t clnt_control(CLIENT *" cl ", int " req ", char *" info );
246 A macro used to change or retrieve various information
247 about a client object.
249 indicates the type of operation, and
251 is a pointer to the information.
252 For both UDP and TCP, the supported values of
254 and their argument types and what they do are:
258 \fBCLSET_TIMEOUT\fP \fIstruct timeval\fP // set total timeout
259 \fBCLGET_TIMEOUT\fP \fIstruct timeval\fP // get total timeout
263 Note: if you set the timeout using
265 the timeout parameter passed to
267 will be ignored in all future calls.
271 \fBCLGET_SERVER_ADDR\fP \fIstruct sockaddr_in\fP
272 // get server\[aq]s address
276 The following operations are valid for UDP only:
280 \fBCLSET_RETRY_TIMEOUT\fP \fIstruct timeval\fP // set the retry timeout
281 \fBCLGET_RETRY_TIMEOUT\fP \fIstruct timeval\fP // get the retry timeout
285 The retry timeout is the time that "UDP RPC"
286 waits for the server to reply before
287 retransmitting the request.
290 .BI "clnt_freeres(CLIENT * " clnt ", xdrproc_t " outproc ", char *" out );
293 A macro that frees any data allocated by the RPC/XDR
294 system when it decoded the results of an RPC call.
297 is the address of the results, and
299 is the XDR routine describing the results.
300 This routine returns one if the results were successfully freed,
304 .BI "void clnt_geterr(CLIENT *" clnt ", struct rpc_err *" errp );
307 A macro that copies the error structure out of the client
308 handle to the structure at address
312 .BI "void clnt_pcreateerror(const char *" s );
315 Print a message to standard error indicating why a client RPC
316 handle could not be created.
317 The message is prepended with string
322 .BR clntraw_create (),
323 .BR clnttcp_create (),
325 .BR clntudp_create ()
329 .BI "void clnt_perrno(enum clnt_stat " stat );
332 Print a message to standard error corresponding
333 to the condition indicated by
339 .BI "clnt_perror(CLIENT *" clnt ", const char *" s );
342 Print a message to standard error indicating why an RPC call failed;
344 is the handle used to do the call.
345 The message is prepended with string
352 .BI "char *clnt_spcreateerror(const char *" s );
356 .BR clnt_pcreateerror (),
357 except that it returns a string instead of printing to the standard error.
359 Bugs: returns pointer to static data that is overwritten on each call.
362 .BI "char *clnt_sperrno(enum clnt_stat " stat );
365 Take the same arguments as
367 but instead of sending a message to the standard error indicating why an RPC
368 call failed, return a pointer to a string which contains the message.
369 The string ends with a NEWLINE.
374 if the program does not have a standard error (as a program
375 running as a server quite likely does not), or if the programmer
376 does not want the message to be output with
378 or if a message format different than that supported by
384 .BR clnt_spcreateerror (),
386 returns pointer to static data, but the
387 result will not get overwritten on each call.
390 .BI "char *clnt_sperror(CLIENT *" rpch ", const char *" s );
397 it returns a string instead of printing to standard error.
399 Bugs: returns pointer to static data that is overwritten on each call.
402 .BI "CLIENT *clntraw_create(unsigned long " prognum \
403 ", unsigned long " versnum );
406 This routine creates a toy RPC client for the remote program
410 The transport used to pass messages to the service is
411 actually a buffer within the process's address space, so the
412 corresponding RPC server should live in the same address space; see
413 .BR svcraw_create ().
414 This allows simulation of RPC and acquisition of RPC
415 overheads, such as round trip times, without any kernel interference.
416 This routine returns NULL if it fails.
419 .BI "CLIENT *clnttcp_create(struct sockaddr_in *" addr ,
420 .BI " unsigned long " prognum ", unsigned long " versnum ,
421 .BI " int *" sockp ", unsigned int " sendsz \
422 ", unsigned int " recvsz );
425 This routine creates an RPC client for the remote program
429 the client uses TCP/IP as a transport.
430 The remote program is located at Internet address
433 .\"The following inline font conversion is necessary for the hyphen indicator
435 is zero, then it is set to the actual port that the remote
436 program is listening on (the remote
438 service is consulted for this information).
441 is a socket; if it is
443 then this routine opens a new one and sets
445 Since TCP-based RPC uses buffered I/O,
446 the user may specify the size of the send and receive buffers
451 values of zero choose suitable defaults.
452 This routine returns NULL if it fails.
455 .BI "CLIENT *clntudp_create(struct sockaddr_in *" addr ,
456 .BI " unsigned long " prognum ", unsigned long " versnum ,
457 .BI " struct timeval " wait ", int *" sockp );
460 This routine creates an RPC client for the remote program
464 the client uses use UDP/IP as a transport.
465 The remote program is located at Internet address
469 is zero, then it is set to actual port that the remote
470 program is listening on (the remote
472 service is consulted for this information).
475 is a socket; if it is
477 then this routine opens a new one and sets
479 The UDP transport resends the call message in intervals of
481 time until a response is received or until the call times out.
482 The total time for the call to time out is specified by
485 Warning: since UDP-based RPC messages can hold only up to 8 Kbytes
486 of encoded data, this transport cannot be used for procedures
487 that take large arguments or return huge results.
490 .BI "CLIENT *clntudp_bufcreate(struct sockaddr_in *" addr ,
491 .BI " unsigned long " prognum ", unsigned long " versnum ,
492 .BI " struct timeval " wait ", int *" sockp ,
493 .BI " unsigned int " sendsize ", unsigned int "recosize );
496 This routine creates an RPC client for the remote program
500 the client uses use UDP/IP as a transport.
501 The remote program is located at Internet address
505 is zero, then it is set to actual port that the remote
506 program is listening on (the remote
508 service is consulted for this information).
511 is a socket; if it is
513 then this routine opens a new one and sets
515 The UDP transport resends the call message in intervals of
517 time until a response is received or until the call times out.
518 The total time for the call to time out is specified by
521 This allows the user to specify the maximum packet
522 size for sending and receiving UDP-based RPC messages.
525 .BI "void get_myaddress(struct sockaddr_in *" addr );
528 Stuff the machine's IP address into
530 without consulting the library routines that deal with
532 The port number is always set to
533 .BR htons(PMAPPORT) .
536 .BI "struct pmaplist *pmap_getmaps(struct sockaddr_in *" addr );
539 A user interface to the
541 service, which returns a list of the current RPC
542 program-to-port mappings on the host located at IP address
544 This routine can return NULL.
550 .BI "unsigned short pmap_getport(struct sockaddr_in *" addr ,
551 .BI " unsigned long " prognum ", unsigned long " versnum ,
552 .BI " unsigned int " protocol );
555 A user interface to the
557 service, which returns the port number
558 on which waits a service that supports program number
562 and speaks the transport protocol associated with
570 A return value of zero means that the mapping does not exist
571 or that the RPC system failed to contact the remote
574 In the latter case, the global variable
576 contains the RPC status.
579 .BI "enum clnt_stat pmap_rmtcall(struct sockaddr_in *" addr ,
580 .BI " unsigned long " prognum ", unsigned long " versnum ,
581 .BI " unsigned long " procnum ,
582 .BI " xdrproc_t " inproc ", char *" in ,
583 .BI " xdrproc_t " outproc ", char *" out ,
584 .BI " struct timeval " tout ", unsigned long *" portp );
587 A user interface to the
589 service, which instructs
591 on the host at IP address
593 to make an RPC call on your behalf to a procedure on that host.
596 will be modified to the program's port number if the procedure succeeds.
597 The definitions of other parameters are discussed
602 This procedure should be used for a \[lq]ping\[rq] and nothing else.
604 .BR clnt_broadcast ().
607 .BI "bool_t pmap_set(unsigned long " prognum ", unsigned long " versnum ,
608 .BI " int " protocol ", unsigned short " port );
611 A user interface to the
613 service, which establishes a mapping between the triple
614 .RI [ prognum , versnum , protocol ]
626 This routine returns one if it succeeds, zero otherwise.
627 Automatically done by
631 .BI "bool_t pmap_unset(unsigned long " prognum ", unsigned long " versnum );
634 A user interface to the
636 service, which destroys all mapping between the triple
637 .RI [ prognum , versnum , * ]
643 This routine returns one if it succeeds, zero otherwise.
646 .BI "int registerrpc(unsigned long " prognum ", unsigned long " versnum ,
647 .BI " unsigned long " procnum ", char *(*" procname ")(char *),"
648 .BI " xdrproc_t " inproc ", xdrproc_t " outproc );
653 with the RPC service package.
654 If a request arrives for program
661 is called with a pointer to its parameter(s);
663 should return a pointer to its static result(s);
665 is used to decode the parameters while
667 is used to encode the results.
668 This routine returns zero if the registration succeeded, \-1 otherwise.
670 Warning: remote procedures registered in this form
671 are accessed using the UDP/IP transport; see
676 .BI "struct rpc_createerr " rpc_createerr ;
679 A global variable whose value is set by any RPC client creation routine
680 that does not succeed.
682 .BR clnt_pcreateerror ()
683 to print the reason why.
686 .BI "void svc_destroy(SVCXPRT *" xprt );
689 A macro that destroys the RPC service transport handle,
691 Destruction usually involves deallocation
692 of private data structures, including
697 is undefined after calling this routine.
700 .BI "fd_set " svc_fdset ;
703 A global variable reflecting the RPC service side's
704 read file descriptor bit mask; it is suitable as a parameter to the
707 This is of interest only if a service implementor does their own
708 asynchronous event processing, instead of calling
710 This variable is read-only (do not pass its address to
712 yet it may change after calls to
714 or any creation routines.
722 but limited to 32 file descriptors.
723 This interface is obsoleted by
727 .BI "svc_freeargs(SVCXPRT *" xprt ", xdrproc_t " inproc ", char *" in );
730 A macro that frees any data allocated by the RPC/XDR
731 system when it decoded the arguments to a service procedure using
733 This routine returns 1 if the results were successfully freed,
737 .BI "svc_getargs(SVCXPRT *" xprt ", xdrproc_t " inproc ", char *" in );
740 A macro that decodes the arguments of an RPC request
741 associated with the RPC service transport handle,
745 is the address where the arguments will be placed;
747 is the XDR routine used to decode the arguments.
748 This routine returns one if decoding succeeds, and zero otherwise.
751 .BI "struct sockaddr_in *svc_getcaller(SVCXPRT *" xprt );
754 The approved way of getting the network address of the caller
755 of a procedure associated with the RPC service transport handle,
759 .BI "void svc_getreqset(fd_set *" rdfds );
762 This routine is of interest only if a service implementor does not call
764 but instead implements custom asynchronous event processing.
765 It is called when the
767 system call has determined that an RPC request has arrived on some
770 is the resultant read file descriptor bit mask.
771 The routine returns when all sockets associated with the value of
776 .BI "void svc_getreq(int " rdfds );
780 .BR svc_getreqset (),
781 but limited to 32 file descriptors.
782 This interface is obsoleted by
783 .BR svc_getreqset ().
786 .BI "bool_t svc_register(SVCXPRT *" xprt ", unsigned long " prognum ,
787 .BI " unsigned long " versnum ,
788 .BI " void (*" dispatch ")(struct svc_req *, SVCXPRT *),"
789 .BI " unsigned long " protocol );
796 with the service dispatch procedure,
800 is zero, the service is not registered with the
805 is nonzero, then a mapping of the triple
806 .RI [ prognum , versnum , protocol ]
809 is established with the local
819 has the following form:
823 dispatch(struct svc_req *request, SVCXPRT *xprt);
829 routine returns one if it succeeds, and zero otherwise.
832 .B "void svc_run(void);"
835 This routine never returns.
836 It waits for RPC requests to arrive, and calls the appropriate service
840 This procedure is usually waiting for a
842 system call to return.
845 .BI "bool_t svc_sendreply(SVCXPRT *" xprt ", xdrproc_t " outproc \
849 Called by an RPC service's dispatch routine to send the results of a
850 remote procedure call.
853 is the request's associated transport handle;
855 is the XDR routine which is used to encode the results; and
857 is the address of the results.
858 This routine returns one if it succeeds, zero otherwise.
861 .BI "void svc_unregister(unsigned long " prognum ", unsigned long " versnum );
864 Remove all mapping of the double
865 .RI [ prognum , versnum ]
866 to dispatch routines, and of the triple
867 .RI [ prognum , versnum , * ]
871 .BI "void svcerr_auth(SVCXPRT *" xprt ", enum auth_stat " why );
874 Called by a service dispatch routine that refuses to perform
875 a remote procedure call due to an authentication error.
878 .BI "void svcerr_decode(SVCXPRT *" xprt );
881 Called by a service dispatch routine that cannot successfully
882 decode its parameters.
887 .BI "void svcerr_noproc(SVCXPRT *" xprt );
890 Called by a service dispatch routine that does not implement
891 the procedure number that the caller requests.
894 .BI "void svcerr_noprog(SVCXPRT *" xprt );
897 Called when the desired program is not registered with the RPC package.
898 Service implementors usually do not need this routine.
901 .BI "void svcerr_progvers(SVCXPRT *" xprt ", unsigned long " low_vers ,
902 .BI " unsigned long " high_vers );
905 Called when the desired version of a program is not registered
906 with the RPC package.
907 Service implementors usually do not need this routine.
910 .BI "void svcerr_systemerr(SVCXPRT *" xprt );
913 Called by a service dispatch routine when it detects a system
914 error not covered by any particular protocol.
915 For example, if a service can no longer allocate storage,
916 it may call this routine.
919 .BI "void svcerr_weakauth(SVCXPRT *" xprt );
922 Called by a service dispatch routine that refuses to perform
923 a remote procedure call due to insufficient authentication parameters.
925 .BR "svcerr_auth(xprt, AUTH_TOOWEAK)" .
928 .BI "SVCXPRT *svcfd_create(int " fd ", unsigned int " sendsize ,
929 .BI " unsigned int " recvsize );
932 Create a service on top of any open file descriptor.
933 Typically, this file descriptor is a connected socket for a stream protocol such
938 indicate sizes for the send and receive buffers.
939 If they are zero, a reasonable default is chosen.
942 .B SVCXPRT *svcraw_create(void);
945 This routine creates a toy RPC
946 service transport, to which it returns a pointer.
947 The transport is really a buffer within the process's address space,
948 so the corresponding RPC client should live in the same address space; see
949 .BR clntraw_create ().
950 This routine allows simulation of RPC and acquisition of RPC
951 overheads (such as round trip times), without any kernel interference.
952 This routine returns NULL if it fails.
955 .BI "SVCXPRT *svctcp_create(int " sock ", unsigned int " send_buf_size ,
956 .BI " unsigned int " recv_buf_size );
959 This routine creates a TCP/IP-based RPC
960 service transport, to which it returns a pointer.
961 The transport is associated with the socket
965 in which case a new socket is created.
966 If the socket is not bound to a local TCP
967 port, then this routine binds it to an arbitrary port.
970 is the transport's socket descriptor, and
972 is the transport's port number.
973 This routine returns NULL if it fails.
974 Since TCP-based RPC uses buffered I/O,
975 users may specify the size of buffers; values of zero
976 choose suitable defaults.
979 .BI "SVCXPRT *svcudp_bufcreate(int " sock ", unsigned int " sendsize ,
980 .BI " unsigned int " recosize );
983 This routine creates a UDP/IP-based RPC
984 service transport, to which it returns a pointer.
985 The transport is associated with the socket
989 in which case a new socket is created.
990 If the socket is not bound to a local UDP
991 port, then this routine binds it to an arbitrary port.
994 is the transport's socket descriptor, and
996 is the transport's port number.
997 This routine returns NULL if it fails.
999 This allows the user to specify the maximum packet size for sending and
1000 receiving UDP-based RPC messages.
1003 .BI "SVCXPRT *svcudp_create(int " sock );
1006 This call is equivalent to
1007 .I svcudp_bufcreate(sock,SZ,SZ)
1008 for some default size
1012 .BI "bool_t xdr_accepted_reply(XDR *" xdrs ", struct accepted_reply *" ar );
1015 Used for encoding RPC reply messages.
1016 This routine is useful for users who wish to generate
1017 RPC-style messages without using the RPC package.
1020 .BI "bool_t xdr_authunix_parms(XDR *" xdrs ", struct authunix_parms *" aupp );
1023 Used for describing UNIX credentials.
1024 This routine is useful for users
1025 who wish to generate these credentials without using the RPC
1026 authentication package.
1029 .BI "void xdr_callhdr(XDR *" xdrs ", struct rpc_msg *" chdr );
1032 Used for describing RPC call header messages.
1033 This routine is useful for users who wish to generate
1034 RPC-style messages without using the RPC package.
1037 .BI "bool_t xdr_callmsg(XDR *" xdrs ", struct rpc_msg *" cmsg );
1040 Used for describing RPC call messages.
1041 This routine is useful for users who wish to generate RPC-style
1042 messages without using the RPC package.
1045 .BI "bool_t xdr_opaque_auth(XDR *" xdrs ", struct opaque_auth *" ap );
1048 Used for describing RPC authentication information messages.
1049 This routine is useful for users who wish to generate
1050 RPC-style messages without using the RPC package.
1053 .BI "bool_t xdr_pmap(XDR *" xdrs ", struct pmap *" regs );
1056 Used for describing parameters to various
1058 procedures, externally.
1059 This routine is useful for users who wish to generate
1060 these parameters without using the
1065 .BI "bool_t xdr_pmaplist(XDR *" xdrs ", struct pmaplist **" rp );
1068 Used for describing a list of port mappings, externally.
1069 This routine is useful for users who wish to generate
1070 these parameters without using the
1075 .BI "bool_t xdr_rejected_reply(XDR *" xdrs ", struct rejected_reply *" rr );
1078 Used for describing RPC reply messages.
1079 This routine is useful for users who wish to generate
1080 RPC-style messages without using the RPC package.
1083 .BI "bool_t xdr_replymsg(XDR *" xdrs ", struct rpc_msg *" rmsg );
1086 Used for describing RPC reply messages.
1087 This routine is useful for users who wish to generate
1088 RPC style messages without using the RPC package.
1091 .BI "void xprt_register(SVCXPRT *" xprt );
1094 After RPC service transport handles are created,
1095 they should register themselves with the RPC service package.
1096 This routine modifies the global variable
1098 Service implementors usually do not need this routine.
1101 .BI "void xprt_unregister(SVCXPRT *" xprt );
1104 Before an RPC service transport handle is destroyed,
1105 it should unregister itself with the RPC service package.
1106 This routine modifies the global variable
1108 Service implementors usually do not need this routine.
1110 For an explanation of the terms used in this section, see
1118 Interface Attribute Value
1120 .BR auth_destroy (),
1121 .BR authnone_create (),
1122 .BR authunix_create (),
1123 .BR authunix_create_default (),
1125 .BR clnt_broadcast (),
1127 .BR clnt_destroy (),
1129 .BR clnt_control (),
1130 .BR clnt_freeres (),
1132 .BR clnt_pcreateerror (),
1135 .BR clnt_spcreateerror (),
1136 .BR clnt_sperrno (),
1137 .BR clnt_sperror (),
1138 .BR clntraw_create (),
1139 .BR clnttcp_create (),
1140 .BR clntudp_create (),
1141 .BR clntudp_bufcreate (),
1142 .BR get_myaddress (),
1143 .BR pmap_getmaps (),
1144 .BR pmap_getport (),
1145 .BR pmap_rmtcall (),
1150 .BR svc_freeargs (),
1152 .BR svc_getcaller (),
1153 .BR svc_getreqset (),
1155 .BR svc_register (),
1157 .BR svc_sendreply (),
1158 .BR svc_unregister (),
1160 .BR svcerr_decode (),
1161 .BR svcerr_noproc (),
1162 .BR svcerr_noprog (),
1163 .BR svcerr_progvers (),
1164 .BR svcerr_systemerr (),
1165 .BR svcerr_weakauth (),
1166 .BR svcfd_create (),
1167 .BR svcraw_create (),
1168 .BR svctcp_create (),
1169 .BR svcudp_bufcreate (),
1170 .BR svcudp_create (),
1171 .BR xdr_accepted_reply (),
1172 .BR xdr_authunix_parms (),
1175 .BR xdr_opaque_auth (),
1177 .BR xdr_pmaplist (),
1178 .BR xdr_rejected_reply (),
1179 .BR xdr_replymsg (),
1180 .BR xprt_register (),
1181 .BR xprt_unregister ()
1182 T} Thread safety MT-Safe
1188 .\" We don't have an rpc_secure.3 page in the set at the moment -- MTK, 19 Sep 05
1189 .\" .BR rpc_secure (3),
1192 The following manuals:
1194 Remote Procedure Calls: Protocol Specification
1196 Remote Procedure Call Programming Guide
1198 rpcgen Programming Guide
1202 .IR "RPC: Remote Procedure Call Protocol Specification" ,
1203 RFC\ 1050, Sun Microsystems, Inc.,