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 informa­
              tion 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 infor­
              mation 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 param­

       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 rou­
              tine clnt_perrno() is handy for translating failure
              statuses into messages.

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

       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 broad­
              cast 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 proce­
              dure'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.

       enum clnt_stat
       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 out­
              proc  is  used  to  decode the procedure'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 usually involves deallocation  of  pri­
              vate  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 arguments or return huge
              results.

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

              A macro used to change or retrieve various informa­
              tion. 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 timevalset the retry timeout
              CLGET_RETRY_TIMEOUT struct timevalget 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  describing
              the  results.   This  routine  returns  one  if the
              results were successfully freed,  and  zero  other­
              wise.

       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 mes­
              sage is prepended with string s and a colon.   Used
              when     a     clnt_create(),     clntraw_create(),
              clnttcp_create(), or clntudp_create() call fails.

       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  over­
              written 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 dif­
              ferent 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 over­
              written on each call.

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

              Like    clnt_perror(),    except     that     (like

              Bugs: returns pointer to static data that is  over­
              written 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 transport. The remote program is
              located   at    Internet    address    addr.     If
              remote portmap service is consulted for this infor­
              mation). 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 can­
              not be used for procedures that  take  large  argu­
              ments 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 infor­
              mation). 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 mes­
              sages.

       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 *

              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 ver­
              snum, 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 modi­
              fied to the program's port number if the  procedure
              succeeds.  The  definitions of other parameters are
              discussed in callrpc() and clnt_call().  This  pro­
              cedure  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  rou­
              tine  returns  one  if it succeeds, zero otherwise.

       u_long prognum, versnum;

              A user interface  to  the  portmap  service,  which
              destroys    all    mapping   between   the   triple
              [prognum,versnum,*]  and  ports  on  the  machine's
              portmap  service.  This  routine  returns one if it
              succeeds, 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 procedure procnum, procname is
              called with a pointer to its parameter(s); progname
              should return a pointer to  its  static  result(s);
              inproc  is used to decode the parameters while out­
              proc is used to encode the results.   This  routine
              returns zero if the registration succeeded, -1 oth­
              erwise.

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

       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_pcreateerror() to print the reason
              why.

       svc_destroy(xprt)
       SVCXPRT *
       xprt;

              A  macro  that  destroys  the RPC service transport
              handle, xprt.  Destruction usually involves deallo­
              cation  of  private data structures, 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
              tines.

       int svc_fds;

              Similar  to  svc_fdset,  but limited to 32 descrip­
              tors. 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  rou­
              tine  returns  1  if  the results were successfully
              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 deter­
              mined 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.


              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 procedure, dispatch.  If protocol is zero,
              the service is not registered with the portmap ser­
              vice.   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 fol­
              lowing form:
                 dispatch(request, xprt)
                 struct svc_req *request;
                 SVCXPRT *xprt;

              The svc_register() routine returns one if  it  suc­
              ceeds, and zero otherwise.

       svc_run()

              This  routine  never  returns.  It  waits  for  RPC
              requests to arrive, and calls the appropriate  ser­
              vice 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 param­
              eter  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 otherwise.

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

              [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  implemen­
              tors 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  particu­
              lar  protocol.   For  example,  if a service can no
              longer allocate storage, it may call this  routine.

       SVCXPRT *xprt;

              Called  by  a service dispatch routine that refuses
              to perform a remote procedure call due to  insuffi­
              cient authentication parameters.  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
              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.

       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 trans­
              port'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
              chosen.

       SVCXPRT *

              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 completion, xprt->xp_sock is the  trans­
              port'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  mes­
              sages.

       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 cre­
              dentials without using the RPC authentication pack­
              age.

       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  rou­
              tine  is useful for users who wish to generate RPC-
              style messages without using the RPC package.

       xdr_opaque_auth(xdrs, ap)
       XDR *xdrs;
              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 generate these parameters without
              using the pmap interface.

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

              Used for describing a list of port mappings, exter­
              nally.   This  routine is useful for users who wish
              to generate these parameters without using the pmap
              interface.

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

              Used  for describing RPC reply messages.  This rou­
              tine 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 rou­
              tine 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  ser­
              vice  package.   This  routine  modifies the global
              variable svc_fds().  Service  implementors  usually
              do not need this routine.

       void
       xprt_unregister(xprt)
       SVCXPRT *xprt;

              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.