static bool_t Svcudp_freeargs(SVCXPRT * xprt, xdrproc_t xdr_args, caddr_t args_ptr)
{
register XDR *xdrs = &(Su_data(xprt)->su_xdrs);
xdrs->x_op = XDR_FREE;
return ((*xdr_args) (xdrs, args_ptr));
}
static bool_t Svcudp_recv(register SVCXPRT * xprt, struct rpc_msg *msg)
{
register struct Svcudp_data *su = Su_data(xprt);
register XDR *xdrs = &(su->su_xdrs);
register int rlen;
again:
xprt->xp_addrlen = sizeof(struct sockaddr_in);
#ifdef _FREEBSD
rlen = recvfrom(xprt->xp_fd, rpc_buffer(xprt), (int)su->su_iosz,
0, (struct sockaddr *)&(xprt->xp_raddr), &(xprt->xp_addrlen));
#else
rlen = recvfrom(xprt->xp_sock, rpc_buffer(xprt), (int)su->su_iosz,
0, (struct sockaddr *)&(xprt->xp_raddr), &(xprt->xp_addrlen));
#endif
if(rlen == -1 && errno == EINTR)
goto again;
if(rlen == -1 || rlen < 4 * sizeof(u_int32_t))
return (FALSE);
xdrs->x_op = XDR_DECODE;
XDR_SETPOS(xdrs, 0);
if(!xdr_callmsg(xdrs, msg))
return (FALSE);
su->su_xid = msg->rm_xid;
return (TRUE);
}
void Svcudp_soft_destroy(register SVCXPRT * xprt)
{
register struct Svcudp_data *su = Su_data(xprt);
//XDR_DESTROY(&(su->su_xdrs));
Mem_Free(rpc_buffer(xprt));
Mem_Free((caddr_t) su);
Mem_Free((caddr_t) xprt);
}
static void Svcudp_destroy(register SVCXPRT * xprt)
{
register struct Svcudp_data *su = Su_data(xprt);
Xprt_unregister(xprt);
(void)close(xprt->XP_SOCK);
XDR_DESTROY(&(su->su_xdrs));
Mem_Free(rpc_buffer(xprt));
Mem_Free((caddr_t) su);
Mem_Free((caddr_t) xprt);
}
static void Svcudp_destroy(register SVCXPRT * xprt)
{
register struct Svcudp_data *su = Su_data(xprt);
Xprt_unregister(xprt);
#ifdef _FREEBSD
(void)close(xprt->xp_fd);
#else
(void)close(xprt->xp_sock);
#endif
XDR_DESTROY(&(su->su_xdrs));
Mem_Free(rpc_buffer(xprt));
Mem_Free((caddr_t) su);
Mem_Free((caddr_t) xprt);
}
static bool_t Svcudp_reply(register SVCXPRT * xprt, struct rpc_msg *msg)
{
register struct Svcudp_data *su = Su_data(xprt);
register XDR *xdrs = &(su->su_xdrs);
register int slen;
xdrproc_t xdr_proc;
caddr_t xdr_where;
xdrs->x_op = XDR_ENCODE;
XDR_SETPOS(xdrs, 0);
msg->rm_xid = su->su_xid;
if(msg->rm_reply.rp_stat == MSG_ACCEPTED && msg->rm_reply.rp_acpt.ar_stat == SUCCESS)
{
xdr_proc = msg->acpted_rply.ar_results.proc;
xdr_where = msg->acpted_rply.ar_results.where;
msg->acpted_rply.ar_results.proc = (xdrproc_t) xdr_void;
msg->acpted_rply.ar_results.where = NULL;
if(!xdr_replymsg(xdrs, msg) ||
!SVCAUTH_WRAP(xprt->xp_auth, xdrs, xdr_proc, xdr_where))
return (FALSE);
}
else if(!xdr_replymsg(xdrs, msg))
{
return (FALSE);
}
slen = (int)XDR_GETPOS(xdrs);
#ifdef _FREEBSD
if(sendto(xprt->xp_fd,
#else
if(sendto(xprt->xp_sock,
#endif
rpc_buffer(xprt),
slen, 0, (struct sockaddr *)&(xprt->xp_raddr), xprt->xp_addrlen) != slen)
{
return (FALSE);
}
return (TRUE);
}
static bool_t Svcudp_reply(register SVCXPRT * xprt, struct rpc_msg *msg)
{
register struct Svcudp_data *su = Su_data(xprt);
register XDR *xdrs = &(su->su_xdrs);
register int slen;
xdrproc_t xdr_proc;
caddr_t xdr_where;
xdrs->x_op = XDR_ENCODE;
XDR_SETPOS(xdrs, 0);
msg->rm_xid = su->su_xid;
if(msg->rm_reply.rp_stat == MSG_ACCEPTED && msg->rm_reply.rp_acpt.ar_stat == SUCCESS)
{
xdr_proc = msg->acpted_rply.ar_results.proc;
xdr_where = msg->acpted_rply.ar_results.where;
msg->acpted_rply.ar_results.proc = (xdrproc_t) xdr_void;
msg->acpted_rply.ar_results.where = NULL;
if(!xdr_replymsg(xdrs, msg) ||
!SVCAUTH_WRAP(xprt->xp_auth, xdrs, xdr_proc, xdr_where))
return (FALSE);
}
else if(!xdr_replymsg(xdrs, msg))
{
return (FALSE);
}
slen = (int)XDR_GETPOS(xdrs);
if(sendto(xprt->XP_SOCK,
rpc_buffer(xprt),
slen, 0, (struct sockaddr *)&(xprt->xp_raddr), xprt->xp_addrlen) != slen)
{
LogInfo(COMPONENT_DISPATCH, "EAGAIN indicates UDP buffer is full and not"
" allowed to block. sendto() returned %s", strerror(errno));
return (FALSE);
}
return (TRUE);
}
void FreeXprt(SVCXPRT *xprt)
{
if(!xprt)
{
LogFullDebug(COMPONENT_RPC,
"Attempt to free NULL xprt");
return;
}
LogFullDebug(COMPONENT_RPC,
"FreeXprt xprt=%p", xprt);
if(xprt->xp_ops == &Svcudp_op)
{
xp_free(Su_data(xprt));
xp_free(rpc_buffer(xprt));
}
else if (xprt->xp_ops == &Svctcp_op)
{
struct tcp_conn *cd = (struct tcp_conn *)xprt->xp_p1;
XDR_DESTROY(&(cd->xdrs));
xp_free(xprt->xp_p1); /* cd */
}
else if (xprt->xp_ops == &Svctcp_rendezvous_op)
{
xp_free(xprt->xp_p1); /* r */
}
else
{
LogCrit(COMPONENT_RPC,
"Attempt to free unknown xprt %p",
xprt);
return;
}
Mem_Free(xprt);
}
static bool_t Svcudp_getargs(SVCXPRT * xprt, xdrproc_t xdr_args, caddr_t args_ptr)
{
return (SVCAUTH_UNWRAP(xprt->xp_auth, &(Su_data(xprt)->su_xdrs), xdr_args, args_ptr));
}
/*
* Duplicate xprt from original to copy.
*/
SVCXPRT *Svcxprt_copy(SVCXPRT *xprt_copy, SVCXPRT *xprt_orig)
{
if(xprt_copy)
FreeXprt(xprt_copy);
xprt_copy = (SVCXPRT *) Mem_Alloc(sizeof(SVCXPRT));
if(xprt_copy == NULL)
goto fail_no_xprt;
LogFullDebug(COMPONENT_RPC,
"Svcxprt_copy copying xprt_orig=%p to xprt_copy=%p",
xprt_orig, xprt_copy);
memcpy(xprt_copy, xprt_orig, sizeof(SVCXPRT));
xprt_copy->xp_p1 = NULL;
xprt_copy->xp_p2 = NULL;
if(xprt_orig->xp_ops == &Svcudp_op)
{
if(Su_data(xprt_orig))
{
struct Svcudp_data *su_o = Su_data(xprt_orig), *su_c;
su_c = (struct Svcudp_data *) Mem_Alloc(sizeof(*su_c));
if(!su_c)
goto fail;
Su_data_set(xprt_copy) = (void *) su_c;
memcpy(su_c, su_o, sizeof(*su_c));
rpc_buffer(xprt_copy) = Mem_Alloc_Label(su_c->su_iosz, "UDP IO Buffer");
if(!rpc_buffer(xprt_copy))
goto fail;
xdrmem_create(&(su_c->su_xdrs), rpc_buffer(xprt_copy), su_c->su_iosz, XDR_DECODE);
if(xprt_orig->xp_verf.oa_base == su_o->su_verfbody)
xprt_copy->xp_verf.oa_base = su_c->su_verfbody;
else
xprt_copy->xp_verf.oa_base = xprt_orig->xp_verf.oa_base;
xprt_copy->xp_verf.oa_flavor = xprt_orig->xp_verf.oa_flavor;
xprt_copy->xp_verf.oa_length = xprt_orig->xp_verf.oa_length;
}
else
goto fail;
}
else if (xprt_orig->xp_ops == &Svctcp_op)
{
struct tcp_conn *cd_o = (struct tcp_conn *)xprt_orig->xp_p1, *cd_c;
cd_c = (struct tcp_conn *) Mem_Alloc(sizeof(*cd_c));
if(!cd_c)
goto fail;
memcpy(cd_c, cd_o, sizeof(*cd_c));
xprt_copy->xp_p1 = (void *) cd_c;
xdrrec_create(&(cd_c->xdrs), 32768, 32768, (caddr_t) xprt_copy, Readtcp, Writetcp);
if(xprt_orig->xp_verf.oa_base == cd_o->verf_body)
xprt_copy->xp_verf.oa_base = cd_c->verf_body;
else
xprt_copy->xp_verf.oa_base = xprt_orig->xp_verf.oa_base;
xprt_copy->xp_verf.oa_flavor = xprt_orig->xp_verf.oa_flavor;
xprt_copy->xp_verf.oa_length = xprt_orig->xp_verf.oa_length;
}
else if (xprt_orig->xp_ops == &Svctcp_rendezvous_op)
{
goto fail;
}
else
{
LogDebug(COMPONENT_RPC,
"Attempt to copy unknown xprt %p",
xprt_orig);
Mem_Free(xprt_copy);
goto fail_no_xprt;
}
return xprt_copy;
fail:
FreeXprt(xprt_copy);
fail_no_xprt:
/* Let caller know about failure */
LogCrit(COMPONENT_RPC,
"Failed to copy xprt");
svcerr_systemerr(xprt_orig);
return NULL;
}
