Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
CALLRPC(3)	       FreeBSD Library Functions Manual		    CALLRPC(3)

NAME
     callrpc, clnt_broadcast, clnt_call, clnt_control, clnt_create,
     clnt_destroy, clnt_freeres, clnt_pcreateerror, clnt_perrno, clnt_perror,
     clnt_spcreateerror, clnt_sperrno, clnt_sperror, clntraw_create,
     clnttcp_create, clntudp_bufcreate,	clntudp_create,	clnt_geterr,
     get_myaddress, pmap_getmaps, pmap_getport,	pmap_rmtcall, pmap_set,
     pmap_unset, registerrpc, rpc_createerr, svc_destroy, svc_fds, svc_fdset,
     svc_freeargs, svc_getargs,	svc_getcaller, svc_getreq, svc_getreq_common,
     svc_getreq_poll, svc_getreqset, svc_getreqset2, svc_register,
     svc_max_pollfd, svc_pollfd, svc_run, svc_sendreply, svc_unregister,
     svcerr_auth, svcerr_decode, svcerr_noproc,	svcerr_noprog,
     svcerr_progvers, svcerr_systemerr,	svcerr_weakauth, svcfd_create,
     svcraw_create, svctcp_create, svcudp_create, svcudp_bufcreate,
     xdr_accepted_reply, xdr_authunix_parms, xdr_callhdr, xdr_callmsg,
     xdr_opaque_auth, xdr_pmap,	xdr_pmaplist, xdr_rejected_reply,
     xdr_replymsg, xprt_register, xprt_unregister -- library routines for re-
     mote procedure calls

