void qrpc_clnt_raw_destroy(CLIENT *cl)
{
struct qrpc_clnt_raw_priv *priv = (struct qrpc_clnt_raw_priv *)cl->cl_private;
if (priv) {
XDR_DESTROY(&priv->xdrs_out);
XDR_DESTROY(&priv->xdrs_in);
qrpc_clnt_raw_free_priv(priv);
}
free(cl);
}
/*
* Create a client handle for memory based rpc.
*/
CLIENT *
clnt_raw_create(const rpcprog_t prog, const rpcvers_t vers)
{
struct clnt_raw_private *clp;
struct rpc_msg call_msg;
XDR xdrs;
CLIENT *client;
uint_t start;
/* VARIABLES PROTECTED BY clntraw_lock: clp */
(void) mutex_lock(&clntraw_lock);
clp = clnt_raw_private;
if (clp != NULL) {
(void) mutex_unlock(&clntraw_lock);
return (&clp->client_object);
}
clp = calloc(1, sizeof (*clp));
if (clp == NULL) {
(void) mutex_unlock(&clntraw_lock);
return (NULL);
}
clp->raw_netbuf = &_rawcomnetbuf;
/*
* pre-serialize the static part of the call msg and stash it away
*/
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->mashl_callmsg, sizeof (clp->mashl_callmsg),
XDR_ENCODE);
start = XDR_GETPOS(&xdrs);
if (!xdr_callhdr(&xdrs, &call_msg)) {
free(clp);
(void) syslog(LOG_ERR,
"clnt_raw_create: Fatal header serialization error");
(void) mutex_unlock(&clntraw_lock);
return (NULL);
}
clp->mcnt = XDR_GETPOS(&xdrs) - start;
XDR_DESTROY(&xdrs);
/*
* create client handle
*/
client = &clp->client_object;
client->cl_ops = clnt_raw_ops();
client->cl_auth = authnone_create();
clnt_raw_private = clp;
(void) mutex_unlock(&clntraw_lock);
return (client);
}
static bool_t
write_struct(char *filename, xdrproc_t structproc, void *list)
{
FILE *fp;
XDR xdrs;
mode_t omask;
omask = umask(077);
fp = fopen(filename, "w");
if (fp == NULL) {
int i;
for (i = 0; i < 10; i++)
close(i);
fp = fopen(filename, "w");
if (fp == NULL) {
syslog(LOG_ERR,
"cannot open file = %s for writing", filename);
syslog(LOG_ERR, "cannot save any registration");
return (FALSE);
}
}
(void) umask(omask);
xdrstdio_create(&xdrs, fp, XDR_ENCODE);
if (structproc(&xdrs, list) == FALSE) {
syslog(LOG_ERR, "rpcbind: xdr_%s: failed", filename);
fclose(fp);
return (FALSE);
}
XDR_DESTROY(&xdrs);
fclose(fp);
return (TRUE);
}
static void
clnt_vc_destroy(CLIENT *cl)
{
struct ct_data *ct = (struct ct_data *) cl->cl_private;
int ct_fd = ct->ct_fd;
sigset_t mask;
sigset_t newmask;
assert(cl != NULL);
ct = (struct ct_data *) cl->cl_private;
sigfillset(&newmask);
thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
mutex_lock(&clnt_fd_lock);
while (vc_fd_locks[ct_fd])
cond_wait(&vc_cv[ct_fd], &clnt_fd_lock);
if (ct->ct_closeit && ct->ct_fd != -1) {
(void)_close(ct->ct_fd);
}
XDR_DESTROY(&(ct->ct_xdrs));
if (ct->ct_addr.buf)
free(ct->ct_addr.buf);
mem_free(ct, sizeof(struct ct_data));
if (cl->cl_netid && cl->cl_netid[0])
mem_free(cl->cl_netid, strlen(cl->cl_netid) +1);
if (cl->cl_tp && cl->cl_tp[0])
mem_free(cl->cl_tp, strlen(cl->cl_tp) +1);
mem_free(cl, sizeof(CLIENT));
mutex_unlock(&clnt_fd_lock);
thr_sigsetmask(SIG_SETMASK, &(mask), NULL);
cond_signal(&vc_cv[ct_fd]);
}
AUTH *authnone_create()
{
register struct authnone_private *ap = authnone_private;
XDR xdr_stream;
register XDR *xdrs;
extern bool_t xdr_opaque_auth(XDR *xdrs, struct opaque_auth *ap);
if (ap == 0) {
ap = (struct authnone_private *) rt_malloc (sizeof(*ap));
if (ap == 0) return NULL;
memset(ap, 0, sizeof(*ap));
authnone_private = ap;
}
if (!ap->mcnt) {
ap->no_client.ah_cred = ap->no_client.ah_verf = _null_auth;
ap->no_client.ah_ops = &ops;
xdrs = &xdr_stream;
xdrmem_create(xdrs, ap->marshalled_client,
(unsigned int) MAX_MARSHEL_SIZE, XDR_ENCODE);
(void) xdr_opaque_auth(xdrs, &ap->no_client.ah_cred);
(void) xdr_opaque_auth(xdrs, &ap->no_client.ah_verf);
ap->mcnt = XDR_GETPOS(xdrs);
XDR_DESTROY(xdrs);
}
return (&ap->no_client);
}
AUTH *
authnone_create(void)
{
struct authnone_private *ap = authnone_private;
XDR xdr_stream;
XDR *xdrs;
if (ap == NULL) {
ap = (struct authnone_private *)calloc(1, sizeof (*ap));
if (ap == NULL)
return (NULL);
authnone_private = ap;
}
if (!ap->mcnt) {
ap->no_client.ah_cred = ap->no_client.ah_verf = _null_auth;
ap->no_client.ah_ops = &ops;
xdrs = &xdr_stream;
xdrmem_create(xdrs, ap->marshalled_client, (u_int)MAX_MARSHEL_SIZE,
XDR_ENCODE);
(void)xdr_opaque_auth(xdrs, &ap->no_client.ah_cred);
(void)xdr_opaque_auth(xdrs, &ap->no_client.ah_verf);
ap->mcnt = XDR_GETPOS(xdrs);
XDR_DESTROY(xdrs);
}
return (&ap->no_client);
}
AUTH *
authnone_create()
{
struct authnone_private *ap = authnone_private;
XDR xdr_stream;
XDR *xdrs;
extern mutex_t authnone_lock;
mutex_lock(&authnone_lock);
if (ap == 0) {
ap = (struct authnone_private *)calloc(1, sizeof (*ap));
if (ap == 0) {
mutex_unlock(&authnone_lock);
return (0);
}
authnone_private = ap;
}
if (!ap->mcnt) {
ap->no_client.ah_cred = ap->no_client.ah_verf = _null_auth;
ap->no_client.ah_ops = authnone_ops();
xdrs = &xdr_stream;
xdrmem_create(xdrs, ap->marshalled_client,
(u_int)MAX_MARSHAL_SIZE, XDR_ENCODE);
(void)xdr_opaque_auth(xdrs, &ap->no_client.ah_cred);
(void)xdr_opaque_auth(xdrs, &ap->no_client.ah_verf);
ap->mcnt = XDR_GETPOS(xdrs);
XDR_DESTROY(xdrs);
}
mutex_unlock(&authnone_lock);
return (&ap->no_client);
}
/*
* Usage:
* xprt = svc_dg_ncreate(sock, sendsize, recvsize);
*
* If recvsize or sendsize are 0 suitable,
* system defaults are chosen.
* If a problem occurred, this routine returns NULL.
*/
static void
svc_dg_xprt_free(struct svc_dg_xprt *su)
{
XDR_DESTROY(su->su_dr.ioq.xdrs);
rpc_dplx_rec_destroy(&su->su_dr);
mem_free(su, sizeof(struct svc_dg_xprt) + su->su_dr.maxrec);
}
static int
test_read_cb(nct_req_t *req)
{
test_read_priv_t *priv = req->req_priv;
nct_mnt_t *mnt = req->req_mnt;
nct_vn_t *vn = mnt->mnt_vn;
off_t offset;
XDR_DESTROY(&req->req_msg->msg_xdr);
if (req->req_msg->msg_stat != RPC_SUCCESS) {
eprint("read failed: %d %s\n",
req->req_msg->msg_stat, clnt_sperrno(req->req_msg->msg_stat));
nct_req_free(req);
return req->req_msg->msg_stat;
}
if (req->req_tsc_stop >= req->req_tsc_finish) {
nct_req_free(req);
return ETIMEDOUT;
}
offset = __sync_fetch_and_add(&priv->pr_offset, priv->pr_length);
if (offset + priv->pr_length > vn->xvn_fattr.size) {
offset = __sync_fetch_and_sub(&priv->pr_offset, priv->pr_offset);
}
nct_nfs_read3_encode(req, offset, priv->pr_length);
nct_req_send(req);
return 0;
}
static void
clnt_vc_destroy(CLIENT *cl)
{
struct ct_data *ct;
#ifdef _REENTRANT
int ct_fd;
sigset_t mask;
#endif
sigset_t newmask;
_DIAGASSERT(cl != NULL);
ct = (struct ct_data *) cl->cl_private;
ct_fd = ct->ct_fd;
__clnt_sigfillset(&newmask);
thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
mutex_lock(&clnt_fd_lock);
#ifdef _REENTRANT
while (vc_fd_locks[ct_fd])
cond_wait(&vc_cv[ct_fd], &clnt_fd_lock);
#endif
if (ct->ct_closeit && ct->ct_fd != -1) {
(void)close(ct->ct_fd);
}
XDR_DESTROY(&(ct->ct_xdrs));
if (ct->ct_addr.buf)
free(ct->ct_addr.buf);
mem_free(ct, sizeof(struct ct_data));
mem_free(cl, sizeof(CLIENT));
mutex_unlock(&clnt_fd_lock);
thr_sigsetmask(SIG_SETMASK, &(mask), NULL);
cond_signal(&vc_cv[ct_fd]);
}
/*ARGSUSED*/
static enum clnt_stat
clnt_raw_send(CLIENT *h, rpcproc_t proc, xdrproc_t xargs, caddr_t argsp)
{
struct clnt_raw_private *clp;
XDR xdrs;
uint_t start;
rpc_callerr.re_errno = 0;
rpc_callerr.re_terrno = 0;
(void) mutex_lock(&clntraw_lock);
clp = clnt_raw_private;
if (clp == NULL) {
(void) mutex_unlock(&clntraw_lock);
return (rpc_callerr.re_status = RPC_FAILED);
}
(void) mutex_unlock(&clntraw_lock);
/*
* send request
*/
xdrmem_create(&xdrs, clp->raw_netbuf->buf, clp->raw_netbuf->maxlen,
XDR_ENCODE);
start = XDR_GETPOS(&xdrs);
/* LINTED pointer alignment */
((struct rpc_msg *)clp->mashl_callmsg)->rm_xid++;
if ((!XDR_PUTBYTES(&xdrs, clp->mashl_callmsg, clp->mcnt)) ||
(!XDR_PUTINT32(&xdrs, (int32_t *)&proc)) ||
(!AUTH_MARSHALL(h->cl_auth, &xdrs)) ||
(!(*xargs)(&xdrs, argsp))) {
XDR_DESTROY(&xdrs);
return (rpc_callerr.re_status = RPC_CANTENCODEARGS);
}
clp->raw_netbuf->len = XDR_GETPOS(&xdrs) - start;
XDR_DESTROY(&xdrs);
/*
* We have to call server input routine here because this is
* all going on in one process.
* By convention using FD_SETSIZE as the pseudo file descriptor.
*/
svc_getreq_common(FD_SETSIZE);
return (rpc_callerr.re_status = RPC_SUCCESS);
}
static bool_t
svc_vc_backchannel_reply(SVCXPRT *xprt, struct rpc_msg *msg,
struct sockaddr *addr, struct mbuf *m, uint32_t *seq)
{
struct ct_data *ct;
XDR xdrs;
struct mbuf *mrep;
bool_t stat = TRUE;
int error;
/*
* Leave space for record mark.
*/
mrep = m_gethdr(M_WAITOK, MT_DATA);
mrep->m_data += sizeof(uint32_t);
xdrmbuf_create(&xdrs, mrep, XDR_ENCODE);
if (msg->rm_reply.rp_stat == MSG_ACCEPTED &&
msg->rm_reply.rp_acpt.ar_stat == SUCCESS) {
if (!xdr_replymsg(&xdrs, msg))
stat = FALSE;
else
xdrmbuf_append(&xdrs, m);
} else {
stat = xdr_replymsg(&xdrs, msg);
}
if (stat) {
m_fixhdr(mrep);
/*
* Prepend a record marker containing the reply length.
*/
M_PREPEND(mrep, sizeof(uint32_t), M_WAITOK);
*mtod(mrep, uint32_t *) =
htonl(0x80000000 | (mrep->m_pkthdr.len
- sizeof(uint32_t)));
sx_xlock(&xprt->xp_lock);
ct = (struct ct_data *)xprt->xp_p2;
if (ct != NULL)
error = sosend(ct->ct_socket, NULL, NULL, mrep, NULL,
0, curthread);
else
error = EPIPE;
sx_xunlock(&xprt->xp_lock);
if (!error) {
stat = TRUE;
}
} else {
m_freem(mrep);
}
XDR_DESTROY(&xdrs);
return (stat);
}
static bool_t
svc_vc_reply(SVCXPRT *xprt, struct rpc_msg *msg,
struct sockaddr *addr, struct mbuf *m, uint32_t *seq)
{
XDR xdrs;
struct mbuf *mrep;
bool_t stat = TRUE;
int error, len;
/*
* Leave space for record mark.
*/
mrep = m_gethdr(M_WAITOK, MT_DATA);
mrep->m_data += sizeof(uint32_t);
xdrmbuf_create(&xdrs, mrep, XDR_ENCODE);
if (msg->rm_reply.rp_stat == MSG_ACCEPTED &&
msg->rm_reply.rp_acpt.ar_stat == SUCCESS) {
if (!xdr_replymsg(&xdrs, msg))
stat = FALSE;
else
xdrmbuf_append(&xdrs, m);
} else {
stat = xdr_replymsg(&xdrs, msg);
}
if (stat) {
m_fixhdr(mrep);
/*
* Prepend a record marker containing the reply length.
*/
M_PREPEND(mrep, sizeof(uint32_t), M_WAITOK);
len = mrep->m_pkthdr.len;
*mtod(mrep, uint32_t *) =
htonl(0x80000000 | (len - sizeof(uint32_t)));
atomic_add_32(&xprt->xp_snd_cnt, len);
error = sosend(xprt->xp_socket, NULL, NULL, mrep, NULL,
0, curthread);
if (!error) {
atomic_add_rel_32(&xprt->xp_snt_cnt, len);
if (seq)
*seq = xprt->xp_snd_cnt;
stat = TRUE;
} else
atomic_subtract_32(&xprt->xp_snd_cnt, len);
} else {
m_freem(mrep);
}
XDR_DESTROY(&xdrs);
return (stat);
}
static void
clnttcp_destroy(CLIENT *h)
{
struct ct_data *ct = h->cl_private;
if (ct->ct_closeit)
(void)closesocket(ct->ct_sock);
XDR_DESTROY(&(ct->ct_xdrs));
mem_free((caddr_t)ct, sizeof(struct ct_data));
mem_free((caddr_t)h, sizeof(CLIENT));
}
/*
* Function: marshall_new_creds
*
* Purpose: (pre-)serialize auth_msg and client_handle fields of
* auth_gssapi_creds into auth->cred_buf
*
* Arguments:
*
* auth (r/w) the AUTH structure to modify
* auth_msg (r) the auth_msg field to serialize
* client_handle (r) the client_handle field to serialize, or
* NULL
*
* Returns: TRUE if successful, FALSE if not
*
* Requires: auth must point to a valid GSS-API auth structure, auth_msg
* must be TRUE or FALSE, client_handle must be a gss_buffer_t with a valid
* value and length field or NULL.
*
* Effects: auth->ah_cred is set to the serialized auth_gssapi_creds
* version 2 structure (stored in the cred_buf field of private data)
* containing version, auth_msg and client_handle.
* auth->ah_cred.oa_flavor is set to AUTH_GSSAPI. If cliend_handle is
* NULL, it is treated as if it had a length of 0 and a value of NULL.
*
* Modifies: auth
*/
static bool_t marshall_new_creds(
AUTH *auth,
bool_t auth_msg,
gss_buffer_t client_handle)
{
auth_gssapi_creds creds;
XDR xdrs;
PRINTF(("marshall_new_creds: starting\n"));
creds.version = 2;
creds.auth_msg = auth_msg;
if (client_handle)
GSS_COPY_BUFFER(creds.client_handle, *client_handle)
else {
creds.client_handle.length = 0;
creds.client_handle.value = NULL;
}
xdrmem_create(&xdrs, (caddr_t) AUTH_PRIVATE(auth)->cred_buf,
MAX_AUTH_BYTES, XDR_ENCODE);
if (! xdr_authgssapi_creds(&xdrs, &creds)) {
PRINTF(("marshall_new_creds: failed encoding auth_gssapi_creds\n"));
XDR_DESTROY(&xdrs);
return FALSE;
}
AUTH_PRIVATE(auth)->cred_len = xdr_getpos(&xdrs);
XDR_DESTROY(&xdrs);
PRINTF(("marshall_new_creds: auth_gssapi_creds is %d bytes\n",
AUTH_PRIVATE(auth)->cred_len));
auth->ah_cred.oa_flavor = AUTH_GSSAPI;
auth->ah_cred.oa_base = (char *) AUTH_PRIVATE(auth)->cred_buf;
auth->ah_cred.oa_length = AUTH_PRIVATE(auth)->cred_len;
PRINTF(("marshall_new_creds: succeeding\n"));
return TRUE;
}
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);
}
/* closes test file for read or write */
bool_t
xdrstdio_finish_cb (XDR * xdrs, enum xdr_op op, void * data)
{
xdrstdio_creation_data* xdrstdio_data = (xdrstdio_creation_data*)data;
if (xdrstdio_data->finish_guard)
{
xdrstdio_data->finish_guard = 0;
XDR_DESTROY (xdrs);
fclose (xdrstdio_data->f);
}
return TRUE;
}
static void
clntudp_destroy(
CLIENT *cl)
{
register struct cu_data *cu = (struct cu_data *)cl->cl_private;
if (cu->cu_closeit) {
(void)close(cu->cu_sock);
}
XDR_DESTROY(&(cu->cu_outxdrs));
mem_free((char*)cu, (sizeof(*cu) + cu->cu_sendsz + cu->cu_recvsz));
mem_free((char*)cl, sizeof(CLIENT));
}
static void clntudp_destroy(CLIENT *cl)
{
register struct cu_data *cu = (struct cu_data *) cl->cl_private;
if (cu->cu_closeit)
{
lwip_close(cu->cu_sock);
}
XDR_DESTROY(&(cu->cu_outxdrs));
rt_free(cu);
rt_free(cl);
}
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), su->su_iosz);
mem_free((char*)su, sizeof(struct svcudp_data));
mem_free((char*)xprt, sizeof(SVCXPRT));
}
/*
* Create a client handle for memory based rpc.
*/
CLIENT *
clnt_raw_ncreate(rpcprog_t prog, rpcvers_t vers)
{
struct clntraw_private *clp;
struct rpc_msg call_msg;
XDR *xdrs;
CLIENT *client;
mutex_lock(&clntraw_lock);
clp = clntraw_private;
if (clp == NULL) {
clp = (struct clntraw_private *)calloc(1, sizeof (*clp));
if (clp == NULL) {
mutex_unlock(&clntraw_lock);
return NULL;
}
if (__rpc_rawcombuf == NULL)
__rpc_rawcombuf =
(char *)calloc(UDPMSGSIZE, sizeof (char));
clp->_raw_buf = __rpc_rawcombuf;
clntraw_private = clp;
}
xdrs = &clp->xdr_stream;
client = &clp->client_object;
/*
* pre-serialize the static part of the call msg and stash it away
*/
call_msg.rm_direction = CALL;
call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
/* XXX: prog and vers have been long historically :-( */
call_msg.rm_call.cb_prog = (u_int32_t)prog;
call_msg.rm_call.cb_vers = (u_int32_t)vers;
xdrmem_create(xdrs, clp->u.mashl_callmsg, MCALL_MSG_SIZE, XDR_ENCODE);
if (! xdr_callhdr(xdrs, &call_msg))
__warnx(TIRPC_DEBUG_FLAG_CLNT_RAW,
"clntraw_create - Fatal header serialization error.");
clp->mcnt = XDR_GETPOS(xdrs);
XDR_DESTROY(xdrs);
/*
* Set xdrmem for client/server shared buffer
*/
xdrmem_create(xdrs, clp->_raw_buf, UDPMSGSIZE, XDR_FREE);
/*
* create client handle
*/
client->cl_ops = clnt_raw_ops();
mutex_unlock(&clntraw_lock);
return (client);
}
static void
clnttcp_destroy(
CLIENT *h)
{
struct ct_data *ct =
(struct ct_data *) h->cl_private;
if (ct->ct_closeit) {
(void)_RPC_close(ct->ct_sock);
}
XDR_DESTROY(&(ct->ct_xdrs));
mem_free(ct, sizeof(struct ct_data));
mem_free(h, sizeof(CLIENT));
}
/*
* Create a client handle for memory based rpc.
*/
CLIENT *
clntraw_create(u_long prog, u_long vers)
{
struct clntraw_private *clp = clntraw_private;
struct rpc_msg call_msg;
XDR *xdrs;
CLIENT *client;
if (clp == NULL) {
clp = (struct clntraw_private *)calloc(1, sizeof (*clp));
if (clp == NULL)
goto fail;
clntraw_private = clp;
}
xdrs = &clp->xdr_stream;
client = &clp->client_object;
/*
* pre-serialize the static part of the call msg and stash it away
*/
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->mashl_callmsg, MCALL_MSG_SIZE, XDR_ENCODE);
if (!xdr_callhdr(xdrs, &call_msg))
goto fail;
clp->mcnt = XDR_GETPOS(xdrs);
XDR_DESTROY(xdrs);
/*
* Set xdrmem for client/server shared buffer
*/
xdrmem_create(xdrs, clp->_raw_buf, UDPMSGSIZE, XDR_FREE);
/*
* create client handle
*/
client->cl_ops = &client_ops;
client->cl_auth = authnone_create();
if (client->cl_auth == NULL)
goto fail;
return (client);
fail:
mem_free((caddr_t)clntraw_private, sizeof(clntraw_private));
clntraw_private = NULL;
rpc_createerr.cf_stat = RPC_SYSTEMERROR;
rpc_createerr.cf_error.re_errno = errno;
return (NULL);
}
static void
authnone_init(void *dummy)
{
struct authnone_private *ap = &authnone_private;
XDR xdrs;
ap->no_client.ah_cred = ap->no_client.ah_verf = _null_auth;
ap->no_client.ah_ops = &authnone_ops;
xdrmem_create(&xdrs, ap->mclient, MAX_MARSHAL_SIZE, XDR_ENCODE);
xdr_opaque_auth(&xdrs, &ap->no_client.ah_cred);
xdr_opaque_auth(&xdrs, &ap->no_client.ah_verf);
ap->mcnt = XDR_GETPOS(&xdrs);
XDR_DESTROY(&xdrs);
}
static void
svcudp_destroy(SVCXPRT *xprt)
{
struct svcudp_data *su = su_data(xprt);
xprt_unregister(xprt);
if (xprt->xp_sock != -1)
(void)close(xprt->xp_sock);
xprt->xp_sock = -1;
XDR_DESTROY(&(su->su_xdrs));
mem_free(rpc_buffer(xprt), su->su_iosz);
mem_free((caddr_t)su, sizeof(struct svcudp_data));
mem_free((caddr_t)xprt, sizeof(SVCXPRT));
}
static bool_t
svc_vc_backchannel_recv(SVCXPRT *xprt, struct rpc_msg *msg,
struct sockaddr **addrp, struct mbuf **mp)
{
struct cf_conn *cd = (struct cf_conn *) xprt->xp_p1;
struct ct_data *ct;
struct mbuf *m;
XDR xdrs;
sx_xlock(&xprt->xp_lock);
ct = (struct ct_data *)xprt->xp_p2;
if (ct == NULL) {
sx_xunlock(&xprt->xp_lock);
return (FALSE);
}
mtx_lock(&ct->ct_lock);
m = cd->mreq;
if (m == NULL) {
xprt_inactive_self(xprt);
mtx_unlock(&ct->ct_lock);
sx_xunlock(&xprt->xp_lock);
return (FALSE);
}
cd->mreq = m->m_nextpkt;
mtx_unlock(&ct->ct_lock);
sx_xunlock(&xprt->xp_lock);
xdrmbuf_create(&xdrs, m, XDR_DECODE);
if (! xdr_callmsg(&xdrs, msg)) {
XDR_DESTROY(&xdrs);
return (FALSE);
}
*addrp = NULL;
*mp = xdrmbuf_getall(&xdrs);
XDR_DESTROY(&xdrs);
return (TRUE);
}
/*
* Marshals (pre-serializes) an auth struct.
* sets private data, au_marshed and au_mpos
*/
static void
marshal_new_auth(AUTH *auth)
{
XDR xdr_stream;
XDR *xdrs = &xdr_stream;
struct audata *au = AUTH_PRIVATE(auth);
xdrmem_create(xdrs, au->au_marshed, MAX_AUTH_BYTES, XDR_ENCODE);
if ((! xdr_opaque_auth(xdrs, &(auth->ah_cred))) ||
(! xdr_opaque_auth(xdrs, &(auth->ah_verf)))) {
/* XXX nothing we can do */
} else {
au->au_mpos = XDR_GETPOS(xdrs);
}
XDR_DESTROY(xdrs);
}
/*
* Marshals (pre-serializes) an auth struct.
* sets private data, au_marshed and au_mpos
*/
static void
marshal_new_auth(AUTH *auth)
{
XDR xdr_stream;
XDR *xdrs = &xdr_stream;
struct audata *au = AUTH_PRIVATE(auth);
xdrmem_create(xdrs, au->au_marshed, MAX_AUTH_BYTES, XDR_ENCODE);
if ((! xdr_opaque_auth(xdrs, &(auth->ah_cred))) ||
(! xdr_opaque_auth(xdrs, &(auth->ah_verf)))) {
perror("auth_none.c - Fatal marshalling problem");
} else {
au->au_mpos = XDR_GETPOS(xdrs);
}
XDR_DESTROY(xdrs);
}
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);
}
/*
* Marshals (pre-serializes) an auth struct.
* sets private data, au_marshed and au_mpos
*/
static void
marshal_new_auth(AUTH *auth)
{
XDR xdrs[1];
struct audata *au = AUTH_PRIVATE(auth);
assert(auth != NULL);
xdrmem_create(xdrs, au->au_marshed, MAX_AUTH_BYTES, XDR_ENCODE);
if ((!xdr_opaque_auth_encode(xdrs, &(auth->ah_cred)))
|| (!xdr_opaque_auth_encode(xdrs, &(auth->ah_verf))))
__warnx(TIRPC_DEBUG_FLAG_AUTH,
"auth_none.c - Fatal marshalling " "problem");
else
au->au_mpos = XDR_GETPOS(xdrs);
XDR_DESTROY(xdrs);
}
