authnone_create man page on MacOSX

Man page or keyword search:  
man Server   23457 pages
apropos Keyword Search (all sections)
Output format
MacOSX logo
[printable version]

RPC(3N)								       RPC(3N)

NAME
       rpc - library routines for remote procedure calls

SYNOPSIS AND 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.

       Routines	 that  are  used  for  Secure  RPC  (DES  authentication)  are
       described  in  rpc_secure(3N).	Secure	RPC  can  be  used only if DES
       encryption is available.

       #include <rpc/rpc.h>

       void
       auth_destroy(auth)
       AUTH *auth;

	      A macro that destroys the authentication information  associated
	      with auth.  Destruction usually involves deallocation of private
	      data structures. The use of  auth	 is  undefined	after  calling
	      auth_destroy().

       AUTH *
       authnone_create()

	      Create  and  returns  an	RPC  authentication handle that passes
	      nonusable authentication information with each remote  procedure
	      call. This is the default authentication used by RPC.

       AUTH *
       authunix_create(host, uid, gid, len, aup_gids)
       char *host;
       int uid, gid, len, *aup.gids;

	      Create  and  return  an  RPC authentication handle that contains
	      authentication information.  The parameter host is the  name  of
	      the  machine  on	which  the information was created; uid is the
	      user's user ID ; gid is the user's current group ID  ;  len  and
	      aup_gids	refer  to  a counted array of groups to which the user
	      belongs.	It is easy to impersonate a user.

       AUTH *
       authunix_create_default()

	      Calls authunix_create() with the appropriate parameters.

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

	      Call 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 result(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 statuses into
	      messages.

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

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

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

		 eachresult(out, addr)
		 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 eachre‐
	      sult() returns zero, clnt_broadcast() waits  for	more  replies;
	      otherwise it returns with appropriate status.

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

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

	      A	 macro that calls the remote procedure procnum associated with
	      the client handle, clnt, which is obtained with  an  RPC	client
	      creation 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 proce‐
	      dure's  results;	tout  is  the time allowed for results to come
	      back.

       clnt_destroy(clnt)
       CLIENT *clnt;

	      A macro that destroys the client's RPC handle. Destruction  usu‐
	      ally involves deallocation of private data structures, including
	      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.

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

	      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().

	      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 argu‐
	      ments or return huge results.

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

	      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  sup‐
	      ported  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(clnt, outproc, out)
       CLIENT *clnt;
       xdrproc_t outproc;
       char *out;

	      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 describ‐
	      ing the results.	This routine returns one if the	 results  were
	      successfully freed, and zero otherwise.

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

	      A macro that copies the error structure out of the client handle
	      to the structure at address errp.

       void
       clnt_pcreateerror(s)
       char *s;

	      Print 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_cre‐
	      ate(), clnttcp_create(), or clntudp_create() call fails.

       void
       clnt_perrno(stat)
       enum clnt_stat stat;

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

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

	      Print 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().

       char *
       clnt_spcreateerror
       char *s;

	      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.

       char *
       clnt_sperrno(stat)
       enum clnt_stat stat;

	      Take the same arguments as clnt_perrno(), but instead of sending
	      a	 message  to  the  standard  error  indicating why an RPC call
	      failed, return a pointer to a string which contains the message.
	      The string ends with a NEWLINE.

	      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 differ‐
	      ent  than	 that supported by clnt_perrno() is to be used.	 Note:
	      unlike clnt_sperror()  and  clnt_spcreaterror(),	clnt_sperrno()
	      returns  pointer	to  static  data,  but the result will not get
	      overwritten on each call.

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

	      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.

       CLIENT *
       clntraw_create(prognum, versnum)
       u_long prognum, versnum;

	      This routine creates a toy RPC client  for  the  remote  program
	      prognum,	version	 versnum.  The transport used to pass messages
	      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 acquisition of RPC overheads, such as round trip times,
	      without any kernel interference. This routine returns NULL if it
	      fails.

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

	      This  routine  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 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.

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

	      This  routine  creates  an  RPC  client  for  the remote program
	      prognum, version versnum; the client uses use UDP/IP as a trans‐
	      port.  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 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 response is received or until the
	      call times out.  The total time for the  call  to	 time  out  is
	      specified by clnt_call().

	      Warning:	since  UDP-based  RPC  messages	 can only hold up to 8
	      Kbytes of encoded data, this transport cannot be used for proce‐
	      dures that take large arguments or return huge results.

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

	      This  routine  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 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 response is received or until the
	      call times out.  The total time for the  call  to	 time  out  is
	      specified by clnt_call().

	      This  allows  the	 user  to  specify the maximun packet size for
	      sending and receiving UDP-based RPC messages.

       void
       get_myaddress(addr)
       struct sockaddr_in *addr;

	      Stuff the machine's IP address into  *addr,  without  consulting
	      the library routines that deal with /etc/hosts.  The port number
	      is always set to htons(PMAPPORT).

       struct pmaplist *
       pmap_getmaps(addr)
       struct sockaddr_in *addr;

	      A user interface to the portmap 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.

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

	      A	 user interface to the portmap service, which returns the port
	      number on which waits a service  that  supports  program	number
	      prognum,	version	 versnum,  and	speaks	the transport protocol
	      associated 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 exist or that the RPC  system  failured  to
	      contact  the  remote  portmap  service.  In the latter case, the
	      global variable rpc_createerr() contains the RPC status.

       enum clnt_stat
       pmap_rmtcall(addr, prognum, versnum, procnum, inproc, in, outproc, out, tout, portp)
       struct sockaddr_in *addr;
       u_long prognum, versnum, procnum;
       char *in, *out;
       xdrproc_t inproc, outproc;
       struct timeval tout;
       u_long *portp;

	      A user interface to the portmap service, which instructs portmap
	      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 suc‐
	      ceeds. 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(prognum, versnum, protocol, port)
       u_long prognum, versnum, protocol;
       u_short port;

	      A user interface to the portmap  service,	 which	establishes  a
	      mapping  between	the triple [prognum,versnum,protocol] and port
	      on the machine's portmap service. The value of protocol is  most
	      likely  IPPROTO_UDP or IPPROTO_TCP.  This routine returns one if
	      it succeeds, zero otherwise.  Automatically done	by  svc_regis‐
	      ter().

       pmap_unset(prognum, versnum)
       u_long prognum, versnum;

	      A user interface to the portmap service, which destroys all map‐
	      ping between the triple [prognum,versnum,*]  and	ports  on  the
	      machine's	 portmap  service. This routine returns one if it suc‐
	      ceeds, zero otherwise.

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

	      Register procedure procname with the RPC service package.	 If  a
	      request arrives for program prognum, version versnum, and proce‐
	      dure procnum, procname is called with a pointer to  its  parame‐
	      ter(s);	progname   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 restric‐
	      tions.

       struct rpc_createerr	rpc_createerr;

	      A global variable whose value is set by any RPC client  creation
	      routine  that does not succeed.  Use the routine clnt_pcreateer‐
	      ror() to print the reason why.

       svc_destroy(xprt)
       SVCXPRT *
       xprt;

	      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.

       fd_set svc_fdset;

	      A	 global	 variable  reflecting the RPC service side's read file
	      descriptor bit mask; it is suitable as a parameter to the select
	      system  call.  This is only of interest if a service implementor
	      does not call svc_run(), but rather does	his  own  asynchronous
	      event  processing.   This variable is read-only (do not pass its
	      address to select!), yet it may change after calls to svc_getre‐
	      qset() or any creation routines.

       int svc_fds;

	      Similar  to  svc_fedset(),  but  limited to 32 descriptors. This
	      interface is obsoleted by svc_fdset().

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

	      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  suc‐
	      cessfully freed, and zero otherwise.

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

	      A	 macro that decodes the arguments of an RPC request associated
	      with the RPC service transport handle, xprt.  The	 parameter  in
	      is the address where the arguments will be placed; inproc is the
	      XDR routine used to decode the arguments.	 This routine  returns
	      one if decoding succeeds, and zero otherwise.

       struct sockaddr_in *
       svc_getcaller(xprt)
       SVCXPRT *xprt;

	      The approved way of getting the network address of the caller of
	      a procedure associated with the RPC  service  transport  handle,
	      xprt.

       svc_getreqset(rdfds)
       fd_set *rdfds;

	      This  routine  is only of interest if a service implementor does
	      not call svc_run(), but instead implements  custom  asynchronous
	      event  processing.  It is called when the select 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 returns when all sockets associated with	the  value  of
	      rdfds have been serviced.

       svc_getreq(rdfds)
       int rdfds;

	      Similar  to svc_getreqset(), but limited to 32 descriptors. This
	      interface is obsoleted by svc_getreqset().

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

	      Associates prognum and versnum with the service dispatch	proce‐
	      dure,  dispatch.	If protocol is zero, the service is not regis‐
	      tered with the portmap 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  service
	      (generally  protocol is zero, IPPROTO_UDP or IPPROTO_TCP ).  The
	      procedure dispatch has the following form:
		 dispatch(request, xprt)
		 struct svc_req *request;
		 SVCXPRT *xprt;

	      The svc_register() routine returns one if it succeeds, and  zero
	      otherwise.

       svc_run()

	      This routine never returns. It waits for RPC requests to arrive,
	      and calls the appropriate service procedure  using  svc_getreq()
	      when  one	 arrives.  This	 procedure  is	usually	 waiting for a
	      select() system call to return.

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

	      Called by an RPC service's dispatch routine to send the  results
	      of a remote procedure call.  The parameter xprt is the request'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	other‐
	      wise.

       void
       svc_unregister(prognum, versnum)
       u_long prognum, versnum;

	      Remove  all  mapping of the double [prognum,versnum] to dispatch
	      routines, and of the triple [prognum,versnum,*] to port number.

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

	      Called by a service dispatch routine that refuses to  perform  a
	      remote procedure call due to an authentication error.

       void
       svcerr_decode(xprt)
       SVCXPRT *xprt;

	      Called  by  a  service dispatch routine that cannot successfully
	      decode its parameters. See also svc_getargs().

       void
       svcerr_noproc(xprt)
       SVCXPRT *xprt;

	      Called by a service dispatch routine that does not implement the
	      procedure number that the caller requests.

       void
       svcerr_noprog(xprt)
       SVCXPRT *xprt;

	      Called  when  the desired program is not registered with the RPC
	      package. Service implementors usually do not need this routine.

       void
       svcerr_progvers(xprt)
       SVCXPRT *xprt;

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

       void
       svcerr_systemerr(xprt)
       SVCXPRT *xprt;

	      Called by a service dispatch routine when it  detects  a	system
	      error not covered by any particular protocol.  For example, if a
	      service can no longer allocate storage, it may  call  this  rou‐
	      tine.

       void
       svcerr_weakauth(xprt)
       SVCXPRT *xprt;

	      Called  by  a service dispatch routine that refuses to perform a
	      remote procedure call due to insufficient authentication parame‐
	      ters.  The routine calls svcerr_auth(xprt, AUTH_TOOWEAK).

       SVCXPRT *
       svcraw_create()

	      This  routine  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 rou‐
	      tine  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.

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

	      This  routine  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 buffers; values of zero choose
	      suitable defaults.

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

	      Create a service on top of any open descriptor. Typically,  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 cho‐
	      sen.

       SVCXPRT *
       svcudp_bufcreate(sock, sendsize, recosize)
       int sock;

	      This routine 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 com‐
	      pletion, 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.

	      This  allows  the	 user  to  specify the maximun packet size for
	      sending and receiving UDP-based RPC messages.

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

	      Used for encoding RPC reply messages. This routine is useful for
	      users  who wish to generate RPC-style messages without using the
	      RPC package.

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

	      Used for describing UNIX credentials. This routine is useful for
	      users  who  wish to generate these credentials without using the
	      RPC authentication package.

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

	      Used for describing RPC call header messages.  This  routine  is
	      useful for users who wish to generate RPC-style messages without
	      using the RPC package.

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

	      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(xdrs, ap)
       XDR *xdrs;
       struct opaque_auth *ap;

	      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(xdrs, regs)
       XDR *xdrs;
       struct pmap *regs;

	      Used for describing parameters to	 various  portmap  procedures,
	      externally.  This routine is useful for users who wish to gener‐
	      ate these parameters without using the pmap interface.

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

	      Used for describing a list of port mappings,  externally.	  This
	      routine  is  useful for users who wish to generate these parame‐
	      ters without using the pmap interface.

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

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

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

	      Used for describing RPC reply messages.  This routine is	useful
	      for  users who wish to generate RPC style messages without using
	      the RPC package.

       void
       xprt_register(xprt)
       SVCXPRT *xprt;

	      After RPC service transport handles  are	created,  they	should
	      register	themselves with the RPC service package.  This routine
	      modifies the global variable  svc_fds().	 Service  implementors
	      usually do not need this routine.

       void
       xprt_unregister(xprt)
       SVCXPRT *xprt;

	      Before  an  RPC service transport handle is destroyed, it should
	      unregister itself with the RPC service  package.	 This  routine
	      modifies	the  global  variable svc_fds().  Service implementors
	      usually do not need this routine.

SEE ALSO
       rpc_secure(3N), xdr(3N)
       The following manuals:
	      Remote Procedure Calls: Protocol Specification
	      Remote Procedure Call Programming Guide
	      rpcgen Programming Guide
       RPC:  Remote  Procedure	Call  Protocol	Specification,	RFC1050,   Sun
       Microsystems, Inc., USC-ISI.

			       16 February 1988			       RPC(3N)
[top]

List of man pages available for MacOSX

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
...................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net