/*
* Connection less client creation returns with client handle parameters.
* Default options are set, which the user can change using clnt_control().
* fd should be open and bound.
* NB: The rpch->cl_auth is initialized to null authentication.
* Caller may wish to set this something more useful.
*
* sendsz and recvsz are the maximum allowable packet sizes that can be
* sent and received. Normally they are the same, but they can be
* changed to improve the program efficiency and buffer allocation.
* If they are 0, use the transport default.
*
* If svcaddr is NULL, returns NULL.
*/
CLIENT *
clnt_dg_create(const int fd, struct netbuf *svcaddr, const rpcprog_t program,
const rpcvers_t version, const uint_t sendsz, const uint_t recvsz)
{
CLIENT *cl = NULL; /* client handle */
struct cu_data *cu = NULL; /* private data */
struct t_unitdata *tr_data;
struct t_info tinfo;
struct timeval now;
struct rpc_msg call_msg;
uint_t ssz;
uint_t rsz;
sig_mutex_lock(&dgtbl_lock);
if ((dgtbl == NULL) && ((dgtbl = rpc_fd_init()) == NULL)) {
sig_mutex_unlock(&dgtbl_lock);
goto err1;
}
sig_mutex_unlock(&dgtbl_lock);
if (svcaddr == NULL) {
rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
return (NULL);
}
if (t_getinfo(fd, &tinfo) == -1) {
rpc_createerr.cf_stat = RPC_TLIERROR;
rpc_createerr.cf_error.re_errno = 0;
rpc_createerr.cf_error.re_terrno = t_errno;
return (NULL);
}
/*
* Setup to rcv datagram error, we ignore any errors returned from
* __rpc_tli_set_options() as SO_DGRAM_ERRIND is only relevant to
* udp/udp6 transports and this point in the code we only know that
* we are using a connection less transport.
*/
if (tinfo.servtype == T_CLTS)
(void) __rpc_tli_set_options(fd, SOL_SOCKET, SO_DGRAM_ERRIND,
1);
/*
* Find the receive and the send size
*/
ssz = __rpc_get_t_size((int)sendsz, tinfo.tsdu);
rsz = __rpc_get_t_size((int)recvsz, tinfo.tsdu);
if ((ssz == 0) || (rsz == 0)) {
rpc_createerr.cf_stat = RPC_TLIERROR; /* XXX */
rpc_createerr.cf_error.re_errno = 0;
rpc_createerr.cf_error.re_terrno = 0;
return (NULL);
}
if ((cl = malloc(sizeof (CLIENT))) == NULL)
goto err1;
/*
* Should be multiple of 4 for XDR.
*/
ssz = ((ssz + 3) / 4) * 4;
rsz = ((rsz + 3) / 4) * 4;
cu = malloc(sizeof (*cu) + ssz + rsz);
if (cu == NULL)
goto err1;
if ((cu->cu_raddr.buf = malloc(svcaddr->len)) == NULL)
goto err1;
(void) memcpy(cu->cu_raddr.buf, svcaddr->buf, (size_t)svcaddr->len);
cu->cu_raddr.len = cu->cu_raddr.maxlen = svcaddr->len;
cu->cu_outbuf_start = &cu->cu_inbuf[rsz];
/* Other values can also be set through clnt_control() */
cu->cu_wait.tv_sec = 15; /* heuristically chosen */
cu->cu_wait.tv_usec = 0;
cu->cu_total.tv_sec = -1;
cu->cu_total.tv_usec = -1;
cu->cu_sendsz = ssz;
cu->cu_recvsz = rsz;
(void) gettimeofday(&now, NULL);
call_msg.rm_xid = getpid() ^ now.tv_sec ^ now.tv_usec;
call_msg.rm_call.cb_prog = program;
call_msg.rm_call.cb_vers = version;
xdrmem_create(&(cu->cu_outxdrs), cu->cu_outbuf, ssz, XDR_ENCODE);
if (!xdr_callhdr(&(cu->cu_outxdrs), &call_msg)) {
rpc_createerr.cf_stat = RPC_CANTENCODEARGS; /* XXX */
rpc_createerr.cf_error.re_errno = 0;
rpc_createerr.cf_error.re_terrno = 0;
goto err2;
}
cu->cu_xdrpos = XDR_GETPOS(&(cu->cu_outxdrs));
XDR_DESTROY(&(cu->cu_outxdrs));
xdrmem_create(&(cu->cu_outxdrs), cu->cu_outbuf_start, ssz, XDR_ENCODE);
/* LINTED pointer alignment */
tr_data = (struct t_unitdata *)t_alloc(fd, T_UNITDATA, T_ADDR | T_OPT);
if (tr_data == NULL) {
goto err1;
}
tr_data->udata.maxlen = cu->cu_recvsz;
tr_data->udata.buf = cu->cu_inbuf;
cu->cu_tr_data = tr_data;
/*
* By default, closeit is always FALSE. It is users responsibility
* to do a t_close on it, else the user may use clnt_control
* to let clnt_destroy do it for him/her.
*/
cu->cu_closeit = FALSE;
cu->cu_fd = fd;
cl->cl_ops = clnt_dg_ops();
cl->cl_private = (caddr_t)cu;
cl->cl_auth = authnone_create();
cl->cl_tp = NULL;
cl->cl_netid = NULL;
cu->pfdp.fd = cu->cu_fd;
cu->pfdp.events = MASKVAL;
return (cl);
err1:
(void) syslog(LOG_ERR, mem_err_clnt_dg);
rpc_createerr.cf_stat = RPC_SYSTEMERROR;
rpc_createerr.cf_error.re_errno = errno;
rpc_createerr.cf_error.re_terrno = 0;
err2:
if (cl) {
free(cl);
if (cu) {
free(cu->cu_raddr.buf);
free(cu);
}
}
return (NULL);
}
/*
* Connection less client creation returns with client handle parameters.
* Default options are set, which the user can change using clnt_control().
* fd should be open and bound.
*
* sendsz and recvsz are the maximum allowable packet sizes that can be
* sent and received. Normally they are the same, but they can be
* changed to improve the program efficiency and buffer allocation.
* If they are 0, use the transport default.
*
* If svcaddr is NULL, returns NULL.
*/
CLIENT *
clnt_dg_ncreate(int fd, /* open file descriptor */
const struct netbuf *svcaddr, /* servers address */
rpcprog_t program, /* program number */
rpcvers_t version, /* version number */
u_int sendsz, /* buffer recv size */
u_int recvsz /* buffer send size */)
{
CLIENT *clnt = NULL; /* client handle */
struct cx_data *cx = NULL; /* private data */
struct cu_data *cu = NULL;
struct timespec now;
struct rpc_msg call_msg;
struct __rpc_sockinfo si;
uint32_t oflags;
int one = 1;
if (svcaddr == NULL) {
rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
return (NULL);
}
if (!__rpc_fd2sockinfo(fd, &si)) {
rpc_createerr.cf_stat = RPC_TLIERROR;
rpc_createerr.cf_error.re_errno = 0;
return (NULL);
}
/*
* Find the receive and the send size
*/
sendsz = __rpc_get_t_size(si.si_af, si.si_proto, (int)sendsz);
recvsz = __rpc_get_t_size(si.si_af, si.si_proto, (int)recvsz);
if ((sendsz == 0) || (recvsz == 0)) {
rpc_createerr.cf_stat = RPC_TLIERROR; /* XXX */
rpc_createerr.cf_error.re_errno = 0;
return (NULL);
}
clnt = mem_alloc(sizeof(CLIENT));
if (clnt == NULL)
goto err1;
mutex_init(&clnt->cl_lock, NULL);
clnt->cl_flags = CLNT_FLAG_NONE;
/*
* Should be multiple of 4 for XDR.
*/
sendsz = ((sendsz + 3) / 4) * 4;
recvsz = ((recvsz + 3) / 4) * 4;
cx = alloc_cx_data(CX_DG_DATA, sendsz, recvsz);
if (cx == NULL)
goto err1;
cu = CU_DATA(cx);
(void)memcpy(&cu->cu_raddr, svcaddr->buf, (size_t) svcaddr->len);
cu->cu_rlen = svcaddr->len;
/* Other values can also be set through clnt_control() */
cu->cu_wait.tv_sec = 15; /* heuristically chosen */
cu->cu_wait.tv_usec = 0;
cu->cu_total.tv_sec = -1;
cu->cu_total.tv_usec = -1;
cu->cu_sendsz = sendsz;
cu->cu_recvsz = recvsz;
cu->cu_async = false;
cu->cu_connect = false;
cu->cu_connected = false;
(void)clock_gettime(CLOCK_MONOTONIC_FAST, &now);
call_msg.rm_xid = __RPC_GETXID(&now); /* XXX? */
call_msg.rm_call.cb_prog = program;
call_msg.rm_call.cb_vers = version;
xdrmem_create(&(cu->cu_outxdrs), cu->cu_outbuf, sendsz, XDR_ENCODE);
if (!xdr_callhdr(&(cu->cu_outxdrs), &call_msg)) {
rpc_createerr.cf_stat = RPC_CANTENCODEARGS; /* XXX */
rpc_createerr.cf_error.re_errno = 0;
goto err2;
}
cu->cu_xdrpos = XDR_GETPOS(&(cu->cu_outxdrs));
/* XXX fvdl - do we still want this? */
#if 0
(void)bindresvport_sa(fd, (struct sockaddr *)svcaddr->buf);
#endif
#ifdef IP_RECVERR
{
int on = 1;
(void) setsockopt(fd, SOL_IP, IP_RECVERR, &on, sizeof(on));
}
#endif
ioctl(fd, FIONBIO, (char *)(void *)&one);
/*
* By default, closeit is always false. It is users responsibility
* to do a close on it, else the user may use clnt_control
* to let clnt_destroy do it for him/her.
*/
cu->cu_closeit = false;
cu->cu_fd = fd;
clnt->cl_ops = clnt_dg_ops();
clnt->cl_p1 = cx;
clnt->cl_p2 = rpc_dplx_lookup_rec(fd, RPC_DPLX_LKP_FLAG_NONE,
&oflags); /* ref+1 */
clnt->cl_tp = NULL;
clnt->cl_netid = NULL;
return (clnt);
err1:
__warnx(TIRPC_DEBUG_FLAG_CLNT_DG, mem_err_clnt_dg);
rpc_createerr.cf_stat = RPC_SYSTEMERROR;
rpc_createerr.cf_error.re_errno = errno;
err2:
if (clnt) {
mem_free(clnt, sizeof(CLIENT));
if (cx)
free_cx_data(cx);
}
return (NULL);
}
