/* * XDR remote call arguments * written for XDR_ENCODE direction only */ bool_t xdr_rmtcall_args( XDR *xdrs, struct rmtcallargs *cap) { u_int lenposition, argposition, position; if (xdr_u_int32(xdrs, &(cap->prog)) && xdr_u_int32(xdrs, &(cap->vers)) && xdr_u_int32(xdrs, &(cap->proc))) { lenposition = XDR_GETPOS(xdrs); if (! xdr_u_int32(xdrs, &(cap->arglen))) return (FALSE); argposition = XDR_GETPOS(xdrs); if (! (*(cap->xdr_args))(xdrs, cap->args_ptr)) return (FALSE); position = XDR_GETPOS(xdrs); cap->arglen = (uint32_t)position - (uint32_t)argposition; XDR_SETPOS(xdrs, lenposition); if (! xdr_u_int32(xdrs, &(cap->arglen))) return (FALSE); XDR_SETPOS(xdrs, position); return (TRUE); } return (FALSE); }
/* * XDR remote call arguments * written for XDR_ENCODE direction only */ bool_t xdr_rmtcall_args( register XDR *xdrs, register struct rmtcallargs *cap) { uint32 lenposition, argposition, position; if (xdr_prog_t(xdrs, &(cap->prog)) && xdr_vers_t(xdrs, &(cap->vers)) && xdr_proc_t(xdrs, &(cap->proc))) { /* * All the jugglery for just getting the size of the arguments */ lenposition = XDR_GETPOS(xdrs); if (! xdr_u_long(xdrs, &(cap->arglen))) return (FALSE); argposition = XDR_GETPOS(xdrs); if (! (*(cap->xdr_args))(xdrs, cap->args_ptr)) return (FALSE); position = XDR_GETPOS(xdrs); cap->arglen = position - argposition; XDR_SETPOS(xdrs, lenposition); if (! xdr_u_long(xdrs, &(cap->arglen))) return (FALSE); XDR_SETPOS(xdrs, position); return (TRUE); } return (FALSE); }
/* * XDR remote call arguments * written for XDR_ENCODE direction only */ bool_t xdr_rmtcall_args (XDR *xdrs, struct rmtcallargs *cap) { u_int lenposition, argposition, position; if (xdr_u_long (xdrs, &(cap->prog)) && xdr_u_long (xdrs, &(cap->vers)) && xdr_u_long (xdrs, &(cap->proc))) { u_long dummy_arglen = 0; lenposition = XDR_GETPOS (xdrs); if (!xdr_u_long (xdrs, &dummy_arglen)) return FALSE; argposition = XDR_GETPOS (xdrs); if (!(*(cap->xdr_args)) (xdrs, cap->args_ptr)) return FALSE; position = XDR_GETPOS (xdrs); cap->arglen = (u_long) position - (u_long) argposition; XDR_SETPOS (xdrs, lenposition); if (!xdr_u_long (xdrs, &(cap->arglen))) return FALSE; XDR_SETPOS (xdrs, position); return TRUE; } return FALSE; }
/* * XDR remote call arguments * written for XDR_ENCODE direction only */ bool_t xdr_rmtcall_args( register XDR *xdrs, register struct rmtcallargs *cap) { unsigned lenposition, argposition, position; if (xdr_u_long(xdrs, &(cap->prog)) && xdr_u_long(xdrs, &(cap->vers)) && xdr_u_long(xdrs, &(cap->proc))) { lenposition = XDR_GETPOS(xdrs); if (! xdr_u_long(xdrs, &(cap->arglen))) return (FALSE); argposition = XDR_GETPOS(xdrs); if (! (*(cap->xdr_args))(xdrs, cap->args_ptr)) return (FALSE); position = XDR_GETPOS(xdrs); cap->arglen = (unsigned long)position - (unsigned long)argposition; XDR_SETPOS(xdrs, lenposition); if (! xdr_u_long(xdrs, &(cap->arglen))) return (FALSE); XDR_SETPOS(xdrs, position); return (TRUE); } return (FALSE); }
static int replyHdrWithRC(int rc, int chfd, int jobId) { XDR xdrs2; char reply_buf[MSGSIZE]; static char fname[] = "replyHdrWithRC"; struct LSFHeader replyHdr; xdrmem_create(&xdrs2, reply_buf, MSGSIZE, XDR_ENCODE); replyHdr.opCode = rc; replyHdr.length = 0; if (!xdr_LSFHeader(&xdrs2, &replyHdr)) { ls_syslog(LOG_ERR, "%s: xdr_LSFHeader() failed for job <%d>", fname, jobId); xdr_destroy(&xdrs2); return -1; } if (chanWrite_(chfd, reply_buf, XDR_GETPOS(&xdrs2)) <= 0) { ls_syslog(LOG_ERR, "%s: chanWrite_(%d) failed for job <%d>: %m", fname, XDR_GETPOS(&xdrs2), jobId); xdr_destroy(&xdrs2); return -1; } xdr_destroy(&xdrs2); return 0; } /* replyHdrWithRC */
/* * XDR remote call arguments * written for XDR_ENCODE direction only */ bool xdr_rmtcall_args(XDR *xdrs, struct rmtcallargs *cap) { u_int lenposition, argposition, position; assert(xdrs != NULL); assert(cap != NULL); if (xdr_u_long(xdrs, &(cap->prog)) && xdr_u_long(xdrs, &(cap->vers)) && xdr_u_long(xdrs, &(cap->proc))) { lenposition = XDR_GETPOS(xdrs); if (!xdr_u_long(xdrs, &(cap->arglen))) return (false); argposition = XDR_GETPOS(xdrs); if (!(*(cap->xdr_args)) (xdrs, cap->args_ptr)) return (false); position = XDR_GETPOS(xdrs); cap->arglen = (u_long) position - (u_long) argposition; XDR_SETPOS(xdrs, lenposition); if (!xdr_u_long(xdrs, &(cap->arglen))) return (false); XDR_SETPOS(xdrs, position); return (true); } return (false); }
/* * 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); }
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() { 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); }
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; register bool_t stat = FALSE; xdrs->x_op = XDR_ENCODE; XDR_SETPOS(xdrs, 0); msg->rm_xid = su->su_xid; if (xdr_replymsg(xdrs, msg)) { slen = (int)XDR_GETPOS(xdrs); if (sendto(xprt->xp_sock, rpc_buffer(xprt), slen, 0, (struct sockaddr *)&(xprt->xp_raddr), xprt->xp_addrlen) == (ssize_t)slen) { stat = TRUE; if (su->su_cache) { cache_set(xprt, (unsigned long) slen); } } } return (stat); }
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); }
void pingReq(XDR *xdrs, struct sockaddr_in *from, struct LSFHeader *reqHdr) { static char fname[] = "pingReq()"; char buf[MSGSIZE/4]; XDR xdrs2; enum limReplyCode limReplyCode; struct LSFHeader replyHdr; limReplyCode = LIME_NO_ERR; replyHdr.opCode = (short) limReplyCode; replyHdr.refCode = reqHdr->refCode; xdrmem_create(&xdrs2, buf, MSGSIZE/4, XDR_ENCODE); if (!xdr_LSFHeader(&xdrs2, &replyHdr) || !xdr_string(&xdrs2, &myHostPtr->hostName, MAXHOSTNAMELEN)) { ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_string"); xdr_destroy(&xdrs2); return; } if (chanSendDgram_(limSock, buf, XDR_GETPOS(&xdrs2), from) < 0) { ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "chanSendDgram_", sockAdd2Str_(from)); xdr_destroy(&xdrs2); return; } xdr_destroy(&xdrs2); return; }
/* lsb_getlimits() */ struct resLimitReply * lsb_getlimits() { XDR xdrs; struct LSFHeader hdr; char *reply; int cc; char buf[sizeof(struct LSFHeader)]; struct resLimitReply *limitReply; initLSFHeader_(&hdr); hdr.opCode = BATCH_RESLIMIT_INFO; xdrmem_create(&xdrs, buf, sizeof(struct LSFHeader), XDR_ENCODE); if (! xdr_LSFHeader(&xdrs, &hdr)) { lsberrno = LSBE_XDR; xdr_destroy(&xdrs); return NULL; } reply = NULL; cc = callmbd(NULL, buf, XDR_GETPOS(&xdrs), &reply, &hdr, NULL, NULL, NULL); if (cc < 0) { xdr_destroy(&xdrs); lsberrno = LSBE_PROTOCOL; return NULL; } xdr_destroy(&xdrs); if (hdr.opCode != LSBE_NO_ERROR) { FREEUP(reply); lsberrno = hdr.opCode; return NULL; } xdrmem_create(&xdrs, reply, XDR_DECODE_SIZE_(cc), XDR_DECODE); limitReply = calloc(1, sizeof(struct resLimitReply)); if(!xdr_resLimitReply(&xdrs, limitReply, &hdr)) { lsberrno = LSBE_XDR; xdr_destroy(&xdrs); if (cc) { FREEUP(reply); FREEUP(limitReply); } return NULL; } xdr_destroy(&xdrs); if (cc) FREEUP(reply); return limitReply; }
static bool_t svc_dg_reply(SVCXPRT *xprt, struct rpc_msg *msg) { struct svc_dg_data *su; XDR *xdrs; bool_t stat = FALSE; size_t slen; _DIAGASSERT(xprt != NULL); _DIAGASSERT(msg != NULL); su = su_data(xprt); xdrs = &(su->su_xdrs); xdrs->x_op = XDR_ENCODE; XDR_SETPOS(xdrs, 0); msg->rm_xid = su->su_xid; if (xdr_replymsg(xdrs, msg)) { slen = XDR_GETPOS(xdrs); if (sendto(xprt->xp_fd, rpc_buffer(xprt), slen, 0, (struct sockaddr *)xprt->xp_rtaddr.buf, (socklen_t)xprt->xp_rtaddr.len) == (ssize_t) slen) { stat = TRUE; if (su->su_cache) cache_set(xprt, slen); } } return (stat); }
/*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); }
/* * Create a unix style authenticator. * Returns an auth handle with the given stuff in it. */ AUTH * authunix_ncreate(char *machname, uid_t uid, gid_t gid, int len, gid_t *aup_gids) { struct audata *au = mem_alloc(sizeof(*au)); AUTH *auth = &au->au_auth; struct authunix_parms aup; struct timespec now; XDR xdrs; /* * Allocate and set up auth handle */ auth->ah_ops = authunix_ops(); auth->ah_private = NULL; auth->ah_error.re_status = RPC_SUCCESS; auth->ah_verf = au->au_shcred = _null_auth; auth->ah_refcnt = 1; au->au_shfaults = 0; /* * fill in param struct from the given params */ (void)clock_gettime(CLOCK_MONOTONIC_FAST, &now); aup.aup_time = now.tv_sec; aup.aup_machname = machname; aup.aup_uid = uid; aup.aup_gid = gid; aup.aup_len = (u_int) len; aup.aup_gids = aup_gids; /* * Serialize the parameters into origcred */ xdrmem_create(&xdrs, au->au_origcred.oa_body, MAX_AUTH_BYTES, XDR_ENCODE); if (!xdr_authunix_parms(&xdrs, &aup)) { __warnx(TIRPC_DEBUG_FLAG_AUTH, "%s: %s", __func__, clnt_sperrno(RPC_CANTENCODEARGS)); auth->ah_error.re_status = RPC_CANTENCODEARGS; return (auth); } au->au_origcred.oa_length = len = XDR_GETPOS(&xdrs); au->au_origcred.oa_flavor = AUTH_UNIX; /* * set auth handle to reflect new cred. */ auth->ah_cred = au->au_origcred; /* auth_get not needed: ah_refcnt == 1, as desired */ marshal_new_auth(auth); /* */ return (auth); }
static enum xprt_stat svc_dg_reply(struct svc_req *req) { SVCXPRT *xprt = req->rq_xprt; struct rpc_dplx_rec *rec = REC_XPRT(xprt); XDR *xdrs = rec->ioq.xdrs; struct svc_dg_xprt *su = DG_DR(rec); struct msghdr *msg = &su->su_msghdr; struct iovec iov; size_t slen; if (!xprt->xp_remote.nb.len) { __warnx(TIRPC_DEBUG_FLAG_WARN, "%s: %p fd %d has no remote address", __func__, xprt, xprt->xp_fd); return (XPRT_IDLE); } xdrs->x_op = XDR_ENCODE; XDR_SETPOS(xdrs, 0); if (!xdr_reply_encode(xdrs, &req->rq_msg)) { __warnx(TIRPC_DEBUG_FLAG_ERROR, "%s: %p fd %d xdr_reply_encode failed (will set dead)", __func__, xprt, xprt->xp_fd); return (XPRT_DIED); } if (req->rq_msg.rm_reply.rp_stat == MSG_ACCEPTED && req->rq_msg.rm_reply.rp_acpt.ar_stat == SUCCESS && req->rq_auth && !SVCAUTH_WRAP(req, xdrs)) { __warnx(TIRPC_DEBUG_FLAG_ERROR, "%s: %p fd %d SVCAUTH_WRAP failed (will set dead)", __func__, xprt, xprt->xp_fd); return (XPRT_DIED); } iov.iov_base = &su[1]; iov.iov_len = slen = XDR_GETPOS(xdrs); msg->msg_iov = &iov; msg->msg_iovlen = 1; msg->msg_name = (struct sockaddr *)&xprt->xp_remote.ss; msg->msg_namelen = xprt->xp_remote.nb.len; /* cmsg already set in svc_dg_rendezvous */ if (sendmsg(xprt->xp_fd, msg, 0) != (ssize_t) slen) { __warnx(TIRPC_DEBUG_FLAG_ERROR, "%s: %p fd %d sendmsg failed (will set dead)", __func__, xprt, xprt->xp_fd); return (XPRT_DIED); } return (XPRT_IDLE); }
/* * 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); }
int lsSendMsg_ (int s, int opCode, int hdrLength, char *data, char *reqBuf, int reqLen, bool_t (*xdrFunc)(), int (*writeFunc)(), struct lsfAuth *auth) { struct LSFHeader hdr; XDR xdrs; initLSFHeader_(&hdr); hdr.opCode = opCode; hdr.refCode = currentSN; if (!data) hdr.length = hdrLength; xdrmem_create(&xdrs, reqBuf, reqLen, XDR_ENCODE); if (!xdr_encodeMsg(&xdrs, data, &hdr, xdrFunc, 0, auth)) { xdr_destroy(&xdrs); lserrno = LSE_BAD_XDR; return(-1); } if ((*writeFunc)(s, (char *)reqBuf, XDR_GETPOS(&xdrs)) != XDR_GETPOS(&xdrs)) { xdr_destroy(&xdrs); lserrno = LSE_MSG_SYS; return (-2); } xdr_destroy(&xdrs); return (0); }
/* * 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); }
/* * 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); }
static bool_t svcraw_reply(SVCXPRT *xprt, struct rpc_msg *msg) { register struct svcraw_private *srp = svcraw_private; register XDR *xdrs; if (srp == 0) return (FALSE); xdrs = &srp->xdr_stream; xdrs->x_op = XDR_ENCODE; XDR_SETPOS(xdrs, 0); if (! xdr_replymsg(xdrs, msg)) return (FALSE); (void)XDR_GETPOS(xdrs); /* called just for overhead */ 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)))) { perror("auth_none.c - Fatal marshalling problem"); } 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 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); }
int lsb_reconfig (int configFlag) { mbdReqType mbdReqtype; XDR xdrs; char request_buf[MSGSIZE]; char *reply_buf; int cc; struct LSFHeader hdr; struct lsfAuth auth; int tmp; mbdReqtype = BATCH_RECONFIG; if (authTicketTokens_ (&auth, NULL) == -1) return (-1); xdrmem_create (&xdrs, request_buf, MSGSIZE, XDR_ENCODE); initLSFHeader_ (&hdr); hdr.opCode = mbdReqtype; tmp = (short) configFlag; hdr.reserved = tmp; if (!xdr_encodeMsg (&xdrs, NULL, &hdr, NULL, 0, &auth)) { lsberrno = LSBE_XDR; return (-1); } if ((cc = callmbd (NULL, request_buf, XDR_GETPOS (&xdrs), &reply_buf, &hdr, NULL, NULL, NULL)) == -1) { xdr_destroy (&xdrs); return (-1); } xdr_destroy (&xdrs); if (cc) free (reply_buf); lsberrno = hdr.opCode; if (lsberrno == LSBE_NO_ERROR) return (0); else return (-1); }
/* * Create a client handle for memory based rpc. */ CLIENT * clntraw_create (u_long prog, u_long vers) { struct clntraw_private_s *clp = clntraw_private; struct rpc_msg call_msg; XDR *xdrs; CLIENT *client; if (clp == 0) { clp = (struct clntraw_private_s *) calloc (1, sizeof (*clp)); if (clp == 0) return (0); 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; INTUSE(xdrmem_create) (xdrs, clp->mashl_callmsg.msg, MCALL_MSG_SIZE, XDR_ENCODE); if (!INTUSE(xdr_callhdr) (xdrs, &call_msg)) { perror (_ ("clnt_raw.c: fatal header serialization error")); } clp->mcnt = XDR_GETPOS (xdrs); XDR_DESTROY (xdrs); /* * Set xdrmem for client/server shared buffer */ INTUSE(xdrmem_create) (xdrs, clp->_raw_buf, UDPMSGSIZE, XDR_FREE); /* * create client handle */ client->cl_ops = (struct clnt_ops *) &client_ops; client->cl_auth = INTUSE(authnone_create) (); return client; }
/* * 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; _DIAGASSERT(auth != NULL); 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)))) warnx("%s: Fatal marshalling problem", __func__); else au->au_mpos = XDR_GETPOS(xdrs); XDR_DESTROY(xdrs); }
static void authnone_create_once (void) { struct authnone_private_s *ap; XDR xdr_stream; XDR *xdrs; ap = &authnone_private; ap->no_client.ah_cred = ap->no_client.ah_verf = _null_auth; ap->no_client.ah_ops = &ops; xdrs = &xdr_stream; INTUSE(xdrmem_create) (xdrs, ap->marshalled_client, (u_int) MAX_MARSHAL_SIZE, XDR_ENCODE); (void) INTUSE(xdr_opaque_auth) (xdrs, &ap->no_client.ah_cred); (void) INTUSE(xdr_opaque_auth) (xdrs, &ap->no_client.ah_verf); ap->mcnt = XDR_GETPOS (xdrs); XDR_DESTROY (xdrs); }
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; register bool_t stat = FALSE; xdrproc_t xdr_results; caddr_t xdr_location; bool_t has_args; if (msg->rm_reply.rp_stat == MSG_ACCEPTED && msg->rm_reply.rp_acpt.ar_stat == SUCCESS) { has_args = TRUE; xdr_results = msg->acpted_rply.ar_results.proc; xdr_location = msg->acpted_rply.ar_results.where; msg->acpted_rply.ar_results.proc = xdr_void; msg->acpted_rply.ar_results.where = NULL; } else has_args = FALSE; xdrs->x_op = XDR_ENCODE; XDR_SETPOS(xdrs, 0); msg->rm_xid = su->su_xid; if (xdr_replymsg(xdrs, msg) && (!has_args || (SVCAUTH_WRAP(xprt->xp_auth, xdrs, xdr_results, xdr_location)))) { slen = (int)XDR_GETPOS(xdrs); if (sendto(xprt->xp_sock, rpc_buffer(xprt), slen, 0, (struct sockaddr *)&(xprt->xp_raddr), xprt->xp_addrlen) == slen) { stat = TRUE; if (su->su_cache && slen >= 0) { cache_set(xprt, (uint32_t) slen); } } } return (stat); }