SYNOPSIS
     #include <rpc/rpc.h>

     int
     callrpc(char *host, u_long	prognum, u_long	versnum, u_long	procnum,
	 xdrproc_t inproc, char	*in, xdrproc_t outproc,	char *out);

     enum clnt_stat
     clnt_broadcast(u_long prognum, u_long versnum, u_long procnum,
	 xdrproc_t inproc, char	*in, xdrproc_t outproc,	char *out,
	 resultproc_t eachresult);

     enum clnt_stat
     clnt_call(CLIENT *clnt, u_long procnum, xdrproc_t inproc, char *in,
	 xdrproc_t outproc, char *out, struct timeval tout);

     int
     clnt_destroy(CLIENT *clnt);

     CLIENT *
     clnt_create(char *host, u_long prog, u_long vers, char *proto);

     bool_t
     clnt_control(CLIENT *cl, int req, char *info);

     int
     clnt_freeres(CLIENT *clnt,	xdrproc_t outproc, char	*out);

     void
     clnt_geterr(CLIENT	*clnt, struct rpc_err *errp);

     void
     clnt_pcreateerror(char *s);

     void
     clnt_perrno(enum clnt_stat	stat);

     int
     clnt_perror(CLIENT	*clnt, char *s);

     char *
     clnt_spcreateerror(char *s);

     char *
     clnt_sperrno(enum clnt_stat stat);

     char *
     clnt_sperror(CLIENT *rpch,	char *s);

     CLIENT *
     clntraw_create(u_long prognum, u_long versnum);

     CLIENT *
     clnttcp_create(struct sockaddr_in *addr, u_long prognum, u_long versnum,
	 int *sockp, u_int sendsz, u_int recvsz);

     CLIENT *
     clntudp_create(struct sockaddr_in *addr, u_long prognum, u_long versnum,
	 struct	timeval	wait, int *sockp);

     CLIENT *
     clntudp_bufcreate(struct sockaddr_in *addr, u_long	prognum,
	 u_long	versnum, struct	timeval	wait, int *sockp,
	 unsigned int sendsize,	unsigned int recosize);

     int
     get_myaddress(struct sockaddr_in *addr);

     struct pmaplist *
     pmap_getmaps(struct sockaddr_in *addr);

     u_short
     pmap_getport(struct sockaddr_in *addr, u_long prognum, u_long versnum,
	 u_long	protocol);

     enum clnt_stat
     pmap_rmtcall(struct sockaddr_in *,	u_long prog, u_long vers, u_long proc,
	 xdrproc_t inp,	char *in, xdrproc_t outp, char *out,
	 struct	timeval	tv, u_long *portp);

     int
     pmap_set(u_long prognum, u_long versnum, u_int protocol, int port);

     int
     pmap_unset(u_long prognum,	u_long versnum);

     int
     registerrpc(u_long	prognum, u_long	versnum, u_long	procnum,
	 char *(*procname)(), xdrproc_t	inproc,	xdrproc_t outproc);

     struct rpc_createerr rpc_createerr;

     int
     svc_destroy(SVCXPRT *xprt);

     struct pollfd *svc_pollfd;
     int svc_max_pollfd;
     fd_set svc_fdset;
     fd_set *__svc_fdset;
     int __svc_fdsetsize;
     int svc_fds;

     int
     svc_freeargs(SVCXPRT *xprt, xdrproc_t inproc, char	*in);

     int
     svc_getargs(SVCXPRT *xprt,	xdrproc_t inproc, char *in);

     struct sockaddr_in	*
     svc_getcaller(SVCXPRT *xprt);

     int
     svc_getreq_common(int fd);

     int
     svc_getreq_poll(struct pollfd *pfds, const	int pollretval);

     int
     svc_getreqset(fd_set *rdfds);

     int
     svc_getreqset2(fd_set *rdfds, int width);

     int
     svc_getreq(int rdfds);

     int
     svc_register(SVCXPRT *xprt, u_long	prognum, u_long	versnum,
	 void (*dispatch)(), u_long protocol);

     int
     svc_run(void);

     int
     svc_sendreply(SVCXPRT *xprt, xdrproc_t outproc, char *out);

     void
     svc_unregister(u_long prognum, u_long versnum);

     void
     svcerr_auth(SVCXPRT *xprt,	enum auth_stat why);

     void
     svcerr_decode(SVCXPRT *xprt);

     void
     svcerr_noproc(SVCXPRT *xprt);

     void
     svcerr_noprog(SVCXPRT *xprt);

     void
     svcerr_progvers(SVCXPRT *xprt);

     void
     svcerr_systemerr(SVCXPRT *xprt);

     void
     svcerr_weakauth(SVCXPRT *xprt);

     SVCXPRT *
     svcraw_create(void);

     SVCXPRT *
     svctcp_create(int sock, u_int send_buf_size, u_int	recv_buf_size);

     SVCXPRT *
     svcfd_create(int fd, u_int	sendsize, u_int	recvsize);

     SVCXPRT *
     svcudp_create(int sock);

     SVCXPRT *
     svcudp_bufcreate(int sock,	u_int sendsz, u_int recvsz);

     bool_t
     xdr_accepted_reply(XDR *xdrs, struct accepted_reply *ar);

     bool_t
     xdr_authunix_parms(XDR *xdrs, struct authunix_parms *aupp);

     void
     xdr_callhdr(XDR *xdrs, struct rpc_msg *chdr);

     int
     xdr_callmsg(XDR *xdrs, struct rpc_msg *cmsg);

     int
     xdr_opaque_auth(XDR *xdrs,	struct opaque_auth *ap);

     int
     xdr_pmap(XDR *xdrs, struct	pmap *regs);

     int
     xdr_pmaplist(XDR *xdrs, struct pmaplist **rp);

     int
     xdr_rejected_reply(XDR *xdrs, struct rejected_reply *rr);

     int
     xdr_replymsg(XDR *xdrs, struct rpc_msg *rmsg);

     void
     xprt_register(SVCXPRT *xprt);

     void
     xprt_unregister(SVCXPRT *xprt);

