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); }