src/rpc_dplx_msg.c - chromiumos/third_party/ntirpc - Git at Google

 /*
  * Copyright (c) 2009, Sun Microsystems, Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  * - Redistributions of source code must retain the above copyright notice,
  *   this list of conditions and the following disclaimer.
  * - Redistributions in binary form must reproduce the above copyright notice,
  *   this list of conditions and the following disclaimer in the documentation
  *   and/or other materials provided with the distribution.
  * - Neither the name of Sun Microsystems, Inc. nor the names of its
  *   contributors may be used to endorse or promote products derived
  *   from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */

 /*
  * rpc_dplx_msg.c
  *
  * Based upon/copied from:
  * rpc_callmsg.c
  *
  * Copyright (C) 1984, Sun Microsystems, Inc.
  *
  */

 #include <config.h>
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>

 #include <rpc/types.h>
 #include <reentrant.h>
 #include <misc/portable.h>
 #include <rpc/rpc.h>
 #include <rpc/xdr_inline.h>
 #include <rpc/auth_inline.h>

 static const struct xdr_discrim reply_dscrm[3] = {
 	{(int)MSG_ACCEPTED, (xdrproc_t) xdr_naccepted_reply},
 	{(int)MSG_DENIED, (xdrproc_t) xdr_nrejected_reply},
 	{__dontcare__, NULL_xdrproc_t}
 };

 /* in glibc 2.14+ x86_64, memcpy no longer tries to handle overlapping areas,
  * see Fedora Bug 691336 (NOTABUG); we dont permit overlapping segments,
  * so memcpy may be a small win over memmove.
  */

 /*
  * encode a reply message, log error messages
  */
 bool
 xdr_reply_encode(XDR *xdrs, struct rpc_msg *dmsg)
 {
 	struct opaque_auth *oa;
 	int32_t *buf;

 	switch (dmsg->rm_reply.rp_stat) {
 	case MSG_ACCEPTED:
 	{
 		struct accepted_reply *ar = (struct accepted_reply *)
 						&(dmsg->rm_reply.ru);

 		oa = &ar->ar_verf;
 		if (oa->oa_length > MAX_AUTH_BYTES) {
 			__warnx(TIRPC_DEBUG_FLAG_ERROR,
 				"%s:%u ERROR ar_verf.oa_length (%u) > %u",
 				__func__, __LINE__,
 				oa->oa_length,
 				MAX_AUTH_BYTES);
 			return (false);
 		}
 		buf = XDR_INLINE(xdrs,
 				 6 * BYTES_PER_XDR_UNIT +
 				 RNDUP(oa->oa_length));

 		if (buf != NULL) {
 			__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
 				"%s:%u ACCEPTED INLINE",
 				__func__, __LINE__);
 			IXDR_PUT_INT32(buf, dmsg->rm_xid);
 			IXDR_PUT_ENUM(buf, dmsg->rm_direction);
 			IXDR_PUT_ENUM(buf, dmsg->rm_reply.rp_stat);
 			IXDR_PUT_ENUM(buf, oa->oa_flavor);
 			IXDR_PUT_INT32(buf, oa->oa_length);
 			if (oa->oa_length) {
 				memcpy(buf, oa->oa_base, oa->oa_length);
 				buf += RNDUP(oa->oa_length) / sizeof(int32_t);
 			}

 			IXDR_PUT_ENUM(buf, ar->ar_stat);
 			switch (ar->ar_stat) {
 			case SUCCESS:
 				__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
 					"%s:%u SUCCESS",
 					__func__, __LINE__);
 				return ((*(ar->ar_results.proc))(xdrs,
 						ar->ar_results.where));

 			case PROG_MISMATCH:
 				__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
 					"%s:%u MISMATCH",
 					__func__, __LINE__);
 				buf = XDR_INLINE(xdrs,
 					2 * BYTES_PER_XDR_UNIT);
 				if (buf != NULL) {
 					IXDR_PUT_ENUM(buf, ar->ar_vers.low);
 					IXDR_PUT_ENUM(buf, ar->ar_vers.high);
 				} else if (!xdr_putuint32(xdrs,
 						&(ar->ar_vers.low))) {
 					__warnx(TIRPC_DEBUG_FLAG_ERROR,
 						"%s:%u ERROR ar_vers.low %u",
 						__func__, __LINE__,
 						ar->ar_vers.low);
 					return (false);
 				} else if (!xdr_putuint32(xdrs,
 						&(ar->ar_vers.high))) {
 					__warnx(TIRPC_DEBUG_FLAG_ERROR,
 						"%s:%u ERROR ar_vers.high %u",
 						__func__, __LINE__,
 						ar->ar_vers.high);
 					return (false);
 				}
 				/* fallthru */
 			case GARBAGE_ARGS:
 			case SYSTEM_ERR:
 			case PROC_UNAVAIL:
 			case PROG_UNAVAIL:
 				break;
 			};
 			return (true);
 		} else {
 			__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
 				"%s:%u ACCEPTED non-INLINE",
 				__func__, __LINE__);
 			return (inline_xdr_union(xdrs,
 				(enum_t *) &(dmsg->rm_reply.rp_stat),
 				(caddr_t)(void *)&(dmsg->rm_reply.ru),
 				reply_dscrm, NULL_xdrproc_t));
 		}
 		/* never arrives here */
 		break;
 	}
 	case MSG_DENIED:
 	{
 		struct rejected_reply *rr = (struct rejected_reply *)
 						&(dmsg->rm_reply.ru);
 		switch (rr->rj_stat) {
 		case RPC_MISMATCH:
 			__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
 				"%s:%u DENIED MISMATCH",
 				__func__, __LINE__);
 			buf = XDR_INLINE(xdrs, 3 * BYTES_PER_XDR_UNIT);

 			if (buf != NULL) {
 				IXDR_PUT_ENUM(buf, rr->rj_stat);
 				IXDR_PUT_U_INT32(buf, rr->rj_vers.low);
 				IXDR_PUT_U_INT32(buf, rr->rj_vers.high);
 			} else if (!xdr_putenum(xdrs, rr->rj_stat)) {
 				__warnx(TIRPC_DEBUG_FLAG_ERROR,
 					"%s:%u ERROR rj_stat %u",
 					__func__, __LINE__,
 					rr->rj_stat);
 				return (false);
 			} else if (!xdr_putuint32(xdrs,
 						&(rr->rj_vers.low))) {
 				__warnx(TIRPC_DEBUG_FLAG_ERROR,
 					"%s:%u ERROR rj_vers.low %u",
 					__func__, __LINE__,
 					rr->rj_vers.low);
 				return (false);
 			} else if (!xdr_putuint32(xdrs,
 						&(rr->rj_vers.high))) {
 				__warnx(TIRPC_DEBUG_FLAG_ERROR,
 					"%s:%u ERROR rj_vers.high %u",
 					__func__, __LINE__,
 					rr->rj_vers.high);
 				return (false);
 			}
 			return (true); /* bugfix */
 		case AUTH_ERROR:
 			__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
 				"%s:%u DENIED AUTH",
 				__func__, __LINE__);
 			buf = XDR_INLINE(xdrs, 2 * BYTES_PER_XDR_UNIT);

 			if (buf != NULL) {
 				IXDR_PUT_ENUM(buf, rr->rj_stat);
 				IXDR_PUT_ENUM(buf, rr->rj_why);
 			} else if (!xdr_putenum(xdrs, rr->rj_stat)) {
 				__warnx(TIRPC_DEBUG_FLAG_ERROR,
 					"%s:%u ERROR rj_stat %u",
 					__func__, __LINE__,
 					rr->rj_stat);
 				return (false);
 			} else if (!xdr_putenum(xdrs, rr->rj_why)) {
 				__warnx(TIRPC_DEBUG_FLAG_ERROR,
 					"%s:%u ERROR rj_why %u",
 					__func__, __LINE__,
 					rr->rj_why);
 				return (false);
 			}
 			return (true); /* bugfix */
 		default:
 			__warnx(TIRPC_DEBUG_FLAG_ERROR,
 				"%s:%u ERROR rr->rj_stat (%u)",
 				__func__, __LINE__,
 				rr->rj_stat);
 			break;
 		};
 		break;
 	}
 	default:
 		__warnx(TIRPC_DEBUG_FLAG_ERROR,
 			"%s:%u ERROR dmsg->rm_reply.rp_stat (%u)",
 			__func__, __LINE__,
 			dmsg->rm_reply.rp_stat);
 		break;
 	};

 	return (false);
 }			/* XDR_ENCODE */

 /*
  * decode a reply message
  *
  * param[IN]	buf	3 more inline
  */
 bool
 xdr_reply_decode(XDR *xdrs, struct rpc_msg *dmsg, int32_t *buf)
 {
 	if (buf != NULL) {
 		__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
 			"%s:%u INLINE",
 			__func__, __LINE__);
 		dmsg->rm_reply.rp_stat = IXDR_GET_ENUM(buf, enum_t);
 	} else {
 		__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
 			"%s:%u non-INLINE",
 			__func__, __LINE__);
 		if (!xdr_getenum(xdrs, (enum_t *)&(dmsg->rm_reply.rp_stat))) {
 			__warnx(TIRPC_DEBUG_FLAG_ERROR,
 				"%s:%u ERROR rm_reply.rp_stat",
 				__func__, __LINE__);
 			return (false);
 		}
 	}

 	switch (dmsg->rm_reply.rp_stat) {
 	case MSG_ACCEPTED:
 	{
 		struct accepted_reply *ar = (struct accepted_reply *)
 						&(dmsg->rm_reply.ru);

 		if (!inline_auth_decode(xdrs, &ar->ar_verf, buf)) {
 			__warnx(TIRPC_DEBUG_FLAG_ERROR,
 				"%s:%u ERROR (return)",
 				__func__, __LINE__);
 			return (false);
 		}

 		if (!xdr_getenum(xdrs, (enum_t *)&(ar->ar_stat))) {
 			__warnx(TIRPC_DEBUG_FLAG_ERROR,
 				"%s:%u ERROR ar_stat",
 				__func__, __LINE__);
 			return (false);
 		}

 		switch (ar->ar_stat) {
 		case SUCCESS:
 			__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
 				"%s:%u SUCCESS",
 				__func__, __LINE__);
 			return ((*(ar->ar_results.proc))(xdrs,
 						&(ar->ar_results.where)));

 		case PROG_MISMATCH:
 			__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
 				"%s:%u MISMATCH",
 				__func__, __LINE__);
 			if (!xdr_getuint32(xdrs, &(ar->ar_vers.low))) {
 				__warnx(TIRPC_DEBUG_FLAG_ERROR,
 					"%s:%u ERROR ar_vers.low",
 					__func__, __LINE__);
 				return (false);
 			}
 			if (!xdr_getuint32(xdrs, &(ar->ar_vers.high))) {
 				__warnx(TIRPC_DEBUG_FLAG_ERROR,
 					"%s:%u ERROR ar_vers.high",
 					__func__, __LINE__);
 				return (false);
 			}

 		case GARBAGE_ARGS:
 		case SYSTEM_ERR:
 		case PROC_UNAVAIL:
 		case PROG_UNAVAIL:
 			/* true */
 			break;
 		default:
 			break;
 		};	/* ar_stat */
 		return (true);
 	}	/* MSG_ACCEPTED */
 	case MSG_DENIED:
 	{
 		/* XXX branch not verified */
 		struct rejected_reply *rr = (struct rejected_reply *)
 						&(dmsg->rm_reply.ru);

 		__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
 			"%s:%u MSG_DENIED not verified",
 			__func__, __LINE__);

 		if (buf != NULL) {
 			rr->rj_stat = IXDR_GET_ENUM(buf, enum_t);
 		} else if (!xdr_getenum(xdrs, (enum_t *)&(rr->rj_stat))) {
 			__warnx(TIRPC_DEBUG_FLAG_ERROR,
 				"%s:%u ERROR rj_stat",
 				__func__, __LINE__);
 			return (false);
 		}

 		switch (rr->rj_stat) {
 		case RPC_MISMATCH:
 			__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
 				"%s:%u DENIED MISMATCH",
 				__func__, __LINE__);
 			if (buf != NULL) {
 				rr->rj_vers.low = IXDR_GET_U_INT32(buf);
 			} else if (!xdr_getuint32(xdrs, &(rr->rj_vers.low))) {
 				__warnx(TIRPC_DEBUG_FLAG_ERROR,
 					"%s:%u ERROR rj_vers.low",
 					__func__, __LINE__);
 				return (false);
 			}
 			if (!xdr_getuint32(xdrs, &(rr->rj_vers.high))) {
 				__warnx(TIRPC_DEBUG_FLAG_ERROR,
 					"%s:%u ERROR rj_vers.high",
 					__func__, __LINE__);
 				return (false);
 			}
 			break;

 		case AUTH_ERROR:
 			__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
 				"%s:%u DENIED AUTH",
 				__func__, __LINE__);
 			if (buf != NULL) {
 				rr->rj_why = IXDR_GET_ENUM(buf, enum_t);
 			} else if (!xdr_getenum(xdrs,
 					(enum_t *)&(rr->rj_why))) {
 				__warnx(TIRPC_DEBUG_FLAG_ERROR,
 					"%s:%u ERROR rj_why",
 					__func__, __LINE__);
 				return (false);
 			}
 			break;
 		};
 		return (true);
 	}	/* MSG_DENIED */
 	default:
 		__warnx(TIRPC_DEBUG_FLAG_ERROR,
 			"%s:%u ERROR dmsg->rm_reply.rp_stat %u",
 			__func__, __LINE__,
 			dmsg->rm_reply.rp_stat);
 		break;
 	};	/* rm_reply.rp_stat */

 	return (false);
 }

 /*
  * decode a duplex message, log error messages
  */
 bool
 xdr_dplx_decode(XDR *xdrs, struct rpc_msg *dmsg)
 {
 	int32_t *buf;

 	/*
 	 * NOTE: 5 here, 3 more in each _decode
 	 */
 	buf = XDR_INLINE(xdrs, 5 * BYTES_PER_XDR_UNIT);
 	if (buf != NULL) {
 		dmsg->rm_xid = IXDR_GET_U_INT32(buf);
 		dmsg->rm_direction = IXDR_GET_ENUM(buf, enum msg_type);
 	} else {
 		if (!xdr_getuint32(xdrs, &(dmsg->rm_xid))) {
 			__warnx(TIRPC_DEBUG_FLAG_ERROR,
 				"%s:%u ERROR rm_xid",
 				__func__, __LINE__);
 			return (false);
 		}
 		if (!xdr_getenum(xdrs, (enum_t *)&(dmsg->rm_direction))) {
 			__warnx(TIRPC_DEBUG_FLAG_ERROR,
 				"%s:%u ERROR rm_direction",
 				__func__, __LINE__);
 			return (false);
 		}
 	}

 	switch (dmsg->rm_direction) {
 	case CALL:
 		return (xdr_call_decode(xdrs, dmsg, buf));
 	case REPLY:
 		return (xdr_reply_decode(xdrs, dmsg, buf));
 	default:
 		__warnx(TIRPC_DEBUG_FLAG_ERROR,
 			"%s:%u ERROR dmsg->rm_direction (%u)",
 			__func__, __LINE__,
 			dmsg->rm_direction);
 		break;
 	};

 	return (false);
 }

 /*
  * XDR a duplex message
  */
 bool
 xdr_dplx_msg(XDR *xdrs, struct rpc_msg *dmsg)
 {
 	assert(xdrs != NULL);
 	assert(dmsg != NULL);

 	switch (xdrs->x_op) {
 	case XDR_ENCODE:
 		switch (dmsg->rm_direction) {
 		case CALL:
 			return (xdr_call_encode(xdrs, dmsg));
 		case REPLY:
 			return (xdr_reply_encode(xdrs, dmsg));
 		default:
 			__warnx(TIRPC_DEBUG_FLAG_ERROR,
 				"%s:%u ERROR dmsg->rm_direction (%u)",
 				__func__, __LINE__,
 				dmsg->rm_direction);
 			break;
 		};
 		break;
 	case XDR_DECODE:
 		return (xdr_dplx_decode(xdrs, dmsg));
 	case XDR_FREE:
 		__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
 			"%s:%u xdrs->x_op XDR_FREE",
 			__func__, __LINE__);
 		return (true);
 	default:
 		__warnx(TIRPC_DEBUG_FLAG_ERROR,
 			"%s:%u ERROR xdrs->x_op (%u)",
 			__func__, __LINE__,
 			xdrs->x_op);
 		break;
 	};

 	return (false);
 }					/* xdr_dplx_msg */
	/*
	* Copyright (c) 2009, Sun Microsystems, Inc.
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are met:
	* - Redistributions of source code must retain the above copyright notice,
	* this list of conditions and the following disclaimer.
	* - Redistributions in binary form must reproduce the above copyright notice,
	* this list of conditions and the following disclaimer in the documentation
	* and/or other materials provided with the distribution.
	* - Neither the name of Sun Microsystems, Inc. nor the names of its
	* contributors may be used to endorse or promote products derived
	* from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	* POSSIBILITY OF SUCH DAMAGE.
	*/

	/*
	* rpc_dplx_msg.c
	*
	* Based upon/copied from:
	* rpc_callmsg.c
	*
	* Copyright (C) 1984, Sun Microsystems, Inc.
	*
	*/

	#include <config.h>
	#include <assert.h>
	#include <stdlib.h>
	#include <string.h>

	#include <rpc/types.h>
	#include <reentrant.h>
	#include <misc/portable.h>
	#include <rpc/rpc.h>
	#include <rpc/xdr_inline.h>
	#include <rpc/auth_inline.h>

	static const struct xdr_discrim reply_dscrm[3] = {
	{(int)MSG_ACCEPTED, (xdrproc_t) xdr_naccepted_reply},
	{(int)MSG_DENIED, (xdrproc_t) xdr_nrejected_reply},
	{__dontcare__, NULL_xdrproc_t}
	};

	/* in glibc 2.14+ x86_64, memcpy no longer tries to handle overlapping areas,
	* see Fedora Bug 691336 (NOTABUG); we dont permit overlapping segments,
	* so memcpy may be a small win over memmove.
	*/

	/*
	* encode a reply message, log error messages
	*/
	bool
	xdr_reply_encode(XDR xdrs, struct rpc_msg dmsg)
	{
	struct opaque_auth *oa;
	int32_t *buf;

	switch (dmsg->rm_reply.rp_stat) {
	case MSG_ACCEPTED:
	{
	struct accepted_reply ar = (struct accepted_reply )
	&(dmsg->rm_reply.ru);

	oa = &ar->ar_verf;
	if (oa->oa_length > MAX_AUTH_BYTES) {
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR ar_verf.oa_length (%u) > %u",
	__func__, __LINE__,
	oa->oa_length,
	MAX_AUTH_BYTES);
	return (false);
	}
	buf = XDR_INLINE(xdrs,
	6 * BYTES_PER_XDR_UNIT +
	RNDUP(oa->oa_length));

	if (buf != NULL) {
	__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
	"%s:%u ACCEPTED INLINE",
	__func__, __LINE__);
	IXDR_PUT_INT32(buf, dmsg->rm_xid);
	IXDR_PUT_ENUM(buf, dmsg->rm_direction);
	IXDR_PUT_ENUM(buf, dmsg->rm_reply.rp_stat);
	IXDR_PUT_ENUM(buf, oa->oa_flavor);
	IXDR_PUT_INT32(buf, oa->oa_length);
	if (oa->oa_length) {
	memcpy(buf, oa->oa_base, oa->oa_length);
	buf += RNDUP(oa->oa_length) / sizeof(int32_t);
	}

	IXDR_PUT_ENUM(buf, ar->ar_stat);
	switch (ar->ar_stat) {
	case SUCCESS:
	__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
	"%s:%u SUCCESS",
	__func__, __LINE__);
	return ((*(ar->ar_results.proc))(xdrs,
	ar->ar_results.where));

	case PROG_MISMATCH:
	__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
	"%s:%u MISMATCH",
	__func__, __LINE__);
	buf = XDR_INLINE(xdrs,
	2 * BYTES_PER_XDR_UNIT);
	if (buf != NULL) {
	IXDR_PUT_ENUM(buf, ar->ar_vers.low);
	IXDR_PUT_ENUM(buf, ar->ar_vers.high);
	} else if (!xdr_putuint32(xdrs,
	&(ar->ar_vers.low))) {
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR ar_vers.low %u",
	__func__, __LINE__,
	ar->ar_vers.low);
	return (false);
	} else if (!xdr_putuint32(xdrs,
	&(ar->ar_vers.high))) {
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR ar_vers.high %u",
	__func__, __LINE__,
	ar->ar_vers.high);
	return (false);
	}
	/* fallthru */
	case GARBAGE_ARGS:
	case SYSTEM_ERR:
	case PROC_UNAVAIL:
	case PROG_UNAVAIL:
	break;
	};
	return (true);
	} else {
	__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
	"%s:%u ACCEPTED non-INLINE",
	__func__, __LINE__);
	return (inline_xdr_union(xdrs,
	(enum_t *) &(dmsg->rm_reply.rp_stat),
	(caddr_t)(void *)&(dmsg->rm_reply.ru),
	reply_dscrm, NULL_xdrproc_t));
	}
	/* never arrives here */
	break;
	}
	case MSG_DENIED:
	{
	struct rejected_reply rr = (struct rejected_reply )
	&(dmsg->rm_reply.ru);
	switch (rr->rj_stat) {
	case RPC_MISMATCH:
	__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
	"%s:%u DENIED MISMATCH",
	__func__, __LINE__);
	buf = XDR_INLINE(xdrs, 3 * BYTES_PER_XDR_UNIT);

	if (buf != NULL) {
	IXDR_PUT_ENUM(buf, rr->rj_stat);
	IXDR_PUT_U_INT32(buf, rr->rj_vers.low);
	IXDR_PUT_U_INT32(buf, rr->rj_vers.high);
	} else if (!xdr_putenum(xdrs, rr->rj_stat)) {
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR rj_stat %u",
	__func__, __LINE__,
	rr->rj_stat);
	return (false);
	} else if (!xdr_putuint32(xdrs,
	&(rr->rj_vers.low))) {
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR rj_vers.low %u",
	__func__, __LINE__,
	rr->rj_vers.low);
	return (false);
	} else if (!xdr_putuint32(xdrs,
	&(rr->rj_vers.high))) {
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR rj_vers.high %u",
	__func__, __LINE__,
	rr->rj_vers.high);
	return (false);
	}
	return (true); /* bugfix */
	case AUTH_ERROR:
	__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
	"%s:%u DENIED AUTH",
	__func__, __LINE__);
	buf = XDR_INLINE(xdrs, 2 * BYTES_PER_XDR_UNIT);

	if (buf != NULL) {
	IXDR_PUT_ENUM(buf, rr->rj_stat);
	IXDR_PUT_ENUM(buf, rr->rj_why);
	} else if (!xdr_putenum(xdrs, rr->rj_stat)) {
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR rj_stat %u",
	__func__, __LINE__,
	rr->rj_stat);
	return (false);
	} else if (!xdr_putenum(xdrs, rr->rj_why)) {
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR rj_why %u",
	__func__, __LINE__,
	rr->rj_why);
	return (false);
	}
	return (true); /* bugfix */
	default:
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR rr->rj_stat (%u)",
	__func__, __LINE__,
	rr->rj_stat);
	break;
	};
	break;
	}
	default:
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR dmsg->rm_reply.rp_stat (%u)",
	__func__, __LINE__,
	dmsg->rm_reply.rp_stat);
	break;
	};

	return (false);
	} /* XDR_ENCODE */

	/*
	* decode a reply message
	*
	* param[IN] buf 3 more inline
	*/
	bool
	xdr_reply_decode(XDR xdrs, struct rpc_msg dmsg, int32_t *buf)
	{
	if (buf != NULL) {
	__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
	"%s:%u INLINE",
	__func__, __LINE__);
	dmsg->rm_reply.rp_stat = IXDR_GET_ENUM(buf, enum_t);
	} else {
	__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
	"%s:%u non-INLINE",
	__func__, __LINE__);
	if (!xdr_getenum(xdrs, (enum_t *)&(dmsg->rm_reply.rp_stat))) {
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR rm_reply.rp_stat",
	__func__, __LINE__);
	return (false);
	}
	}

	switch (dmsg->rm_reply.rp_stat) {
	case MSG_ACCEPTED:
	{
	struct accepted_reply ar = (struct accepted_reply )
	&(dmsg->rm_reply.ru);

	if (!inline_auth_decode(xdrs, &ar->ar_verf, buf)) {
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR (return)",
	__func__, __LINE__);
	return (false);
	}

	if (!xdr_getenum(xdrs, (enum_t *)&(ar->ar_stat))) {
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR ar_stat",
	__func__, __LINE__);
	return (false);
	}

	switch (ar->ar_stat) {
	case SUCCESS:
	__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
	"%s:%u SUCCESS",
	__func__, __LINE__);
	return ((*(ar->ar_results.proc))(xdrs,
	&(ar->ar_results.where)));

	case PROG_MISMATCH:
	__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
	"%s:%u MISMATCH",
	__func__, __LINE__);
	if (!xdr_getuint32(xdrs, &(ar->ar_vers.low))) {
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR ar_vers.low",
	__func__, __LINE__);
	return (false);
	}
	if (!xdr_getuint32(xdrs, &(ar->ar_vers.high))) {
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR ar_vers.high",
	__func__, __LINE__);
	return (false);
	}

	case GARBAGE_ARGS:
	case SYSTEM_ERR:
	case PROC_UNAVAIL:
	case PROG_UNAVAIL:
	/* true */
	break;
	default:
	break;
	}; /* ar_stat */
	return (true);
	} /* MSG_ACCEPTED */
	case MSG_DENIED:
	{
	/* XXX branch not verified */
	struct rejected_reply rr = (struct rejected_reply )
	&(dmsg->rm_reply.ru);

	__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
	"%s:%u MSG_DENIED not verified",
	__func__, __LINE__);

	if (buf != NULL) {
	rr->rj_stat = IXDR_GET_ENUM(buf, enum_t);
	} else if (!xdr_getenum(xdrs, (enum_t *)&(rr->rj_stat))) {
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR rj_stat",
	__func__, __LINE__);
	return (false);
	}

	switch (rr->rj_stat) {
	case RPC_MISMATCH:
	__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
	"%s:%u DENIED MISMATCH",
	__func__, __LINE__);
	if (buf != NULL) {
	rr->rj_vers.low = IXDR_GET_U_INT32(buf);
	} else if (!xdr_getuint32(xdrs, &(rr->rj_vers.low))) {
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR rj_vers.low",
	__func__, __LINE__);
	return (false);
	}
	if (!xdr_getuint32(xdrs, &(rr->rj_vers.high))) {
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR rj_vers.high",
	__func__, __LINE__);
	return (false);
	}
	break;

	case AUTH_ERROR:
	__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
	"%s:%u DENIED AUTH",
	__func__, __LINE__);
	if (buf != NULL) {
	rr->rj_why = IXDR_GET_ENUM(buf, enum_t);
	} else if (!xdr_getenum(xdrs,
	(enum_t *)&(rr->rj_why))) {
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR rj_why",
	__func__, __LINE__);
	return (false);
	}
	break;
	};
	return (true);
	} /* MSG_DENIED */
	default:
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR dmsg->rm_reply.rp_stat %u",
	__func__, __LINE__,
	dmsg->rm_reply.rp_stat);
	break;
	}; /* rm_reply.rp_stat */

	return (false);
	}

	/*
	* decode a duplex message, log error messages
	*/
	bool
	xdr_dplx_decode(XDR xdrs, struct rpc_msg dmsg)
	{
	int32_t *buf;

	/*
	* NOTE: 5 here, 3 more in each _decode
	*/
	buf = XDR_INLINE(xdrs, 5 * BYTES_PER_XDR_UNIT);
	if (buf != NULL) {
	dmsg->rm_xid = IXDR_GET_U_INT32(buf);
	dmsg->rm_direction = IXDR_GET_ENUM(buf, enum msg_type);
	} else {
	if (!xdr_getuint32(xdrs, &(dmsg->rm_xid))) {
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR rm_xid",
	__func__, __LINE__);
	return (false);
	}
	if (!xdr_getenum(xdrs, (enum_t *)&(dmsg->rm_direction))) {
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR rm_direction",
	__func__, __LINE__);
	return (false);
	}
	}

	switch (dmsg->rm_direction) {
	case CALL:
	return (xdr_call_decode(xdrs, dmsg, buf));
	case REPLY:
	return (xdr_reply_decode(xdrs, dmsg, buf));
	default:
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR dmsg->rm_direction (%u)",
	__func__, __LINE__,
	dmsg->rm_direction);
	break;
	};

	return (false);
	}

	/*
	* XDR a duplex message
	*/
	bool
	xdr_dplx_msg(XDR xdrs, struct rpc_msg dmsg)
	{
	assert(xdrs != NULL);
	assert(dmsg != NULL);

	switch (xdrs->x_op) {
	case XDR_ENCODE:
	switch (dmsg->rm_direction) {
	case CALL:
	return (xdr_call_encode(xdrs, dmsg));
	case REPLY:
	return (xdr_reply_encode(xdrs, dmsg));
	default:
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR dmsg->rm_direction (%u)",
	__func__, __LINE__,
	dmsg->rm_direction);
	break;
	};
	break;
	case XDR_DECODE:
	return (xdr_dplx_decode(xdrs, dmsg));
	case XDR_FREE:
	__warnx(TIRPC_DEBUG_FLAG_RPC_MSG,
	"%s:%u xdrs->x_op XDR_FREE",
	__func__, __LINE__);
	return (true);
	default:
	__warnx(TIRPC_DEBUG_FLAG_ERROR,
	"%s:%u ERROR xdrs->x_op (%u)",
	__func__, __LINE__,
	xdrs->x_op);
	break;
	};

	return (false);
	} /* xdr_dplx_msg */