DESCRIPTION
     These routines allow C programs to	make procedure calls on	other machines
     across the	network.  First, the client calls a procedure to send a	data
     packet to the server.  Upon receipt of the	packet,	the server calls a
     dispatch routine to perform the requested service,	and then sends back a
     reply.  Finally, the procedure call returns to the	client.

     callrpc() calls the remote	procedure associated with prognum, versnum,
     and procnum on the	machine, host.	The parameter in is the	address	of the
     procedure's argument(s), and out is the address of	where to place the re-
     sult(s); inproc is	used to	encode the procedure's parameters, and outproc
     is	used to	decode the procedure's results.	 This routine returns zero if
     it	succeeds, or the value of enum clnt_stat cast to an integer if it
     fails.  The routine clnt_perrno() is handy	for translating	failure	sta-
     tuses into	messages.

     Warning: calling remote procedures	with this routine uses UDP/IP as a
     transport;	see clntudp_create() for restrictions.	You do not have	con-
     trol of timeouts or authentication	using this routine.

     clnt_broadcast() is like callrpc(), except	the call message is broadcast
     to	all locally connected broadcast	nets.  Each time it receives a re-
     sponse, this routine calls	eachresult, whose form is:

	   int
	   eachresult(char *out, struct	sockaddr_in *addr)

     where out is the same as out passed to clnt_broadcast(), except that the
     remote procedure's	output is decoded there; addr points to	the address of
     the machine that sent the results.	 If eachresult returns zero,
     clnt_broadcast() waits for	more replies; otherwise	it returns with	appro-
     priate status.

     Warning: broadcast	sockets	are limited in size to the maximum transfer
     unit of the data link.  For Ethernet, this	value is 1500 bytes.

     clnt_call() is a macro that calls the remote procedure procnum associated
     with the client handle, clnt, which is obtained with an RPC client	cre-
     ation routine such	as clnt_create().  The parameter in is the address of
     the procedure's argument(s), and out is the address of where to place the
     result(s);	inproc is used to encode the procedure's parameters, and
     outproc is	used to	decode the procedure's results;	tout is	the time al-
     lowed for results to come back.

     clnt_destroy() is a macro that destroys the client's RPC handle.  De-
     struction usually involves	deallocation of	private	data structures, in-
     cluding clnt itself.  Use of clnt is undefined after calling
     clnt_destroy().  If the RPC library opened	the associated socket, it will
     close it also.  Otherwise,	the socket remains open.

     clnt_create() is a	generic	client creation	routine.  host identifies the
     name of the remote	host where the server is located.  proto indicates
     which kind	of transport protocol to use.  The currently supported values
     for this field are	"udp" and "tcp".  Default timeouts are set, but	can be
     modified using clnt_control().  This routine returns NULL if it fails.

     Warning: Using UDP	has its	shortcomings.  Since UDP-based RPC messages
     can only hold up to 8 Kbytes of encoded data, this	transport cannot be
     used for procedures that take large arguments or return huge results.

     clnt_control() is a macro used to change or retrieve various information
     about a client object.  req indicates the type of operation, and info is
     a pointer to the information.  For	both UDP and TCP, the supported	values
     of	req and	their argument types and what they do are:

	   CLSET_TIMEOUT   struct timeval  set total timeout
	   CLGET_TIMEOUT   struct timeval  get total timeout

     Note: if you set the timeout using	clnt_control(),	the timeout parameter
     passed to clnt_call() will	be ignored in all future calls.

	   CLGET_SERVER_ADDR	   struct sockaddr_in	   get server's	address

     The following operations are valid	for UDP	only:

	   CLSET_RETRY_TIMEOUT	 struct	timeval	   set the retry timeout
	   CLGET_RETRY_TIMEOUT	 struct	timeval	   get the retry timeout

     The retry timeout is the time that	UDP RPC	waits for the server to	reply
     before retransmitting the request.

     clnt_freeres() is a macro that frees any data allocated by	the RPC/XDR
     system when it decoded the	results	of an RPC call.	 The parameter out is
     the address of the	results, and outproc is	the XDR	routine	describing the
     results.  This routine returns one	if the results were successfully
     freed, and	zero otherwise.

     clnt_geterr() is a	macro that copies the error structure out of the
     client handle to the structure at address errp.

     clnt_pcreateerror() prints	a message to standard error indicating why a
     client RPC	handle could not be created.  The message is prepended with
     string s and a colon.  Used when a	clnt_create(), clntraw_create(),
     clnttcp_create(), or clntudp_create() call	fails.

     clnt_perrno() prints a message to standard	error corresponding to the
     condition indicated by stat.  Used	after callrpc().

     clnt_perror() prints a message to standard	error indicating why an	RPC
     call failed; clnt is the handle used to do	the call.  The message is
     prepended with string s and a colon.  Used	after clnt_call().

     clnt_spcreateerror() is like clnt_pcreateerror(), except that it returns
     a string instead of printing to the standard error.

     Bugs: returns pointer to static data that is overwritten on each call.

     clnt_sperrno() takes the same arguments as	clnt_perrno(), but instead of
     sending a message to the standard error indicating	why an RPC call
     failed, returns a pointer to a string which contains the message.	Unlike
     clnt_perror(), it does not	append a newline character to the end of the
     message.

     clnt_sperrno() is used instead of clnt_perrno() if	the program does not
     have a standard error (as a program running as a server quite likely does
     not), or if the programmer	does not want the message to be	output with
     printf(), or if a message format different	than that supported by
     clnt_perrno() is to be used.

     Note: unlike clnt_sperror() and clnt_spcreaterror(), clnt_sperrno() re-
     turns a pointer to	static data, but the result will not get overwritten
     on	each call.

     clnt_sperror() is like clnt_perror(), except that (like clnt_sperrno())
     it	returns	a string instead of printing to	standard error.

     Bugs: returns pointer to static data that is overwritten on each call.

     clntraw_create() is a routine which creates a toy RPC client for the re-
     mote program prognum, version versnum.  The transport used	to pass	mes-
     sages to the service is actually a	buffer within the process's address
     space, so the corresponding RPC server should live	in the same address
     space; see	svcraw_create().  This allows simulation of RPC	and acquisi-
     tion of RPC overheads, such as round trip times, without any kernel in-
     terference.  This routine returns NULL if it fails.

     clnttcp_create() is a routine which creates an RPC	client for the remote
     program prognum, version versnum; the client uses TCP/IP as a transport.
     The remote	program	is located at Internet address *addr.  If
     addr-_sin_port is zero, then it is	set to the actual port that the	remote
     program is	listening on (the remote portmap(8) service is consulted for
     this information).	 The parameter sockp is	a socket; if it	is
     RPC_ANYSOCK, then this routine opens a new	one and	sets sockp.  Since
     TCP-based RPC uses	buffered I/O, the user may specify the size of the
     send and receive buffers with the parameters sendsz and recvsz; values of
     zero choose suitable defaults.  This routine returns NULL if it fails.

     clntudp_create() is a routine which creates an RPC	client for the remote
     program prognum, on versnum; the client uses use UDP/IP as	a transport.
     The remote	program	is located at Internet address addr.  If
     addr-_sin_port is zero, then it is	set to actual port that	the remote
     program is	listening on (the remote portmap(8) service is consulted for
     this information).	 The parameter sockp is	a socket; if it	is
     RPC_ANYSOCK, then this routine opens a new	one and	sets sockp.  The UDP
     transport resends the call	message	in intervals of	wait time until	a re-
     sponse is received	or until the call times	out.  The total	time for the
     call to time out is specified by clnt_call().  This routine returns NULL
     if	it fails.

     clntudp_bufcreate() is like clntudp_create(), except that it allows the
     user to specify the maximum packet	size for sending and receiving UDP-
     based RPC messages	instead	of using the default size limit	of 8800	bytes.

     get_myaddress() stuffs the	machine's IP address into *addr, without con-
     sulting the library routines that deal with /etc/hosts.  The port number
     is	always set to htons(PMAPPORT).	Returns	zero on	success, non-zero on
     failure.

     pmap_getmaps() is a function interface to the portmap(8) service, which
     returns a list of the current RPC program-to-port mappings	on the host
     located at	IP address *addr.  This	routine	can return NULL.  The command
     "rpcinfo -p" uses this routine.

     pmap_getport() is a user interface	to the portmap(8) service, which re-
     turns the port number on which waits a service that supports program num-
     ber prognum, version versnum, and speaks the transport protocol associ-
     ated with protocol.  The value of protocol	is most	likely IPPROTO_UDP or
     IPPROTO_TCP.  A return value of zero means	that the mapping does not ex-
     ist or that the RPC system	failured to contact the	remote portmap(8) ser-
     vice.  In the latter case,	the global variable rpc_createerr contains the
     RPC status.

     pmap_rmtcall() is a user interface	to the portmap(8) service, which in-
     structs portmap(8)	on the host at IP address *addr	to make	an RPC call on
     your behalf to a procedure	on that	host.  The parameter *portp will be
     modified to the program's port number if the procedure succeeds.  The
     definitions of other parameters are discussed in callrpc()	and
     clnt_call().  This	procedure should be used for a "ping" and nothing
     else.  See	also clnt_broadcast().

     pmap_set()	is a user interface to the portmap(8) service, which estab-
     lishes a mapping between the triple [prognum, versnum, protocol] and port
     on	the machine's portmap(8) service.  The value of	protocol is most
     likely IPPROTO_UDP	or IPPROTO_TCP.	 This routine returns one if it	suc-
     ceeds, zero otherwise.  Automatically done	by svc_register().

     pmap_unset() is a user interface to the portmap(8)	service, which de-
     stroys all	mapping	between	the triple [prognum, versnum, *] and ports on
     the machine's portmap(8) service.	This routine returns one if it suc-
     ceeds, zero otherwise.

     registerrpc() will	register a procedure procname with the RPC service
     package.  If a request arrives for	program	prognum, version versnum, and
     procedure procnum,	procname is called with	a pointer to its parameter(s);
     procname should return a pointer to its static result(s); inproc is used
     to	decode the parameters while outproc is used to encode the results.
     This routine returns zero if the registration succeeded, -1 otherwise.

     Warning: remote procedures	registered in this form	are accessed using the
     UDP/IP transport; see svcudp_create() for restrictions.

     rpc_createerr is a	global variable	whose value is set by any RPC client
     creation routine that does	not succeed.  Use the routine
     clnt_pcreateerror() to print the reason why.

     svc_destroy() is a	macro that destroys the	RPC service transport handle,
     xprt.  Destruction	usually	involves deallocation of private data struc-
     tures, including xprt itself.  Use	of xprt	is undefined after calling
     this routine.

     svc_pollfd	is a global variable reflecting	the RPC	service	side's read
     file descriptor array.  This variable is only of interest if service im-
     plementors	do not call svc_run(), but rather do their own asynchronous
     event processing.	This variable is read-only, and	it may change after
     calls to svc_getreq_poll()	or any creation	routines.  Do not pass it di-
     rectly to poll(2)!	 Instead, make a copy and pass that instead.

     svc_max_pollfd is a global	variable containing the	maximum	length of the
     svc_pollfd	array.	svc_max_pollfd is not a	hard limit; it will grow auto-
     matically as needed.  This	variable is read-only, and it may change after
     calls to svc_getreq_poll()	or any creation	routines.  The purpose of
     svc_max_pollfd is to allow	a service implementor to make a	copy of
     svc_pollfd	that may in turn be passed to poll(2).

     __svc_fdset and __svc_fdsetsize are global	variables reflecting the RPC
     service side's read file descriptor bit mask.  __svc_fdsetsize is a count
     of	the number of checkable	bits in	__svc_fdset, and can expand to the
     full size that select(2) supports,	hence exceeding	FD_SETSIZE if re-
     quired.  These variables are only of interest if service implementors do
     not call svc_run(), but rather do their own asynchronous event process-
     ing.  This	variable is read-only, and it may change after calls to
     svc_getreqset() or	any creation routines.	Do not pass its	address	to
     select(2)!	 Instead, pass the address of a	copy.  These variables are
     considered	obsolete; new programs should use svc_pollfd and
     svc_max_pollfd instead.

     svc_fdset is similar to __svc_fdset but limited to	FD_SETSIZE descrip-
     tors.  This is only of interest if	service	implementors do	not call
     svc_run(),	but rather do their own	asynchronous event processing.	This
     variable is read-only, and	it may change after calls to svc_getreqset()
     or	any creation routines.	Do not pass it directly	to select(2)!  In-
     stead, make a copy	and pass that instead.

     Additionally, note	that if	the process has	descriptor limits which	are
     extended beyond FD_SETSIZE, this variable will only be usable for the
     first FD_SETSIZE descriptors.  This variable is considered	obsolete; new
     programs should use svc_pollfd which does not have	this limit.

     svc_fds is	similar	to svc_fdset, but limited to 32	descriptors.  This in-
     terface is	obsoleted by svc_fdset and is included for source compatibil-
     ity only.

     svc_freeargs() is a macro that frees any data allocated by	the RPC/XDR
     system when it decoded the	arguments to a service procedure using
     svc_getargs().  This routine returns 1 if the results were	successfully
     freed, and	zero otherwise.

     svc_getargs() is a	macro that decodes the arguments of an RPC request as-
     sociated with the RPC service transport handle, xprt.  The	parameter in
     is	the address where the arguments	will be	placed;	inproc is the XDR rou-
     tine used to decode the arguments.	 This routine returns one if decoding
     succeeds, and zero	otherwise.

     svc_getcaller() is	the approved way of getting the	network	address	of the
     caller of a procedure associated with the RPC service transport handle,
     xprt.

     svc_getreq_common() is called to handle a request on the given socket.
     It	is used	internally by svc_getreq_poll(), svc_getreqset(),
     svc_getreqset2(), and svc_getreq().

     svc_getreq_poll() is a routine which is only of interest if a service im-
     plementor does not	call svc_run(),	but instead implements custom asyn-
     chronous event processing.	 It is called when the poll(2) system call has
     determined	that an	RPC request has	arrived	on some	RPC socket(s);
     pollretval	is the value returned by poll(2) and pfds is the array of
     pollfd structures passed to poll(2).  The routine returns when all	sock-
     ets described by pollfd have been serviced.

     svc_getreqset() is	a routine which	is only	of interest if a service im-
     plementor does not	call svc_run(),	but instead implements custom asyn-
     chronous event processing.	 It is called when the select(2) system	call
     has determined that an RPC	request	has arrived on some RPC	socket(s);
     rdfds is the resultant read file descriptor bit mask.  The	routine	re-
     turns when	all sockets associated with the	value of rdfds have been ser-
     viced.

     svc_getreqset2() is a non-standard	routine	which is only of interest if a
     service implementor does not call svc_run(), but instead implements cus-
     tom asynchronous event processing.	 It is called when the select(2) sys-
     tem call has determined that an RPC request has arrived on	some RPC
     socket(s);	rdfds is the resultant read file descriptor bit	mask.  The
     routine returns when all sockets associated with the value	of rdfds have
     been serviced.  This interface is non-portable, but provided for applica-
     tions which need to deal with large fd_set	sizes.

     svc_getreq() is similar to	svc_getreqset, but limited to 32 descriptors.
     This interface is obsoleted by svc_getreq_poll and	svc_getreqset.

     svc_register() associates prognum and versnum with	the service dispatch
     procedure,	dispatch.  If protocol is zero,	the service is not registered
     with the portmap(8) service.  If protocol is non-zero, then a mapping of
     the triple	[prognum, versnum, protocol] to	xprt-_xp_port is established
     with the local portmap(8) service (generally protocol is zero,
     IPPROTO_UDP or IPPROTO_TCP).  The procedure dispatch has the following
     form: int dispatch(struct svc_req *request, SVCXPRT *xprt)	The
     svc_register() routine returns one	if it succeeds,	and zero otherwise.

     svc_run() never returns.  It waits	for RPC	requests to arrive, and	calls
     the appropriate service procedure using svc_getreq_poll() when one	ar-
     rives.  This procedure is usually waiting for a poll(2) system call to
     return.

     svc_sendreply() is	called by an RPC service's dispatch routine to send
     the results of a remote procedure call.  The parameter xprt is the	re-
     quest's associated	transport handle; outproc is the XDR routine which is
     used to encode the	results; and out is the	address	of the results.	 This
     routine returns one if it succeeds, zero otherwise.

     svc_unregister() removes all mapping of the double	[prognum, versnum] to
     dispatch routines,	and of the triple [prognum, versnum, *]	to port	num-
     ber.

     svcerr_auth() is called by	a service dispatch routine that	refuses	to
     perform a remote procedure	call due to an authentication error.

     svcerr_decode() is	called by a service dispatch routine that cannot suc-
     cessfully decode its parameters.  See also	svc_getargs().

     svcerr_noproc() is	called by a service dispatch routine that does not im-
     plement the procedure number that the caller requests.

     svcerr_noprog() is	called when the	desired	program	is not registered with
     the RPC package.  Service implementors usually do not need	this routine.

     svcerr_progvers() is called when the desired version of a program is not
     registered	with the RPC package.  Service implementors usually do not
     need this routine.

     svcerr_systemerr()	is called by a service dispatch	routine	when it	de-
     tects a system error not covered by any particular	protocol.  For exam-
     ple, if a service can no longer allocate storage, it may call this	rou-
     tine.

     svcerr_weakauth() is called by a service dispatch routine that refuses to
     perform a remote procedure	call due to insufficient authentication	param-
     eters.  The routine calls svcerr_auth(xprt, AUTH_TOOWEAK).

     svcraw_create() is	a routine which	creates	a toy RPC service transport,
     to	which it returns a pointer.  The transport is really a buffer within
     the process's address space, so the corresponding RPC client should live
     in	the same address space;	see clntraw_create().  This routine allows
     simulation	of RPC and acquisition of RPC overheads	(such as round trip
     times), without any kernel	interference.  This routine returns NULL if it
     fails.

     svctcp_create() is	a routine which	creates	a TCP/IP-based RPC service
     transport,	to which it returns a pointer.	The transport is associated
     with the socket sock, which may be	RPC_ANYSOCK, in	which case a new
     socket is created.	 If the	socket is not bound to a local TCP port, then
     this routine binds	it to an arbitrary port.  Upon completion,
     xprt-_xp_sock is the transport's socket descriptor, and xprt-_xp_port is
     the transport's port number.  This	routine	returns	NULL if	it fails.
     Since TCP-based RPC uses buffered I/O, users may specify the size of buf-
     fers; values of zero choose suitable defaults.

     svcfd_create() will create	a service on top of any	open descriptor.  Typ-
     ically, this descriptor is	a connected socket for a stream	protocol such
     as	TCP.  sendsize and recvsize indicate sizes for the send	and receive
     buffers.  If they are zero, a reasonable default is chosen.

     svcudp_create() is	a routine which	creates	a UDP/IP-based RPC service
     transport,	to which it returns a pointer.	The transport is associated
     with the socket sock, which may be	RPC_ANYSOCK, in	which case a new
     socket is created.	 If the	socket is not bound to a local UDP port, then
     this routine binds	it to an arbitrary port.  Upon completion,
     xprt-_xp_sock is the transport's socket descriptor, and xprt-_xp_port is
     the transport's port number.  This	routine	returns	NULL if	it fails.

     svcudp_bufcreate()	is like	svcudp_create(), except	that it	allows the
     user to specify the maximum packet	size for sending and receiving UDP-
     based RPC messages	instead	of using the default size limit	of 8800	bytes.

     xdr_accepted_reply() is used for encoding RPC reply messages.  This rou-
     tine is useful for	users who wish to generate RPC-style messages without
     using the RPC package.

     xdr_authunix_parms() is used for describing UNIX credentials.  This rou-
     tine is useful for	users who wish to generate these credentials without
     using the RPC authentication package.

     xdr_callhdr() is used for describing RPC call header messages.  This rou-
     tine is useful for	users who wish to generate RPC-style messages without
     using the RPC package.

     xdr_callmsg() is used for describing RPC call messages.  This routine is
     useful for	users who wish to generate RPC-style messages without using
     the RPC package.

     xdr_opaque_auth() is used for describing RPC authentication information
     messages.	This routine is	useful for users who wish to generate RPC-
     style messages without using the RPC package.

     xdr_pmap()	is used	for describing parameters to various portmap(8)	proce-
     dures, externally.	 This routine is useful	for users who wish to generate
     these parameters without using the	pmap interface.

     xdr_pmaplist() is used for	describing a list of port mappings, exter-
     nally.  This routine is useful for	users who wish to generate these pa-
     rameters without using the	pmap interface.

     xdr_rejected_reply() is used for describing RPC reply messages.  This
     routine is	useful for users who wish to generate RPC-style	messages with-
     out using the RPC package.

     xdr_replymsg() is used for	describing RPC reply messages.	This routine
     is	useful for users who wish to generate RPC-style	messages without using
     the RPC package.

     xprt_register() is	used to	register transport handles.  After RPC service
     transport handles are created, they should	register themselves with the
     RPC service package.  This	routine	modifies the global variables
     svc_pollfd, svc_fdset, __svc_fdset	and may	modify svc_max_pollfd and
     __svc_fdsetsize.  Service implementors usually do not need	this routine.

     xprt_unregister() is used to unregister a transport handle.  Before an
     RPC service transport handle is destroyed,	it should unregister itself
     with the RPC service package.  This routine modifies the global variable
     svc_pollfd, svc_fdset, and	__svc_fdset.  Service implementors usually do
     not need this routine.

SEE ALSO
     rpcgen(1),	poll(2), select(2), authnone_create(3),	getrpcent(3),
     getrpcport(3), xdr(3), rpc(5), portmap(8)

     Remote Procedure Calls: Protocol Specification, Sun Microsystems, Inc..

     Remote Procedure Call Programming Guide, Sun Microsystems,	Inc..

     rpcgen Programming	Guide, Sun Microsystems, Inc..

STANDARDS
     RPC: Remote Procedure Call	Protocol Specification Version 2, RFC 1057,
     Sun Microsystems, Inc., June 1988.

FreeBSD	13.0		       November	10, 2015		  FreeBSD 13.0

NAME | SYNOPSIS | DESCRIPTION | SEE ALSO | STANDARDS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=rpc&sektion=3&manpath=OpenBSD+6.9>

home | help