#if !defined(lint) && defined(SCCSIDS)
static char sccsid[] = "@(#)clnt_raw.c 1.22 87/08/11 Copyr 1984 Sun Micro";
#endif
#include <gssrpc/rpc.h>
#define MCALL_MSG_SIZE 24
static struct clntraw_private {
CLIENT client_object;
XDR xdr_stream;
char _raw_buf[UDPMSGSIZE];
union {
struct rpc_msg mashl_rpcmsg;
char mashl_callmsg[MCALL_MSG_SIZE];
} u;
u_int mcnt;
} *clntraw_private;
static enum clnt_stat clntraw_call(CLIENT *, rpcproc_t, xdrproc_t,
void *, xdrproc_t, void *,
struct timeval);
static void clntraw_abort(CLIENT *);
static void clntraw_geterr(CLIENT *, struct rpc_err *);
static bool_t clntraw_freeres(CLIENT *, xdrproc_t, void *);
static bool_t clntraw_control(CLIENT *, int, void *);
static void clntraw_destroy(CLIENT *);
static struct clnt_ops client_ops = {
clntraw_call,
clntraw_abort,
clntraw_geterr,
clntraw_freeres,
clntraw_destroy,
clntraw_control
};
void svc_getreq();
CLIENT *
clntraw_create(
rpcprog_t prog,
rpcvers_t vers)
{
register struct clntraw_private *clp = clntraw_private;
struct rpc_msg call_msg;
XDR *xdrs = &clp->xdr_stream;
CLIENT *client = &clp->client_object;
if (clp == 0) {
clp = (struct clntraw_private *)calloc(1, sizeof (*clp));
if (clp == 0)
return (0);
clntraw_private = clp;
}
call_msg.rm_direction = CALL;
call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
call_msg.rm_call.cb_prog = prog;
call_msg.rm_call.cb_vers = vers;
xdrmem_create(xdrs, clp->u.mashl_callmsg, MCALL_MSG_SIZE, XDR_ENCODE);
if (! xdr_callhdr(xdrs, &call_msg)) {
perror("clnt_raw.c - Fatal header serialization error.");
}
clp->mcnt = XDR_GETPOS(xdrs);
XDR_DESTROY(xdrs);
xdrmem_create(xdrs, clp->_raw_buf, UDPMSGSIZE, XDR_FREE);
client->cl_ops = &client_ops;
client->cl_auth = authnone_create();
return (client);
}
static enum clnt_stat
clntraw_call(
CLIENT *h,
rpcproc_t proc,
xdrproc_t xargs,
void * argsp,
xdrproc_t xresults,
void * resultsp,
struct timeval timeout)
{
register struct clntraw_private *clp = clntraw_private;
register XDR *xdrs = &clp->xdr_stream;
struct rpc_msg msg;
enum clnt_stat status;
struct rpc_err error;
long procl = proc;
if (clp == 0)
return (RPC_FAILED);
call_again:
xdrs->x_op = XDR_ENCODE;
XDR_SETPOS(xdrs, 0);
clp->u.mashl_rpcmsg.rm_xid ++ ;
if ((! XDR_PUTBYTES(xdrs, clp->u.mashl_callmsg, clp->mcnt)) ||
(! XDR_PUTLONG(xdrs, &procl)) ||
(! AUTH_MARSHALL(h->cl_auth, xdrs)) ||
(! (*xargs)(xdrs, argsp))) {
return (RPC_CANTENCODEARGS);
}
(void)XDR_GETPOS(xdrs);
svc_getreq(1);
xdrs->x_op = XDR_DECODE;
XDR_SETPOS(xdrs, 0);
msg.acpted_rply.ar_verf = gssrpc__null_auth;
msg.acpted_rply.ar_results.where = resultsp;
msg.acpted_rply.ar_results.proc = xresults;
if (! xdr_replymsg(xdrs, &msg)) {
enum xdr_op op = xdrs->x_op;
xdrs->x_op = XDR_FREE;
xdr_replymsg(xdrs, &msg);
xdrs->x_op = op;
return (RPC_CANTDECODERES);
}
gssrpc__seterr_reply(&msg, &error);
status = error.re_status;
if (status == RPC_SUCCESS) {
if (! AUTH_VALIDATE(h->cl_auth, &msg.acpted_rply.ar_verf)) {
status = RPC_AUTHERROR;
}
}
else {
if (AUTH_REFRESH(h->cl_auth, &msg))
goto call_again;
}
if (status == RPC_SUCCESS) {
if (! AUTH_VALIDATE(h->cl_auth, &msg.acpted_rply.ar_verf)) {
status = RPC_AUTHERROR;
}
if (msg.acpted_rply.ar_verf.oa_base != NULL) {
xdrs->x_op = XDR_FREE;
(void)xdr_opaque_auth(xdrs, &(msg.acpted_rply.ar_verf));
}
}
return (status);
}
static void
clntraw_geterr(
CLIENT *cl,
struct rpc_err *err)
{
}
static bool_t
clntraw_freeres(
CLIENT *cl,
xdrproc_t xdr_res,
void *res_ptr)
{
register struct clntraw_private *clp = clntraw_private;
register XDR *xdrs = &clp->xdr_stream;
bool_t rval;
if (clp == 0)
{
rval = (bool_t) RPC_FAILED;
return (rval);
}
xdrs->x_op = XDR_FREE;
return ((*xdr_res)(xdrs, res_ptr));
}
static void
clntraw_abort(CLIENT *cl)
{
}
static bool_t
clntraw_control(
CLIENT *cl,
int request,
void *info)
{
return (FALSE);
}
static void
clntraw_destroy(CLIENT *cl)
{
}