1RPC(3) Library Functions 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
10 machines across the network. First, the client calls a procedure to
11 send a data packet to the server. Upon receipt of the packet, the
12 server calls a dispatch routine to perform the requested service, and
13 then sends back a reply. Finally, the procedure call returns to the
14 client.
15 #include <rpc/rpc.h>
17 void
19 auth_destroy(auth)
20 AUTH *auth;
21 A macro that destroys the authentication information associated
23 with auth. Destruction usually involves deallocation of private
24 data structures. The use of auth is undefined after calling
25 auth_destroy().
26 AUTH *
28 authnone_create()
29 Create and returns an RPC authentication handle that passes
31 nonusable authentication information with each remote procedure
32 call. This is the default authentication used by RPC.
33 AUTH *
35 authunix_create(host, uid, gid, len, aup_gids)
36 char *host;
37 int uid, gid, len, *aup.gids;
38 Create and return an RPC authentication handle that contains
40 authentication information. The parameter host is the name of
41 the machine on which the information was created; uid is the
42 user's user ID ; gid is the user's current group ID ; len and
43 aup_gids refer to a counted array of groups to which the user
44 belongs. It is easy to impersonate a user.
45 AUTH *
47 authunix_create_default()
48 Calls authunix_create() with the appropriate parameters.
50 callrpc(host, prognum, versnum, procnum, inproc, in, outproc, out)
52 char *host;
53 u_long prognum, versnum, procnum;
54 char *in, *out;
55 xdrproc_t inproc, outproc;
56 Call the remote procedure associated with prognum, versnum, and
58 procnum on the machine, host. The parameter in is the address
59 of the procedure's argument(s), and out is the address of where
60 to place the result(s); inproc is used to encode the procedure's
61 parameters, and outproc is used to decode the procedure's
62 results. This routine returns zero if it succeeds, or the value
63 of enum clnt_stat cast to an integer if it fails. The routine
64 clnt_perrno() is handy for translating failure statuses into
65 messages.
66 Warning: calling remote procedures with this routine uses UDP/IP
68 as a transport; see clntudp_create() for restrictions. You do
69 not have control of timeouts or authentication using this rou‐
70 tine.
71 enum clnt_stat
73 clnt_broadcast(prognum, versnum, procnum, inproc, in, outproc, out, eachresult)
74 u_long prognum, versnum, procnum;
75 char *in, *out;
76 xdrproc_t inproc, outproc;
77 resultproc_t eachresult;
78 Like callrpc(), except the call message is broadcast to all
80 locally connected broadcast nets. Each time it receives a
81 response, this routine calls eachresult(), whose form is:
82 eachresult(out, addr)
84 char *out;
85 struct sockaddr_in *addr;
86 where out is the same as out passed to clnt_broadcast(), except
88 that the remote procedure's output is decoded there; addr points
89 to the address of the machine that sent the results. If eachre‐
90 sult() returns zero, clnt_broadcast() waits for more replies;
91 otherwise it returns with appropriate status.
92 Warning: broadcast sockets are limited in size to the maximum
94 transfer unit of the data link. For ethernet, this value is 1500
95 bytes.
96 enum clnt_stat
98 clnt_call(clnt, procnum, inproc, in, outproc, out, tout)
99 CLIENT *clnt;
100 u_long
101 procnum;
102 xdrproc_t inproc, outproc;
103 char *in, *out;
104 struct timeval tout;
105 A macro that calls the remote procedure procnum associated with
107 the client handle, clnt, which is obtained with an RPC client
108 creation routine such as clnt_create(). The parameter in is the
109 address of the procedure's argument(s), and out is the address
110 of where to place the result(s); inproc is used to encode the
111 procedure's parameters, and outproc is used to decode the proce‐
112 dure's results; tout is the time allowed for results to come
113 back.
114 clnt_destroy(clnt)
116 CLIENT *clnt;
117 A macro that destroys the client's RPC handle. Destruction usu‐
119 ally involves deallocation of private data structures, including
120 clnt itself. Use of clnt is undefined after calling
121 clnt_destroy(). If the RPC library opened the associated
122 socket, it will close it also. Otherwise, the socket remains
123 open.
124 CLIENT *
126 clnt_create(host, prog, vers, proto)
127 char *host;
128 u_long prog, vers;
129 char *proto;
130 Generic client creation routine. host identifies the name of
132 the remote host where the server is located. proto indicates
133 which kind of transport protocol to use. The currently supported
134 values for this field are “udp” and “tcp”. Default timeouts are
135 set, but can be modified using clnt_control().
136 Warning: Using UDP has its shortcomings. Since UDP-based RPC
138 messages can only hold up to 8 Kbytes of encoded data, this
139 transport cannot be used for procedures that take large argu‐
140 ments or return huge results.
141 bool_t
143 clnt_control(cl, req, info)
144 CLIENT *cl;
145 char *info;
146 A macro used to change or retrieve various information about a
148 client object. req indicates the type of operation, and info is
149 a pointer to the information. For both UDP and TCP, the sup‐
150 ported values of req and their argument types and what they do
151 are:
152 CLSET_TIMEOUT struct timeval set total timeout
154 CLGET_TIMEOUT struct timeval get total timeout
155 Note: if you set the timeout using clnt_control(), the timeout
157 parameter passed to clnt_call() will be ignored in all future
158 calls.
159 CLGET_SERVER_ADDR struct sockaddr_in get server's address
161 The following operations are valid for UDP only:
163 CLSET_RETRY_TIMEOUT struct timeval set the retry timeout
165 CLGET_RETRY_TIMEOUT struct timeval get the retry timeout
166 The retry timeout is the time that UDP RPC waits for the server
168 to reply before retransmitting the request.
169 clnt_freeres(clnt, outproc, out)
171 CLIENT *clnt;
172 xdrproc_t outproc;
173 char *out;
174 A macro that frees any data allocated by the RPC/XDR system when
176 it decoded the results of an RPC call. The parameter out is the
177 address of the results, and outproc is the XDR routine describ‐
178 ing the results. This routine returns one if the results were
179 successfully freed, and zero otherwise.
180 void
182 clnt_geterr(clnt, errp)
183 CLIENT *clnt;
184 struct rpc_err *errp;
185 A macro that copies the error structure out of the client handle
187 to the structure at address errp.
188 void
190 clnt_pcreateerror(s)
191 char *s;
192 Print a message to standard error indicating why a client RPC
194 handle could not be created. The message is prepended with
195 string s and a colon. Used when a clnt_create(), clntraw_cre‐
196 ate(), clnttcp_create(), or clntudp_create() call fails.
197 void
199 clnt_perrno(stat)
200 enum clnt_stat stat;
201 Print a message to standard error corresponding to the condition
203 indicated by stat. Used after callrpc().
204 clnt_perror(clnt, s)
206 CLIENT *clnt;
207 char *s;
208 Print a message to standard error indicating why an RPC call
210 failed; clnt is the handle used to do the call. The message is
211 prepended with string s and a colon. Used after clnt_call().
212 char *
214 clnt_spcreateerror
215 char *s;
216 Like clnt_pcreateerror(), except that it returns a string
218 instead of printing to the standard error.
219 Bugs: returns pointer to static data that is overwritten on each
221 call.
222 char *
224 clnt_sperrno(stat)
225 enum clnt_stat stat;
226 Take the same arguments as clnt_perrno(), but instead of sending
228 a message to the standard error indicating why an RPC call
229 failed, return a pointer to a string which contains the message.
230 The string ends with a NEWLINE.
231 clnt_sperrno() is used instead of clnt_perrno() if the program
233 does not have a standard error (as a program running as a server
234 quite likely does not), or if the programmer does not want the
235 message to be output with printf(), or if a message format dif‐
236 ferent than that supported by clnt_perrno() is to be used.
237 Note: unlike clnt_sperror() and clnt_spcreaterror(), clnt_sper‐
238 rno() returns pointer to static data, but the result will not
239 get overwritten on each call.
240 char *
242 clnt_sperror(rpch, s)
243 CLIENT *rpch;
244 char *s;
245 Like clnt_perror(), except that (like clnt_sperrno()) it returns
247 a string instead of printing to standard error.
248 Bugs: returns pointer to static data that is overwritten on each
250 call.
251 CLIENT *
253 clntraw_create(prognum, versnum)
254 u_long prognum, versnum;
255 This routine creates a toy RPC client for the remote program
257 prognum, version versnum. The transport used to pass messages
258 to the service is actually a buffer within the process's address
259 space, so the corresponding RPC server should live in the same
260 address space; see svcraw_create(). This allows simulation of
261 RPC and acquisition of RPC overheads, such as round trip times,
262 without any kernel interference. This routine returns NULL if it
263 fails.
264 CLIENT *
266 clnttcp_create(addr, prognum, versnum, sockp, sendsz, recvsz)
267 struct sockaddr_in *addr;
268 u_long prognum, versnum;
269 int *sockp;
270 u_int sendsz, recvsz;
271 This routine creates an RPC client for the remote program
273 prognum, version versnum; the client uses TCP/IP as a transport.
274 The remote program is located at Internet address *addr. If
275 addr->sin_port is zero, then it is set to the actual port that
276 the remote program is listening on (the remote portmap service
277 is consulted for this information). The parameter sockp is a
278 socket; if it is RPC_ANYSOCK, then this routine opens a new one
279 and sets sockp. Since TCP-based RPC uses buffered I/O , the
280 user may specify the size of the send and receive buffers with
281 the parameters sendsz and recvsz; values of zero choose suitable
282 defaults. This routine returns NULL if it fails.
283 CLIENT *
285 clntudp_create(addr, prognum, versnum, wait, sockp)
286 struct sockaddr_in *addr;
287 u_long prognum, versnum;
288 struct timeval wait;
289 int *sockp;
290 This routine creates an RPC client for the remote program
292 prognum, version versnum; the client uses use UDP/IP as a trans‐
293 port. The remote program is located at Internet address addr.
294 If addr->sin_port is zero, then it is set to actual port that
295 the remote program is listening on (the remote portmap service
296 is consulted for this information). The parameter sockp is a
297 socket; if it is RPC_ANYSOCK, then this routine opens a new one
298 and sets sockp. The UDP transport resends the call message in
299 intervals of wait time until a response is received or until the
300 call times out. The total time for the call to time out is
301 specified by clnt_call().
302 Warning: since UDP-based RPC messages can only hold up to 8
304 Kbytes of encoded data, this transport cannot be used for proce‐
305 dures that take large arguments or return huge results.
306 CLIENT *
308 clntudp_bufcreate(addr, prognum, versnum, wait, sockp, sendsize, recosize)
309 struct sockaddr_in *addr;
310 u_long prognum, versnum;
311 struct timeval wait;
312 int *sockp;
313 unsigned int sendsize;
314 unsigned int recosize;
315 This routine creates an RPC client for the remote program
317 prognum, on versnum; the client uses use UDP/IP as a transport.
318 The remote program is located at Internet address addr. If
319 addr->sin_port is zero, then it is set to actual port that the
320 remote program is listening on (the remote portmap service is
321 consulted for this information). The parameter sockp is a
322 socket; if it is RPC_ANYSOCK, then this routine opens a new one
323 and sets sockp. The UDP transport resends the call message in
324 intervals of wait time until a response is received or until the
325 call times out. The total time for the call to time out is
326 specified by clnt_call().
327 This allows the user to specify the maximum packet size for
329 sending and receiving UDP-based RPC messages.
330 void
332 get_myaddress(addr)
333 struct sockaddr_in *addr;
334 Stuff the machine's IP address into *addr, without consulting
336 the library routines that deal with /etc/hosts. The port number
337 is always set to htons(PMAPPORT).
338 struct pmaplist *
340 pmap_getmaps(addr)
341 struct sockaddr_in *addr;
342 A user interface to the portmap service, which returns a list of
344 the current RPC program-to-port mappings on the host located at
345 IP address *addr. This routine can return NULL . The command
346 `rpcinfo -p' uses this routine.
347 u_short
349 pmap_getport(addr, prognum, versnum, protocol)
350 struct sockaddr_in *addr;
351 u_long prognum, versnum, protocol;
352 A user interface to the portmap service, which returns the port
354 number on which waits a service that supports program number
355 prognum, version versnum, and speaks the transport protocol
356 associated with protocol. The value of protocol is most likely
357 IPPROTO_UDP or IPPROTO_TCP. A return value of zero means that
358 the mapping does not exist or that the RPC system failed to con‐
359 tact the remote portmap service. In the latter case, the global
360 variable rpc_createerr() contains the RPC status.
361 enum clnt_stat
363 pmap_rmtcall(addr, prognum, versnum, procnum, inproc, in, outproc, out, tout, portp)
364 struct sockaddr_in *addr;
365 u_long prognum, versnum, procnum;
366 char *in, *out;
367 xdrproc_t inproc, outproc;
368 struct timeval tout;
369 u_long *portp;
370 A user interface to the portmap service, which instructs portmap
372 on the host at IP address *addr to make an RPC call on your
373 behalf to a procedure on that host. The parameter *portp will
374 be modified to the program's port number if the procedure suc‐
375 ceeds. The definitions of other parameters are discussed in
376 callrpc() and clnt_call(). This procedure should be used for a
377 “ping” and nothing else. See also clnt_broadcast().
378 pmap_set(prognum, versnum, protocol, port)
380 u_long prognum, versnum, protocol;
381 u_short port;
382 A user interface to the portmap service, which establishes a
384 mapping between the triple [prognum,versnum,protocol] and port
385 on the machine's portmap service. The value of protocol is most
386 likely IPPROTO_UDP or IPPROTO_TCP. This routine returns one if
387 it succeeds, zero otherwise. Automatically done by svc_regis‐
388 ter().
389 pmap_unset(prognum, versnum)
391 u_long prognum, versnum;
392 A user interface to the portmap service, which destroys all map‐
394 ping between the triple [prognum,versnum,*] and ports on the
395 machine's portmap service. This routine returns one if it suc‐
396 ceeds, zero otherwise.
397 registerrpc(prognum, versnum, procnum, procname, inproc, outproc)
399 u_long prognum, versnum, procnum;
400 char *(*procname) () ;
401 xdrproc_t inproc, outproc;
402 Register procedure procname with the RPC service package. If a
404 request arrives for program prognum, version versnum, and proce‐
405 dure procnum, procname is called with a pointer to its parame‐
406 ter(s); progname should return a pointer to its static
407 result(s); inproc is used to decode the parameters while outproc
408 is used to encode the results. This routine returns zero if the
409 registration succeeded, -1 otherwise.
410 Warning: remote procedures registered in this form are accessed
412 using the UDP/IP transport; see svcudp_create() for restric‐
413 tions.
414 struct rpc_createerr rpc_createerr;
416 A global variable whose value is set by any RPC client creation
418 routine that does not succeed. Use the routine clnt_pcreateer‐
419 ror() to print the reason why.
420 svc_destroy(xprt)
422 SVCXPRT *
423 xprt;
424 A macro that destroys the RPC service transport handle, xprt.
426 Destruction usually involves deallocation of private data struc‐
427 tures, including xprt itself. Use of xprt is undefined after
428 calling this routine.
429 fd_set svc_fdset;
431 A global variable reflecting the RPC service side's read file
433 descriptor bit mask; it is suitable as a parameter to the
434 select() system call. This is only of interest if a service
435 implementor does not call svc_run(), but rather does his own
436 asynchronous event processing. This variable is read-only (do
437 not pass its address to select()!), yet it may change after
438 calls to svc_getreqset() or any creation routines.
439 int svc_fds;
441 Similar to svc_fdset, but limited to 32 descriptors. This inter‐
443 face is obsoleted by svc_fdset.
444 svc_freeargs(xprt, inproc, in)
446 SVCXPRT *xprt;
447 xdrproc_t inproc;
448 char *in;
449 A macro that frees any data allocated by the RPC/XDR system when
451 it decoded the arguments to a service procedure using
452 svc_getargs(). This routine returns 1 if the results were suc‐
453 cessfully freed, and zero otherwise.
454 svc_getargs(xprt, inproc, in)
456 SVCXPRT *xprt;
457 xdrproc_t inproc;
458 char *in;
459 A macro that decodes the arguments of an RPC request associated
461 with the RPC service transport handle, xprt. The parameter in
462 is the address where the arguments will be placed; inproc is the
463 XDR routine used to decode the arguments. This routine returns
464 one if decoding succeeds, and zero otherwise.
465 struct sockaddr_in *
467 svc_getcaller(xprt)
468 SVCXPRT *xprt;
469 The approved way of getting the network address of the caller of
471 a procedure associated with the RPC service transport handle,
472 xprt.
473 svc_getreqset(rdfds)
475 fd_set *rdfds;
476 This routine is only of interest if a service implementor does
478 not call svc_run(), but instead implements custom asynchronous
479 event processing. It is called when the select() system call
480 has determined that an RPC request has arrived on some RPC
481 socket(s) ; rdfds is the resultant read file descriptor bit
482 mask. The routine returns when all sockets associated with the
483 value of rdfds have been serviced.
484 svc_getreq(rdfds)
486 int rdfds;
487 Similar to svc_getreqset(), but limited to 32 descriptors. This
489 interface is obsoleted by svc_getreqset().
490 svc_register(xprt, prognum, versnum, dispatch, protocol)
492 SVCXPRT *xprt;
493 u_long prognum, versnum;
494 void (*dispatch) ();
495 u_long protocol;
496 Associates prognum and versnum with the service dispatch proce‐
498 dure, dispatch. If protocol is zero, the service is not regis‐
499 tered with the portmap service. If protocol is non-zero, then a
500 mapping of the triple [prognum,versnum,protocol] to
501 xprt->xp_port is established with the local portmap service
502 (generally protocol is zero, IPPROTO_UDP or IPPROTO_TCP ). The
503 procedure dispatch has the following form:
504 dispatch(request, xprt)
505 struct svc_req *request;
506 SVCXPRT *xprt;
507 The svc_register() routine returns one if it succeeds, and zero
509 otherwise.
510 svc_run()
512 This routine never returns. It waits for RPC requests to arrive,
514 and calls the appropriate service procedure using svc_getreq()
515 when one arrives. This procedure is usually waiting for a
516 select() system call to return.
517 svc_sendreply(xprt, outproc, out)
519 SVCXPRT *xprt;
520 xdrproc_t outproc;
521 char *out;
522 Called by an RPC service's dispatch routine to send the results
524 of a remote procedure call. The parameter xprt is the request's
525 associated transport handle; outproc is the XDR routine which is
526 used to encode the results; and out is the address of the
527 results. This routine returns one if it succeeds, zero other‐
528 wise.
529 void
531 svc_unregister(prognum, versnum)
532 u_long prognum, versnum;
533 Remove all mapping of the double [prognum,versnum] to dispatch
535 routines, and of the triple [prognum,versnum,*] to port number.
536 void
538 svcerr_auth(xprt, why)
539 SVCXPRT *xprt;
540 enum auth_stat why;
541 Called by a service dispatch routine that refuses to perform a
543 remote procedure call due to an authentication error.
544 void
546 svcerr_decode(xprt)
547 SVCXPRT *xprt;
548 Called by a service dispatch routine that cannot successfully
550 decode its parameters. See also svc_getargs().
551 void
553 svcerr_noproc(xprt)
554 SVCXPRT *xprt;
555 Called by a service dispatch routine that does not implement the
557 procedure number that the caller requests.
558 void
560 svcerr_noprog(xprt)
561 SVCXPRT *xprt;
562 Called when the desired program is not registered with the RPC
564 package. Service implementors usually do not need this routine.
565 void
567 svcerr_progvers(xprt)
568 SVCXPRT *xprt;
569 Called when the desired version of a program is not registered
571 with the RPC package. Service implementors usually do not need
572 this routine.
573 void
575 svcerr_systemerr(xprt)
576 SVCXPRT *xprt;
577 Called by a service dispatch routine when it detects a system
579 error not covered by any particular protocol. For example, if a
580 service can no longer allocate storage, it may call this rou‐
581 tine.
582 void
584 svcerr_weakauth(xprt)
585 SVCXPRT *xprt;
586 Called by a service dispatch routine that refuses to perform a
588 remote procedure call due to insufficient authentication parame‐
589 ters. The routine calls svcerr_auth(xprt, AUTH_TOOWEAK).
590 SVCXPRT *
592 svcfd_create(fd, sendsize, recvsize)
593 int fd;
594 u_int sendsize;
595 u_int recvsize;
596 Create a service on top of any open descriptor. Typically, this
598 descriptor is a connected socket for a stream protocol such as
599 TCP. sendsize and recvsize indicate sizes for the send and
600 receive buffers. If they are zero, a reasonable default is cho‐
601 sen.
602 SVCXPRT *
604 svcraw_create()
605 This routine creates a toy RPC service transport, to which it
607 returns a pointer. The transport is really a buffer within the
608 process's address space, so the corresponding RPC client should
609 live in the same address space; see clntraw_create(). This rou‐
610 tine allows simulation of RPC and acquisition of RPC overheads
611 (such as round trip times), without any kernel interference.
612 This routine returns NULL if it fails.
613 SVCXPRT *
615 svctcp_create(sock, send_buf_size, recv_buf_size)
616 int sock;
617 u_int send_buf_size, recv_buf_size;
618 This routine creates a TCP/IP-based RPC service transport, to
620 which it returns a pointer. The transport is associated with
621 the socket sock, which may be RPC_ANYSOCK, in which case a new
622 socket is created. If the socket is not bound to a local TCP
623 port, then this routine binds it to an arbitrary port. Upon
624 completion, xprt->xp_sock is the transport's socket descriptor,
625 and xprt->xp_port is the transport's port number. This routine
626 returns NULL if it fails. Since TCP-based RPC uses buffered I/O
627 , users may specify the size of buffers; values of zero choose
628 suitable defaults.
629 SVCXPRT *
631 svcudp_bufcreate(sock, sendsize, recosize)
632 int sock;
633 This routine creates a UDP/IP-based RPC service transport, to
635 which it returns a pointer. The transport is associated with
636 the socket sock, which may be RPC_ANYSOCK, in which case a new
637 socket is created. If the socket is not bound to a local UDP
638 port, then this routine binds it to an arbitrary port. Upon com‐
639 pletion, xprt->xp_sock is the transport's socket descriptor, and
640 xprt->xp_port is the transport's port number. This routine
641 returns NULL if it fails.
642 This allows the user to specify the maximum packet size for
644 sending and receiving UDP-based RPC messages.
645 SVCXPRT *
647 svcudp_create(sock)
648 int sock;
649 This call is equivalent to svcudp_bufcreate(sock,SZ,SZ) for some
651 default size SZ.
652 xdr_accepted_reply(xdrs, ar)
654 XDR *xdrs;
655 struct accepted_reply *ar;
656 Used for encoding RPC reply messages. This routine is useful for
658 users who wish to generate RPC-style messages without using the
659 RPC package.
660 xdr_authunix_parms(xdrs, aupp)
662 XDR *xdrs;
663 struct authunix_parms *aupp;
664 Used for describing UNIX credentials. This routine is useful for
666 users who wish to generate these credentials without using the
667 RPC authentication package.
668 void
670 xdr_callhdr(xdrs, chdr)
671 XDR *xdrs;
672 struct rpc_msg *chdr;
673 Used for describing RPC call header messages. This routine is
675 useful for users who wish to generate RPC-style messages without
676 using the RPC package.
677 xdr_callmsg(xdrs, cmsg)
679 XDR *xdrs;
680 struct rpc_msg *cmsg;
681 Used for describing RPC call messages. This routine is useful
683 for users who wish to generate RPC-style messages without using
684 the RPC package.
685 xdr_opaque_auth(xdrs, ap)
687 XDR *xdrs;
688 struct opaque_auth *ap;
689 Used for describing RPC authentication information messages.
691 This routine is useful for users who wish to generate RPC-style
692 messages without using the RPC package.
693 xdr_pmap(xdrs, regs)
695 XDR *xdrs;
696 struct pmap *regs;
697 Used for describing parameters to various portmap procedures,
699 externally. This routine is useful for users who wish to gener‐
700 ate these parameters without using the pmap interface.
701 xdr_pmaplist(xdrs, rp)
703 XDR *xdrs;
704 struct pmaplist **rp;
705 Used for describing a list of port mappings, externally. This
707 routine is useful for users who wish to generate these parame‐
708 ters without using the pmap interface.
709 xdr_rejected_reply(xdrs, rr)
711 XDR *xdrs;
712 struct rejected_reply *rr;
713 Used for describing RPC reply messages. This routine is useful
715 for users who wish to generate RPC-style messages without using
716 the RPC package.
717 xdr_replymsg(xdrs, rmsg)
719 XDR *xdrs;
720 struct rpc_msg *rmsg;
721 Used for describing RPC reply messages. This routine is useful
723 for users who wish to generate RPC style messages without using
724 the RPC package.
725 void
727 xprt_register(xprt)
728 SVCXPRT *xprt;
729 After RPC service transport handles are created, they should
731 register themselves with the RPC service package. This routine
732 modifies the global variable svc_fds(). Service implementors
733 usually do not need this routine.
734 void
736 xprt_unregister(xprt)
737 SVCXPRT *xprt;
738 Before an RPC service transport handle is destroyed, it should
740 unregister itself with the RPC service package. This routine
741 modifies the global variable svc_fds(). Service implementors
742 usually do not need this routine.
743
745 xdr(3)
746 The following manuals:
747 Remote Procedure Calls: Protocol Specification
748 Remote Procedure Call Programming Guide
749 rpcgen Programming Guide
750 RPC: Remote Procedure Call Protocol Specification, RFC 1050, Sun
751 Microsystems, Inc., USC-ISI.
752 1988-02-16 RPC(3)