I would appreciate any donations. Wishlist or send e-mail type donations to maekawa AT daemon-systems.org.

Thank you.

RPC_SOC(3)                 Library Functions Manual                 RPC_SOC(3)

     rpc_soc, auth_destroy, authnone_create, authunix_create,
     authunix_create_default, callrpc, clnt_broadcast, clnt_call,
     clnt_control, clnt_create, clnt_destroy, clnt_freeres, clnt_geterr,
     clnt_pcreateerror, clnt_perrno, clnt_perror, clnt_spcreateerror,
     clnt_sperrno, clnt_sperror, clntraw_create, clnttcp_create,
     clntudp_bufcreate, clntudp_create, get_myaddress, pmap_getmaps,
     pmap_getport, pmap_rmtcall, pmap_set, pmap_unset, registerrpc,
     rpc_createerr, svc_destroy, svc_fds, svc_fdset, svc_getargs,
     svc_getcaller, svc_getreg, svc_getregset, svc_getrpccaller, svc_register,
     svc_run, svc_sendreply, svc_unregister, svcerr_auth, svcerr_decode,
     svcerr_noproc, svcerr_noprog, svcerr_progvers, svcerr_systemerr,
     svcerr_weakauth, svcfd_create, svcraw_create, xdr_accepted_reply,
     xdr_authunix_parms, xdr_callhdr, xdr_callmsg, xdr_opaque_auth, xdr_pmap,
     xdr_pmaplist, xdr_rejected_reply, xdr_replymsg, xprt_register,
     xprt_unregister - library routines for remote procedure calls

     #include <rpc/rpc.h>

     auth_destroy(AUTH *auth);

     AUTH *

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

     AUTH *

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

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

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

     clnt_destroy(CLIENT *clnt);

     CLIENT *
     clnt_create(const char *host, rpcprog_t prog, rpcvers_t vers,
         const char *proto);

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

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

     clnt_geterr(CLIENT *clnt, struct rpc_err errp);

     clnt_pcreateerror(const char *s);

     clnt_perrno(enum clnt_stat stat);

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

     char *
     clnt_spcreateerror(const char *s);

     char *
     clnt_sperrno(enum clnt_stat stat);

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

     CLIENT *
     clntraw_create(u_long prognum, u_long versnum);

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

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

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

     get_myaddress(struct sockaddr_in *addr);

     struct pmaplist *
     pmap_getmaps(struct sockaddr_in *addr);

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

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

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

     pmap_unset(u_long prognum, u_long versnum);

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

     struct rpc_createerr rpc_createerr;

     svc_destroy(SVCXPRT *xprt);

     fd_set svc_fdset;
     int svc_fds;

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

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

     struct sockaddr_in *
     svc_getcaller(SVCXPRT *xprt);

     svc_getreqset(fd_set *rdfds);

     svc_getreq(int rdfds);

     struct netbuf *
     svc_getrpccaller(SVCXPRT *xprt);

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


     svc_sendreply(SVCXPRT *xprt, xdrproc_t xdr_results,
         const char *location);

     svc_unregister(u_long prognum, u_long versnum);

     svcerr_auth(SVCXPRT *xprt, enum auth_stat why);

     svcerr_decode(SVCXPRT *xprt);

     svcerr_noproc(SVCXPRT *xprt);

     svcerr_noprog(SVCXPRT *xprt);

     svcerr_progvers(SVCXPRT *xprt, rpcvers_t low_vers, rpcvers_t high_vers);

     svcerr_systemerr(SVCXPRT *xprt);

     svcerr_weakauth(SVCXPRT *xprt);

     SVCXPRT *

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

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

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

     SVCXPRT *
     svcudp_create(int sock);

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

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

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

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

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

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

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

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

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

     xprt_register(SVCXPRT *xprt);

     xprt_unregister(SVCXPRT *xprt);

     The svc and clnt functions described in this page are the old, TS-RPC
     interface to the XDR and RPC library, and exist for backward
     compatibility. The new interface is described in the pages referenced
     from rpc(3).

     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.

          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

          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.

          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.

          Calls authunix_create() with the appropriate parameters.

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

          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 int eachresult(char *out,
          struct sockaddr_in *addr) where out is the same as out passed to
          clnt_broadcast(), except that the remote procedure's output is
          decoded there; addr points to the address of the machine that sent
          the results.  If eachresult() returns zero, clnt_broadcast() waits
          for more replies; otherwise it returns with appropriate status.

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

          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 procedure's results;
          tout is the time allowed for results to come back.

          A macro that destroys the client's RPC handle.  Destruction usually
          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.

          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.

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

          CLSET_TIMEOUT         struct timeval; set total timeout.

          CLGET_TIMEOUT         struct timeval; get total timeout.

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

          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.

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

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

          Print a message to standard error ind