Seth Woolley's Man Viewer

Manual for rpc - man 3 rpc

([section] manual, -k keyword, -K [section] search, -f whatis)
man plain no title

RPC(3)                                                                  RPC(3)



NAME
       rpc(3,5,8) - 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(2,n)  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(1,8) rpc_secure(3).  Secure RPC can be used only if(3,n) DES encryp-
       tion is available.

       #include <rpc(3,5,8)/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(1,5), uid, gid, len, aup_gids)
       char *host(1,5);
       int uid, gid, len, *aup.gids;

              Create  and  return  an  RPC authentication handle that contains
              authentication information.  The parameter host(1,5) 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(1,5), prognum, versnum, procnum, inproc, in(1,8), outproc, out)
       char *host(1,5);
       u_long prognum, versnum, procnum;
       char *in(1,8), *out;
       xdrproc_t inproc, outproc;

              Call the remote procedure associated with prognum, versnum,  and
              procnum  on  the machine, host(1,5).  The parameter in(1,8) 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(3,n) it succeeds, or the value
              of enum clnt_stat cast to an integer if(3,n) 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(1,8), outproc, out, eachresult)
       u_long prognum, versnum, procnum;
       char *in(1,8), *out;
       xdrproc_t inproc, outproc;
       resultproc_t eachresult;

              Like  callrpc(),  except  the  call  message is broadcast to all
              locally connected  broadcast  nets.  Each  time(1,2,n)  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(1,8) 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(1,8), outproc, out, tout)
       CLIENT *clnt;
       u_long
       procnum;
       xdrproc_t inproc, outproc;
       char *in(1,8), *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(1,8) 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(1,2,n) 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(2,7,n), it will close(2,7,n) it also.  Otherwise,  the  socket(2,7,n)  remains
              open.

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

              Generic  client  creation  routine.  host(1,5) identifies the name of
              the remote host(1,5) 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(7,n,1 builtins), 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(1,5,n))
       CLIENT *cl;
       char *info(1,5,n);

              A macro used to change or retrieve various information  about  a
              client object.  req indicates the type of operation, and info(1,5,n) 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(7,n,1 builtins) total timeout(1,3x,3x cbreak)
              CLGET_TIMEOUT       struct timeval      get total timeout(1,3x,3x cbreak)

              Note: if(3,n) you set(7,n,1 builtins) the timeout(1,3x,3x cbreak) using clnt_control(),  the  timeout(1,3x,3x cbreak)
              parameter  passed  to  clnt_call() will be ignored in(1,8) 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(7,n,1 builtins) the retry timeout(1,3x,3x cbreak)
              CLGET_RETRY_TIMEOUT struct timeval      get the retry timeout(1,3x,3x cbreak)

              The retry timeout(1,3x,3x cbreak) is the time(1,2,n) 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(3,n) 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(8,n) structure out of the client handle
              to the structure at address errp.

       void
       clnt_pcreateerror(s)
       char *s;

              Print a message to standard error(8,n) indicating why  a  client  RPC
              handle  could  not  be  created.   The message is prepended with
              string(3,n) s and a colon.  Used when a  clnt_create(),  clntraw_cre-
              ate(), clnttcp_create(), or clntudp_create() call fails.

       void
       clnt_perrno(stat(1,2))
       enum clnt_stat stat(1,2);

              Print a message to standard error(8,n) corresponding to the condition
              indicated by stat(1,2).  Used after callrpc().

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

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

       char *
       clnt_spcreateerror
       char *s;

              Like  clnt_pcreateerror(),  except  that  it  returns  a  string(3,n)
              instead of printing to the standard error.

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

       char *
       clnt_sperrno(stat(1,2))
       enum clnt_stat stat(1,2);

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

              clnt_sperrno()  is  used instead of clnt_perrno() if(3,n) the program
              does not have a standard error(8,n) (as a program running as a server
              quite  likely  does not), or if(3,n) the programmer does not want the
              message to be output with printf(1,3,1 builtins), or if(3,n) 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(3,n) 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(1,3,5)  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(1,8) 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(3,n) 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(1,3,5) 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(7,n,1 builtins) 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(2,7,n);  if(3,n) 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(2,n) and receive buffers with
              the parameters sendsz and recvsz; values of zero choose suitable
              defaults.  This routine returns NULL if(3,n) 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(1,3,5) 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(7,n,1 builtins) 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(2,7,n);  if(3,n) it is RPC_ANYSOCK, then this routine opens a new one
              and sets sockp.  The UDP transport resends the call  message  in(1,8)
              intervals of wait time(1,2,n) until a response is received or until the
              call times out.  The total time(1,2,n) for the  call  to  time(1,2,n)  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(7,n,1 builtins) 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(2,7,n);  if(3,n) it is RPC_ANYSOCK, then this routine opens a new one
              and sets sockp.  The UDP transport resends the call  message  in(1,8)
              intervals of wait time(1,2,n) until a response is received or until the
              call times out.  The total time(1,2,n) for the  call  to  time(1,2,n)  out  is
              specified by clnt_call().

              This  allows  the  user  to  specify the maximum 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(7,n,1 builtins) 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(1,5) 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(1,3,5)  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 failed to con-
              tact 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(1,8), outproc, out, tout, portp)
       struct sockaddr_in *addr;
       u_long prognum, versnum, procnum;
       char *in(1,8), *out;
       xdrproc_t inproc, outproc;
       struct timeval tout;
       u_long *portp;

              A user interface to the portmap service, which instructs portmap
              on  the  host(1,5)  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(3,n) the procedure suc-
              ceeds. The definitions of  other  parameters  are  discussed  in(1,8)
              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(3,n)
              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(3,n) 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(1,3,5) 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(3,n) the
              registration succeeded, -1 otherwise.

              Warning: remote procedures registered in(1,8) 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(7,n,1 builtins) 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(2,n,1 builtins) file(1,n)
              descriptor bit mask; it is suitable as a parameter to the select(2,7,2 select_tut)
              system  call.  This is only of interest if(3,n) 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(2,7,2 select_tut)!), yet it may change after calls to svc_getre-
              qset() or any creation routines.

       int svc_fds;

              Similar to svc_fdset, but limited to 32 descriptors. This inter-
              face is obsoleted by svc_fdset.

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

              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(3,n) the results were  suc-
              cessfully freed, and zero otherwise.

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

              A  macro that decodes the arguments of an RPC request associated
              with the RPC service transport handle, xprt.  The  parameter  in(1,8)
              is the address where the arguments will be placed; inproc is the
              XDR routine used to decode the arguments.  This routine  returns
              one if(3,n) 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(3,n) a service implementor does
              not call svc_run(), but instead implements  custom  asynchronous
              event  processing.  It is called when the select(2,7,2 select_tut) system call has
              determined that an RPC request has arrived on some RPC socket(2,7,n)(s)
              ;  rdfds  is  the  resultant read(2,n,1 builtins) file(1,n) 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(3,n) 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(2,7,2 select_tut)() 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(2,n) 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(3,n) 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(1,3,5) 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(8,n) not covered by any particular protocol.  For example, if(3,n) 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 *
       svcfd_create(fd, sendsize, recvsize)
       int fd;
       u_int sendsize;
       u_int recvsize;

              Create  a service on top of any open(2,3,n) descriptor. Typically, this
              descriptor is a connected socket(2,7,n) for a stream protocol  such  as
              TCP.   sendsize  and  recvsize  indicate  sizes for the send(2,n) and
              receive buffers.  If they are zero, a reasonable default is cho-
              sen.

       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(1,8) 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(3,n) 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(2,7,n)  sock, which may be RPC_ANYSOCK, in(1,8) which case a new
              socket(2,7,n) is created.  If the socket(2,7,n) 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(2,7,n)  descriptor,
              and  xprt->xp_port is the transport's port number.  This routine
              returns NULL if(3,n) it fails. Since TCP-based RPC uses buffered  I/O
              ,  users(1,5)  may specify the size of buffers; values of zero choose
              suitable defaults.

       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(2,7,n) sock, which may be RPC_ANYSOCK , in(1,8) which case a  new
              socket(2,7,n)  is  created.   If the socket(2,7,n) 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(2,7,n) descriptor, and
              xprt->xp_port is the  transport's  port  number.   This  routine
              returns NULL if(3,n) it fails.

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

       SVCXPRT *
       svcudp_create(sock)
       int sock;

              This call is equivalent to svcudp_bufcreate(sock,SZ,SZ) for some
              default size SZ.

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

              Used for encoding(3,n) RPC reply messages. This routine is useful for
              users(1,5) 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(1,5) 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(1,5) 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(1,5) 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(1,5) 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(1,5) 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(1,5) 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(1,5) 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(1,5) 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(3), xdr(3)
       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.



                                  1988-02-16                            RPC(3)

References for this manual (incoming links)