| 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 —
#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);
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()auth_destroy().authnone_create()authunix_create()authunix_create_default()authunix_create() with the appropriate
      parameters.callrpc()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()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()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()clnt_destroy(). If the RPC
      library opened the associated socket, it will close it also. Otherwise,
      the socket remains open.clnt_create()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()Note: if you set the timeout using
            clnt_control(), the timeout parameter passed
            to clnt_call() will be ignored in all future
            calls.
The following operations are valid for UDP only:
The retry timeout is the time that UDP RPC waits for the server to reply before retransmitting the request.
clnt_freeres()clnt_geterr()clnt_pcreateerror()clnt_create(),
      clntraw_create(),
      clnttcp_create(), or
      clntudp_create() call fails.clnt_perrno()callrpc().clnt_perror()clnt_call().clnt_spcreateerror()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.
clnt_sperrno()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.
    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(3), or if a message
        format different than that supported by
        clnt_perrno() is to be used. Note: unlike
        clnt_sperror() and
        clnt_spcreateerror(),
        clnt_sperrno() returns a pointer to static data,
        but the result will not get overwritten on each call.
clnt_sperror()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.
clntraw_create()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.clnttcp_create()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.clntudp_create()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 procedures that take large arguments or return huge results.
clntudp_bufcreate()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 maximum packet size for sending and receiving UDP-based RPC messages.
get_myaddress()htons(PMAPPORT). Returns
      zero on success, non-zero on failure.pmap_getmaps()NULL. The command
    rpcinfo
      -ppmap_getport()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 rpcbind(8) service.
      In the latter case, the global variable
      rpc_createerr() contains the RPC status.pmap_rmtcall()callrpc() and
      clnt_call(). This procedure should be used for a
      “ping” and nothing else. See also
      clnt_broadcast().pmap_set()IPPROTO_UDP or
      IPPROTO_TCP. This routine returns one if it
      succeeds, zero otherwise. Automatically done by
      svc_register().pmap_unset()registerrpc()Warning: remote procedures registered in this form are
        accessed using the UDP/IP transport; see
        svcudp_bufcreate() for restrictions.
clnt_pcreateerror() to print the reason why.svc_destroy()svc_run(), but rather does his own asynchronous
      event processing. This variable is read-only (do not pass its address to
      select(2)!), yet it may
      change after calls to svc_getreqset() or any
      creation routines.svc_fedset(), but limited to 32
      descriptors. This interface is obsoleted by
      svc_fdset().svc_freeargs()svc_getargs(). This routine returns 1 if the
      results were successfully freed, and zero otherwise.svc_getargs()svc_getcaller()svc_getrpccaller().svc_getreqset()svc_run(), but instead implements custom
      asynchronous event processing. It is called when the
      select(2) 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()svc_getreqset(), but limited to 32
      descriptors. This interface is obsoleted by
      svc_getreqset().svc_getrpccaller()svc_register()IPPROTO_UDP or
      IPPROTO_TCP). The procedure
      dispatch has the following form:
      int
      dispatch(struct svc_req
      *request, SVCXPRT *xprt).
    The svc_register() routine returns one
        if it succeeds, and zero otherwise.
svc_run()svc_getreq() when one arrives. This procedure is
      usually waiting for a
      select(2) system call to
      return.svc_sendreply()svc_unregister()svcerr_auth()svcerr_decode()svc_getargs().svcerr_noproc()svcerr_noprog()svcerr_progvers()svcerr_systemerr()svcerr_weakauth()svcerr_auth(xprt,
      AUTH_TOOWEAK).svcraw_create()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.svctcp_create()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.svcfd_create()svcudp_bufcreate()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 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 maximum packet size for sending and receiving UDP-based RPC messages.
svcudp_create()svcudp_bufcreate() with predefined
      sizes for the maximum packet sizes.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()The following manuals:
Remote Procedure Calls: Protocol Specification.
Remote Procedure Call Programming Guide.
rpcgen Programming Guide.
Sun Microsystems, Inc., USC-ISI, RPC: Remote Procedure Call Protocol Specification, RFC, 1050.
| December 29, 2016 | NetBSD 10.0 |