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
, u_long prognum
, u_long versnum
, u_long 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(
char *host
, u_long prog
, u_long vers
, 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(
char *s
)
void
clnt_perrno(
enum clnt_stat stat
)
int
clnt_perror(
CLIENT *clnt
, char *s
)
char
*
clnt_spcreateerror(
const char *s
)
char
*
clnt_sperrno(
enum clnt_stat stat
)
char
*
clnt_sperror(
CLIENT *rpch
, 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_long protocol
)
enum
clnt_stat
pmap_rmtcall(
struct sockaddr_in *addr
u_long prognum
u_long versnum
u_long procnum
xdrproc_t inproc
char *in
xdrpoc_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(
u_long prognum
, u_long versnum
, u_long procnum
, char *(*procname)()
, xdrproc_t inproc
, xdrproc_t outproc
)
int
svc_destroy(
SVCXPRT *xprt
)
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
)
int
svc_getreqset(
fd_set *rdfds
)
int
svc_getreq(
int rdfds
)
int
svc_register(
SVCXPRT *xprt
, u_long prognum
, u_long versnum
, void (*dispatch)()
, u_long protocol
)
int
svc_run(
void
)
int
svc_sendreply(
SVCXPRT *xprt
, xdrproc_t outproc
, char *out
)
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
)
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
)
void
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
)
void
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
.
Destruction usually involves deallocation of private data structures.
The use of
auth
is undefined after calling
auth_destroy(
).
)
)
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.
)
)
with the appropriate parameters.
)
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.
)
),
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.
)
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
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.
)
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.
)
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:
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.
)
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.
)
errp
.
)
s
and a colon.
A newline character is appended at the end of the message.
Used when a
clnt_create(
),
clntraw_create(
),
clnttcp_create(
),
or
clntudp_create(
)
call fails.
)
stat
.
A newline character is appended at the end of the message.
Used after
callrpc(
).
)
clnt
is the handle used to do the call.
The message is prepended with string
s
and a colon.
A newline character is appended at the end of the message.
Used after
clnt_call(
).
)
),
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.
)
),
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.
)
),
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.
)
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.
)
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
rpcbind(8)
or
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.
)
prognum
,
version
versnum
;
the client uses 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
rpcbind(8)
or
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.
)
prognum
,
on
versnum
;
the client uses 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
rpcbind(8)
or
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.
)
*addr
,
without consulting the library routines that deal with
/etc/hosts
.
The port number is always set to
htons(
PMAPPORT
).
Returns zero on success, non-zero on failure.
)
*addr
.
This routine can return
NULL
.
The command
rpcinfo -p
)
prognum
,
version
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 failured to contact the remote
rpcbind(8)
service.
In the latter case, the global variable
rpc_createerr(
)
contains the RPC status.
)
*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 the
procedure succeeds.
The definitions of other parameters are discussed in
callrpc(
)
and
clnt_call(
).
This procedure should be used for a
``ping''
and nothing else.
See also
clnt_broadcast(
).
)
[prognum
,
versnum
,
protocol
]
and
port
on the machine's
rpcbind(8)
service.
The value of
protocol
is most likely
IPPROTO_UDP
or
IPPROTO_TCP
.
This routine returns one if it succeeds, zero otherwise.
Automatically done by
svc_register(
).
)
[prognum
,
versnum
,
*
]
and
ports
on the machine's
rpcbind(8)
service.
This routine returns one if it succeeds, zero otherwise.
)
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
outproc
is used to encode the results.
This routine returns zero if the registration succeeded, -1
otherwise.
Warning: remote procedures registered in this form
are accessed using the UDP/IP transport; see
svcudp_bufcreate()
for restrictions.
)
to print the reason why.
)
xprt
.
Destruction usually involves deallocation
of private data structures, including
xprt
itself.
Use of
xprt
is undefined after calling this routine.
),
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.
),
but limited to 32 descriptors.
This interface is obsoleted by
svc_fdset(
).
)
).
This routine returns 1 if the results were successfully freed,
and zero otherwise.
)
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.
)
xprt
.
)
),
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.
)
),
but limited to 32 descriptors.
This interface is obsoleted by
svc_getreqset(
).
)
prognum
and
versnum
with the service dispatch procedure,
dispatch
.
If
protocol
is zero, the service is not registered with the
rpcbind(8)
service.
If
protocol
is non-zero, then a mapping of the triple
[prognum
,
versnum
,
protocol
]
to
xprt->xp_port
is established with the local
rpcbind(8)
service (generally
protocol
is zero,
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.
)
)
when one arrives.
This procedure is usually waiting for a
select(2)
system call to return.
)
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.
)
[prognum
,
versnum
]
to dispatch routines, and of the triple
[prognum
,
versnum
,
*
]
to port number.
)
)
).
)
)
)
)
)
xprt
, AUTH_TOOWEAK
).
)
).
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.
)
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 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.
)
sendsize
and
recvsize
indicate sizes for the send and receive buffers.
If they are zero, a reasonable default is chosen.
)
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 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.
)
with
)
predefined sizes for the maximum packet sizes.
)
)
)
)
)
)
)
)
)
)
)The following manuals: