libc/rpc/clnt_vc.c

168 	struct ct_data *ct = NULL;	/* client handle */
182 	ct = (struct ct_data *)mem_alloc(sizeof (*ct));
183 	if ((cl == (CLIENT *)NULL) || (ct == (struct ct_data *)NULL)) {
190 	ct->ct_addr.buf = NULL;
250 	ct->ct_closeit = FALSE;
255 	ct->ct_fd = fd;
256 	ct->ct_wait.tv_usec = 0;
257 	ct->ct_waitset = FALSE;
258 	ct->ct_addr.buf = malloc(raddr->maxlen);
259 	if (ct->ct_addr.buf == NULL)
261 	memcpy(ct->ct_addr.buf, raddr->buf, raddr->len);
262 	ct->ct_addr.len = raddr->maxlen;
263 	ct->ct_addr.maxlen = raddr->maxlen;
278 	xdrmem_create(&(ct->ct_xdrs), ct->ct_u.ct_mcallc, MCALL_MSG_SIZE,
280 	if (! xdr_callhdr(&(ct->ct_xdrs), &call_msg)) {
281 		if (ct->ct_closeit) {
286 	ct->ct_mpos = XDR_GETPOS(&(ct->ct_xdrs));
287 	XDR_DESTROY(&(ct->ct_xdrs));
288 	assert(ct->ct_mpos + sizeof(uint32_t) <= MCALL_MSG_SIZE);
295 	cl->cl_private = ct;
299 	xdrrec_create(&(ct->ct_xdrs), sendsz, recvsz,
304 	if (ct) {
305 		if (ct->ct_addr.len)
306 			mem_free(ct->ct_addr.buf, ct->ct_addr.len);
307 		mem_free(ct, sizeof (struct ct_data));
324 	struct ct_data *ct = (struct ct_data *) cl->cl_private;
325 	XDR *xdrs = &(ct->ct_xdrs);
328 	u_int32_t *msg_x_id = &ct->ct_u.ct_mcalli;    /* yuk */
340 	while (vc_fd_locks[ct->ct_fd])
341 		cond_wait(&vc_cv[ct->ct_fd], &clnt_fd_lock);
346 	vc_fd_locks[ct->ct_fd] = rpc_lock_value;
348 	if (!ct->ct_waitset) {
351 			ct->ct_wait = timeout;
360 	ct->ct_error.re_status = RPC_SUCCESS;
364 		if ((! XDR_PUTBYTES(xdrs, ct->ct_u.ct_mcallc, ct->ct_mpos)) ||
368 			if (ct->ct_error.re_status == RPC_SUCCESS)
369 				ct->ct_error.re_status = RPC_CANTENCODEARGS;
371 			release_fd_lock(ct->ct_fd, mask);
372 			return (ct->ct_error.re_status);
375 		*(uint32_t *) &ct->ct_u.ct_mcallc[ct->ct_mpos] = htonl(proc);
376 		if (! __rpc_gss_wrap(cl->cl_auth, ct->ct_u.ct_mcallc,
377 			ct->ct_mpos + sizeof(uint32_t),
379 			if (ct->ct_error.re_status == RPC_SUCCESS)
380 				ct->ct_error.re_status = RPC_CANTENCODEARGS;
382 			release_fd_lock(ct->ct_fd, mask);
383 			return (ct->ct_error.re_status);
387 		release_fd_lock(ct->ct_fd, mask);
388 		return (ct->ct_error.re_status = RPC_CANTSEND);
391 		release_fd_lock(ct->ct_fd, mask);
398 		release_fd_lock(ct->ct_fd, mask);
399 		return(ct->ct_error.re_status = RPC_TIMEDOUT);
412 			release_fd_lock(ct->ct_fd, mask);
413 			return (ct->ct_error.re_status);
417 			if (ct->ct_error.re_status == RPC_SUCCESS)
419 			release_fd_lock(ct->ct_fd, mask);
420 			return (ct->ct_error.re_status);
429 	_seterr_reply(&reply_msg, &(ct->ct_error));
430 	if (ct->ct_error.re_status == RPC_SUCCESS) {
433 			ct->ct_error.re_status = RPC_AUTHERROR;
434 			ct->ct_error.re_why = AUTH_INVALIDRESP;
443 				if (ct->ct_error.re_status == RPC_SUCCESS)
444 					ct->ct_error.re_status =
460 	release_fd_lock(ct->ct_fd, mask);
461 	return (ct->ct_error.re_status);
469 	struct ct_data *ct;
474 	ct = (struct ct_data *) cl->cl_private;
475 	*errp = ct->ct_error;
484 	struct ct_data *ct;
492 	ct = (struct ct_data *)cl->cl_private;
493 	xdrs = &(ct->ct_xdrs);
498 	while (vc_fd_locks[ct->ct_fd])
499 		cond_wait(&vc_cv[ct->ct_fd], &clnt_fd_lock);
504 	cond_signal(&vc_cv[ct->ct_fd]);
522 	struct ct_data *ct;
530 	ct = (struct ct_data *)cl->cl_private;
535 	while (vc_fd_locks[ct->ct_fd])
536 		cond_wait(&vc_cv[ct->ct_fd], &clnt_fd_lock);
541 	vc_fd_locks[ct->ct_fd] = rpc_lock_value;
546 		ct->ct_closeit = TRUE;
547 		release_fd_lock(ct->ct_fd, mask);
550 		ct->ct_closeit = FALSE;
551 		release_fd_lock(ct->ct_fd, mask);
559 		release_fd_lock(ct->ct_fd, mask);
565 			release_fd_lock(ct->ct_fd, mask);
568 		ct->ct_wait = *(struct timeval *)infop;
569 		ct->ct_waitset = TRUE;
572 		*(struct timeval *)infop = ct->ct_wait;
575 		(void) memcpy(info, ct->ct_addr.buf, (size_t)ct->ct_addr.len);
578 		*(int *)info = ct->ct_fd;
582 		*(struct netbuf *)info = ct->ct_addr;
585 		release_fd_lock(ct->ct_fd, mask);
594 		    ntohl(*(u_int32_t *)(void *)&ct->ct_u.ct_mcalli);
598 		*(u_int32_t *)(void *)&ct->ct_u.ct_mcalli =
610 		    ntohl(*(u_int32_t *)(void *)(ct->ct_u.ct_mcallc +
615 		*(u_int32_t *)(void *)(ct->ct_u.ct_mcallc +
628 		    ntohl(*(u_int32_t *)(void *)(ct->ct_u.ct_mcallc +
633 		*(u_int32_t *)(void *)(ct->ct_u.ct_mcallc +
639 		release_fd_lock(ct->ct_fd, mask);
642 	release_fd_lock(ct->ct_fd, mask);
651 	struct ct_data *ct = (struct ct_data *) cl->cl_private;
652 	int ct_fd = ct->ct_fd;
658 	ct = (struct ct_data *) cl->cl_private;
665 	if (ct->ct_closeit && ct->ct_fd != -1) {
666 		(void)_close(ct->ct_fd);
668 	XDR_DESTROY(&(ct->ct_xdrs));
669 	if (ct->ct_addr.buf)
670 		free(ct->ct_addr.buf);
671 	mem_free(ct, sizeof(struct ct_data));
695 	struct ct_data *ct = (struct ct_data *)ctp;
697 	int milliseconds = (int)((ct->ct_wait.tv_sec * 1000) +
698 	    (ct->ct_wait.tv_usec / 1000));
702 	fd.fd = ct->ct_fd;
707 			ct->ct_error.re_status = RPC_TIMEDOUT;
713 			ct->ct_error.re_status = RPC_CANTRECV;
714 			ct->ct_error.re_errno = errno;
721 	if ((_getpeername(ct->ct_fd, &sa, &sal) == 0) &&
723 		len = __msgread(ct->ct_fd, buf, (size_t)len);
725 		len = _read(ct->ct_fd, buf, (size_t)len);
731 		ct->ct_error.re_errno = ECONNRESET;
732 		ct->ct_error.re_status = RPC_CANTRECV;
737 		ct->ct_error.re_errno = errno;
738 		ct->ct_error.re_status = RPC_CANTRECV;
752 	struct ct_data *ct = (struct ct_data *)ctp;
756 	if ((_getpeername(ct->ct_fd, &sa, &sal) == 0) &&
759 			if ((i = __msgwrite(ct->ct_fd, buf,
761 				ct->ct_error.re_errno = errno;
762 				ct->ct_error.re_status = RPC_CANTSEND;
768 			if ((i = _write(ct->ct_fd, buf, (size_t)cnt)) == -1) {
769 				ct->ct_error.re_errno = errno;
770 				ct->ct_error.re_status = RPC_CANTSEND;