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)

NAME
     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

SYNOPSIS
     #include <rpc/rpc.h>

     void
     auth_destroy(AUTH *auth);

     AUTH *
     authnone_create(void);

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

     AUTH *
     authunix_create_default(void);

     int
     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);

     int
     clnt_destroy(CLIENT *clnt);

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

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

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

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

     void
     clnt_pcreateerror(const char *s);

     void
     clnt_perrno(enum clnt_stat stat);

     void
     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);

     int
     get_myaddress(struct sockaddr_in *addr);

     struct pmaplist *
     pmap_getmaps(struct sockaddr_in *addr);

     u_short
     pmap_getport(struct sockaddr_in *addr, u_long prognum, u_long versnum,
         u_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);

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

     int
     pmap_unset(u_long prognum, u_long versnum);

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

     struct rpc_createerr rpc_createerr;

     int
     svc_destroy(SVCXPRT *xprt);

     fd_set svc_fdset;
     int svc_fds;

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

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

     struct sockaddr_in *
     svc_getcaller(SVCXPRT *xprt);

     void
     svc_getreqset(fd_set *rdfds);

     void
     svc_getreq(int rdfds);

     struct netbuf *
     svc_getrpccaller(SVCXPRT *xprt);

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

     void
     svc_run(void);

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

     void
     svc_unregister(u_long prognum, u_long versnum);

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

     void
     svcerr_decode(SVCXPRT *xprt);

     void
     svcerr_noproc(SVCXPRT *xprt);

     void
     svcerr_noprog(SVCXPRT *xprt);

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

     void
     svcerr_systemerr(SVCXPRT *xprt);

     void
     svcerr_weakauth(SVCXPRT *xprt);

     SVCXPRT *
     svcraw_create(void);

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

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

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

     SVCXPRT *
     svcudp_create(int sock);

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

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

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

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

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

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

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

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

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

     bool_t
     xprt_register(SVCXPRT *xprt);

     void
     xprt_unregister(SVCXPRT *xprt);

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

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

     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.

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

     authunix_create_default()
          Calls authunix_create() with the appropriate parameters.

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

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

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

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

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

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

          CLSET_TIMEOUT         struct timeval; set total timeout.

          CLGET_TIMEOUT         struct timeval; get total timeout.

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

          CLGET_SERVER_ADDR     struct sockaddr_in; get server's address.

          The following operations are valid for UDP only:

          CLSET_RETRY_TIMEOUT  struct timeval; set the retry timeout.

          CLGET_RETRY_TIMEOUT  struct timeval; get the retry timeout.

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

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

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

     clnt_pcreateerror()
          Print a message to standard error ind