自学教程：C++ xdr_bool函数代码示例

bool_txdr_remote_client_cmd_args (XDR *xdrs, remote_client_cmd_args *objp){	register int32_t *buf;	 if (!xdr_string (xdrs, &objp->cmdstring, MAX_CMD_LEN))		 return FALSE;	 if (!xdr_stringlist (xdrs, &objp->environment_settings))		 return FALSE;	 if (!xdr_string (xdrs, &objp->identstring, MAX_IDENT_LEN))		 return FALSE;	 if (!xdr_int (xdrs, &objp->run_in_background))		 return FALSE;	 if (!xdr_int (xdrs, &objp->run_in_shell))		 return FALSE;	 if (!xdr_Iu32 (xdrs, &objp->timeout))		 return FALSE;	 if (!xdr_bool (xdrs, &objp->fail_on_timeout))		 return FALSE;	 if (!xdr_bool (xdrs, &objp->workqueueID_flag))		 return FALSE;	 if (!xdr_Iu32 (xdrs, &objp->workqueueID))		 return FALSE;	 if (!xdr_Iu32 (xdrs, &objp->actionresultID))		 return FALSE;	 if (!xdr_int (xdrs, &objp->msglevel))		 return FALSE;	return TRUE;}

/* * Function: xdr_nulltype * * Purpose: XDR function for arbitrary pointer types that are either * NULL or contain data. */bool_t xdr_nulltype(XDR *xdrs, void **objp, xdrproc_t proc){     bool_t null;     switch (xdrs->x_op) {     case XDR_DECODE:	  if (!xdr_bool(xdrs, &null))	      return FALSE;	  if (null) {	       *objp = NULL;	       return TRUE;	  }	  return (*proc)(xdrs, objp);     case XDR_ENCODE:	  if (*objp == NULL)	       null = TRUE;	  else	       null = FALSE;	  if (!xdr_bool(xdrs, &null))	       return FALSE;	  if (null == FALSE)	       return (*proc)(xdrs, objp);	  return TRUE;     case XDR_FREE:	  if (*objp)	       return (*proc)(xdrs, objp);	  return TRUE;     }     return FALSE;}

bool_t xdr_Create_LinkParms (XDR *xdrs, Create_LinkParms *objp){#if defined(SOLARIS) && !defined(_LP64)  register long *buf;#else  register int32_t *buf;#endif  if (xdrs->x_op == XDR_ENCODE) {    buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);    if (buf == NULL) {      if (!xdr_long (xdrs, &objp->clientId))        return FALSE;      if (!xdr_bool (xdrs, &objp->lockDevice))        return FALSE;      if (!xdr_u_long (xdrs, &objp->lock_timeout))        return FALSE;    } else {      IXDR_PUT_INT32(buf, objp->clientId);      IXDR_PUT_BOOL(buf, objp->lockDevice);      IXDR_PUT_U_INT32(buf, objp->lock_timeout);    }    if (!xdr_string (xdrs, &objp->device, ~0))      return FALSE;    return TRUE;  } else if (xdrs->x_op == XDR_DECODE) {    buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);    if (buf == NULL) {      if (!xdr_long (xdrs, &objp->clientId))        return FALSE;      if (!xdr_bool (xdrs, &objp->lockDevice))        return FALSE;      if (!xdr_u_long (xdrs, &objp->lock_timeout))        return FALSE;    } else {      objp->clientId = IXDR_GET_INT32(buf);      objp->lockDevice = IXDR_GET_BOOL(buf);      objp->lock_timeout = IXDR_GET_U_INT32(buf);    }    if (!xdr_string (xdrs, &objp->device, ~0))      return FALSE;    return TRUE;  }  if (!xdr_long (xdrs, &objp->clientId))    return FALSE;  if (!xdr_bool (xdrs, &objp->lockDevice))    return FALSE;  if (!xdr_u_long (xdrs, &objp->lock_timeout))    return FALSE;  if (!xdr_string (xdrs, &objp->device, ~0))    return FALSE;  return TRUE;}

bool_txdr_remote_client_query_tag_outcome (XDR *xdrs, remote_client_query_tag_outcome *objp){	register int32_t *buf;	if (xdrs->x_op == XDR_ENCODE) {		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);		if (buf == NULL) {			 if (!xdr_bool (xdrs, &objp->valid))				 return FALSE;			 if (!xdr_u_int (xdrs, &objp->state))				 return FALSE;			 if (!xdr_int (xdrs, &objp->cmd_exit_code))				 return FALSE;			 if (!xdr_int (xdrs, &objp->cmd_exit_signal))				 return FALSE;		} else {			IXDR_PUT_BOOL(buf, objp->valid);			IXDR_PUT_U_LONG(buf, objp->state);			IXDR_PUT_LONG(buf, objp->cmd_exit_code);			IXDR_PUT_LONG(buf, objp->cmd_exit_signal);		}		return TRUE;	} else if (xdrs->x_op == XDR_DECODE) {		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);		if (buf == NULL) {			 if (!xdr_bool (xdrs, &objp->valid))				 return FALSE;			 if (!xdr_u_int (xdrs, &objp->state))				 return FALSE;			 if (!xdr_int (xdrs, &objp->cmd_exit_code))				 return FALSE;			 if (!xdr_int (xdrs, &objp->cmd_exit_signal))				 return FALSE;		} else {			objp->valid = IXDR_GET_BOOL(buf);			objp->state = IXDR_GET_U_LONG(buf);			objp->cmd_exit_code = IXDR_GET_LONG(buf);			objp->cmd_exit_signal = IXDR_GET_LONG(buf);		}	 return TRUE;	}	 if (!xdr_bool (xdrs, &objp->valid))		 return FALSE;	 if (!xdr_u_int (xdrs, &objp->state))		 return FALSE;	 if (!xdr_int (xdrs, &objp->cmd_exit_code))		 return FALSE;	 if (!xdr_int (xdrs, &objp->cmd_exit_signal))		 return FALSE;	return TRUE;}

bool_txdr_klm_holder (XDR *xdrs, klm_holder *objp){    register int32_t *buf;    if (xdrs->x_op == XDR_ENCODE) {        buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);        if (buf == NULL) {            if (!xdr_bool (xdrs, &objp->exclusive))                return FALSE;            if (!xdr_int (xdrs, &objp->svid))                return FALSE;            if (!xdr_u_int (xdrs, &objp->l_offset))                return FALSE;            if (!xdr_u_int (xdrs, &objp->l_len))                return FALSE;        } else {            IXDR_PUT_BOOL(buf, objp->exclusive);            IXDR_PUT_LONG(buf, objp->svid);            IXDR_PUT_U_LONG(buf, objp->l_offset);            IXDR_PUT_U_LONG(buf, objp->l_len);        }        return TRUE;    } else if (xdrs->x_op == XDR_DECODE) {        buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);        if (buf == NULL) {            if (!xdr_bool (xdrs, &objp->exclusive))                return FALSE;            if (!xdr_int (xdrs, &objp->svid))                return FALSE;            if (!xdr_u_int (xdrs, &objp->l_offset))                return FALSE;            if (!xdr_u_int (xdrs, &objp->l_len))                return FALSE;        } else {            objp->exclusive = IXDR_GET_BOOL(buf);            objp->svid = IXDR_GET_LONG(buf);            objp->l_offset = IXDR_GET_U_LONG(buf);            objp->l_len = IXDR_GET_U_LONG(buf);        }        return TRUE;    }    if (!xdr_bool (xdrs, &objp->exclusive))        return FALSE;    if (!xdr_int (xdrs, &objp->svid))        return FALSE;    if (!xdr_u_int (xdrs, &objp->l_offset))        return FALSE;    if (!xdr_u_int (xdrs, &objp->l_len))        return FALSE;    return TRUE;}

bool_txdr_klm_lockargs(XDR *xdrs, klm_lockargs *objp){	if (!xdr_bool(xdrs, &objp->block))		return (FALSE);	if (!xdr_bool(xdrs, &objp->exclusive))		return (FALSE);	if (!xdr_klm_lock(xdrs, &objp->alock))		return (FALSE);	return (TRUE);}

bool_txdr_klm_lockargs (XDR *xdrs, klm_lockargs *objp){    register int32_t *buf;    if (!xdr_bool (xdrs, &objp->block))        return FALSE;    if (!xdr_bool (xdrs, &objp->exclusive))        return FALSE;    if (!xdr_klm_lock (xdrs, &objp->alock))        return FALSE;    return TRUE;}

bool_txdr_nlm4_cancargs (XDR *xdrs, nlm4_cancargs *objp){    if (!xdr_netobj (xdrs, &objp->cookie))        return FALSE;    if (!xdr_bool (xdrs, &objp->block))        return FALSE;    if (!xdr_bool (xdrs, &objp->exclusive))        return FALSE;    if (!xdr_nlm4_lock (xdrs, &objp->alock))        return FALSE;    return TRUE;}

void writeInput(void){  const char routineName[] = "writeInput";  bool_t  result=TRUE, PRD_angle_dep, XRD, big_endian;  FILE   *fp_out;  XDR     xdrs;  if (!strcmp(INPUT_DOT_OUT, "none")) return;  if ((fp_out = fopen(INPUT_DOT_OUT, "w")) == NULL) {    sprintf(messageStr, "Unable to open output file %s",	    INPUT_DOT_OUT);    Error(ERROR_LEVEL_1, routineName, messageStr);    return;  }  xdrstdio_create(&xdrs, fp_out, XDR_ENCODE);  PRD_angle_dep = (input.PRD_angle_dep != PRD_ANGLE_INDEP  &&  atmos.NPRDactive > 0);  XRD           = (input.XRD  &&  atmos.NPRDactive > 0);  /* --- Write various input parameters to file --     -------------- */        result &= xdr_bool(&xdrs, &input.magneto_optical);  result &= xdr_bool(&xdrs, &PRD_angle_dep);  result &= xdr_bool(&xdrs, &XRD);  result &= xdr_enum(&xdrs, (enum_t *) &input.startJ);  result &= xdr_enum(&xdrs, (enum_t *) &input.StokesMode);  result &= xdr_double(&xdrs, &input.metallicity);  result &= xdr_bool(&xdrs, &input.backgr_pol);  /* --- Write Endianness of compute architecture so that J can be         read properly in the analysis --              -------------- */  big_endian = is_big_endian();  result &= xdr_bool(&xdrs, &big_endian);  if (!result) {    sprintf(messageStr, "Unable to write proper amount to output file %s",	    INPUT_DOT_OUT);    Error(ERROR_LEVEL_1, routineName, messageStr);  }  xdr_destroy(&xdrs);  fclose(fp_out);}

bool_txdr_remote_client_copyfile_outcome (XDR *xdrs, remote_client_copyfile_outcome *objp){	register int32_t *buf;	 if (!xdr_bool (xdrs, &objp->valid_copyfile))		 return FALSE;	 if (!xdr_int (xdrs, &objp->num_bytes_in_transfer))		 return FALSE;	 if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0))		 return FALSE;	 if (!xdr_bool (xdrs, &objp->eof))		 return FALSE;	return TRUE;}

bool_txdr_nlm_cancargs (XDR *xdrs, nlm_cancargs *objp){	register int32_t *buf;	 if (!xdr_netobj (xdrs, &objp->cookie))		 return FALSE;	 if (!xdr_bool (xdrs, &objp->block))		 return FALSE;	 if (!xdr_bool (xdrs, &objp->exclusive))		 return FALSE;	 if (!xdr_nlm_lock (xdrs, &objp->alock))		 return FALSE;	return TRUE;}

/* * Conditionally decode a RDMA WRITE chunk list from XDR stream. * * If the next boolean in the XDR stream is false there is no * RDMA WRITE chunk list present. Otherwise iterate over the * array and for each entry: allocate a struct clist and decode. * Pass back an indication via wlist_exists if we have seen a * RDMA WRITE chunk list. */bool_txdr_decode_wlist(XDR *xdrs, struct clist **w, bool_t *wlist_exists){	struct clist	*tmp;	bool_t		more = FALSE;	uint32_t	seg_array_len;	uint32_t	i;	if (!xdr_bool(xdrs, &more))		return (FALSE);	/* is there a wlist? */	if (more == FALSE) {		*wlist_exists = FALSE;		return (TRUE);	}	*wlist_exists = TRUE;	if (!xdr_uint32(xdrs, &seg_array_len))		return (FALSE);	tmp = *w = clist_alloc();	for (i = 0; i < seg_array_len; i++) {		if (!xdr_uint32(xdrs, &tmp->c_dmemhandle.mrc_rmr))			return (FALSE);		if (!xdr_uint32(xdrs, &tmp->c_len))			return (FALSE);		DTRACE_PROBE1(krpc__i__xdr_decode_wlist_len,		    uint_t, tmp->c_len);		if (!xdr_uint64(xdrs, &tmp->u.c_daddr))			return (FALSE);		if (i < seg_array_len - 1) {			tmp->c_next = clist_alloc();			tmp = tmp->c_next;		} else {			tmp->c_next = NULL;		}	}	more = FALSE;	if (!xdr_bool(xdrs, &more))		return (FALSE);	return (TRUE);}

static int xdr_getquota_rslt(XDR *xdrsp, struct getquota_rslt *gqr){	if (!xdr_int(xdrsp, &quotastat)) {		DEBUG(6,("nfs_quotas: Status bad or zero/n"));		return 0;	}	if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bsize)) {		DEBUG(6,("nfs_quotas: Block size bad or zero/n"));		return 0;	}	if (!xdr_bool(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_active)) {		DEBUG(6,("nfs_quotas: Active bad or zero/n"));		return 0;	}	if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bhardlimit)) {		DEBUG(6,("nfs_quotas: Hardlimit bad or zero/n"));		return 0;	}	if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bsoftlimit)) {		DEBUG(6,("nfs_quotas: Softlimit bad or zero/n"));		return 0;	}	if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_curblocks)) {		DEBUG(6,("nfs_quotas: Currentblocks bad or zero/n"));		return 0;	}	return (1);}

bool_txdr_remote_client_query_version_outcome (XDR *xdrs, remote_client_query_version_outcome *objp){	register int32_t *buf;	 if (!xdr_u_int (xdrs, &objp->agent_major_version))		 return FALSE;	 if (!xdr_u_int (xdrs, &objp->agent_minor_version))		 return FALSE;	 if (!xdr_string (xdrs, &objp->agent_version_string, 128))		 return FALSE;	 if (!xdr_string (xdrs, &objp->agent_build_machine, 128))		 return FALSE;	 if (!xdr_bool (xdrs, &objp->p_osdata_is_valid))		 return FALSE;	 if (!xdr_string (xdrs, &objp->p_name, 128))		 return FALSE;	 if (!xdr_string (xdrs, &objp->p_os_type, 128))		 return FALSE;	 if (!xdr_string (xdrs, &objp->p_os_version, 128))		 return FALSE;	 if (!xdr_string (xdrs, &objp->p_os_description, 128))		 return FALSE;	 if (!xdr_string (xdrs, &objp->p_cpu_architecture, 128))		 return FALSE;	return TRUE;}

static int my_xdr_getquota_rslt(XDR *xdrsp, struct getquota_rslt *gqr){	int quotastat;	if (!xdr_int(xdrsp, &quotastat)) {		DEBUG(6,("nfs_quotas: Status bad or zero/n"));		return 0;	}	gqr->GQR_STATUS = quotastat;	if (!xdr_int(xdrsp, &gqr->GQR_RQUOTA.rq_bsize)) {		DEBUG(6,("nfs_quotas: Block size bad or zero/n"));		return 0;	}	if (!xdr_bool(xdrsp, &gqr->GQR_RQUOTA.rq_active)) {		DEBUG(6,("nfs_quotas: Active bad or zero/n"));		return 0;	}	if (!xdr_int(xdrsp, (int *)&gqr->GQR_RQUOTA.rq_bhardlimit)) {		DEBUG(6,("nfs_quotas: Hardlimit bad or zero/n"));		return 0;	}	if (!xdr_int(xdrsp, (int *)&gqr->GQR_RQUOTA.rq_bsoftlimit)) {		DEBUG(6,("nfs_quotas: Softlimit bad or zero/n"));		return 0;	}	if (!xdr_int(xdrsp, (int *)&gqr->GQR_RQUOTA.rq_curblocks)) {		DEBUG(6,("nfs_quotas: Currentblocks bad or zero/n"));		return 0;	}	return (1);}

/* * XDR decode the long reply write chunk. */bool_txdr_decode_reply_wchunk(XDR *xdrs, struct clist **clist){	bool_t		have_rchunk = FALSE;	struct clist	*first = NULL, *ncl = NULL;	uint32_t	num_wclist;	uint32_t	i;	if (!xdr_bool(xdrs, &have_rchunk))		return (FALSE);	if (have_rchunk == FALSE)		return (TRUE);	if (!xdr_uint32(xdrs, &num_wclist)) {		DTRACE_PROBE(krpc__e__xdrrdma__replywchunk__listlength);		return (FALSE);	}	if (num_wclist == 0) {		return (FALSE);	}	first = ncl = clist_alloc();	for (i = 0; i < num_wclist; i++) {		if (i > 0) {			ncl->c_next = clist_alloc();			ncl = ncl->c_next;		}		if (!xdr_uint32(xdrs, &ncl->c_dmemhandle.mrc_rmr))			goto err_out;		if (!xdr_uint32(xdrs, &ncl->c_len))			goto err_out;		if (!xdr_uint64(xdrs, &ncl->u.c_daddr))			goto err_out;		if (ncl->c_len > MAX_SVC_XFER_SIZE) {			DTRACE_PROBE(			    krpc__e__xdrrdma__replywchunk__chunklist_toobig);			ncl->c_len = MAX_SVC_XFER_SIZE;		}		if (!(ncl->c_dmemhandle.mrc_rmr &&		    (ncl->c_len > 0) && ncl->u.c_daddr))			DTRACE_PROBE(			    krpc__e__xdrrdma__replywchunk__invalid_segaddr);		DTRACE_PROBE1(krpc__i__xdr_decode_reply_wchunk_c_len,		    uint32_t, ncl->c_len);	}	*clist = first;	return (TRUE);err_out:	clist_free(first);	return (FALSE);}

/*  * What is going on with linked lists? (!) * First recall the link list declaration from pmap_prot.h: * * struct pmaplist { *	struct pmap pml_map; *	struct pmaplist *pml_map; * }; * * Compare that declaration with a corresponding xdr declaration that  * is (a) pointer-less, and (b) recursive: * * typedef union switch (bool_t) { *  *	case TRUE: struct { *		struct pmap; * 		pmaplist_t foo; *	}; * *	case FALSE: struct {}; * } pmaplist_t; * * Notice that the xdr declaration has no nxt pointer while * the C declaration has no bool_t variable.  The bool_t can be * interpreted as ``more data follows me''; if FALSE then nothing * follows this bool_t; if TRUE then the bool_t is followed by * an actual struct pmap, and then (recursively) by the  * xdr union, pmaplist_t. * * This could be implemented via the xdr_union primitive, though this * would cause a one recursive call per element in the list.  Rather than do * that we can ``unwind'' the recursion * into a while loop and do the union arms in-place. * * The head of the list is what the C programmer wishes to past around * the net, yet is the data that the pointer points to which is interesting; * this sounds like a job for xdr_reference! */bool_txdr_pmaplist(	register XDR *xdrs,	register struct pmaplist **rp){	/*	 * more_elements is pre-computed in case the direction is	 * XDR_ENCODE or XDR_FREE.  more_elements is overwritten by	 * xdr_bool when the direction is XDR_DECODE.	 */	bool_t more_elements;	register int freeing = (xdrs->x_op == XDR_FREE);	register struct pmaplist **next;	while (TRUE) {		more_elements = (bool_t)(*rp != NULL);		if (! xdr_bool(xdrs, &more_elements))			return (FALSE);		if (! more_elements)			return (TRUE);  /* we are done */		/*		 * the unfortunate side effect of non-recursion is that in		 * the case of freeing we must remember the next object		 * before we free the current object ...		 */		if (freeing)			next = &((*rp)->pml_next); 		if (! xdr_reference(xdrs, (caddr_t *)rp,		    (u_int)sizeof(struct pmaplist), xdr_pmap))			return (FALSE);		rp = (freeing) ? next : &((*rp)->pml_next);	}}

static bool_tsmb_posix_grps_helper_xdr(XDR *xdrs, char **identity){	uint32_t pos, len;	uint32_t cnt;	bool_t rc;	if (xdrs->x_op == XDR_DECODE) {		pos = xdr_getpos(xdrs);		if (!xdr_bool(xdrs, &rc))			return (FALSE);		if (!xdr_uint32_t(xdrs, &cnt))			return (FALSE);		rc = xdr_setpos(xdrs, pos);		if (rc == FALSE)			return (FALSE);	} else {		if (*identity == NULL)			return (FALSE);		cnt = ((smb_posix_grps_t *)(uintptr_t)*identity)->pg_ngrps;	}	len = SMB_POSIX_GRPS_SIZE(cnt);	if (!xdr_pointer(xdrs, identity, len, (xdrproc_t)smb_posix_grps_xdr))		return (FALSE);	return (TRUE);}

/* * Serializes/deserializes a stream of struct ypresp_key_val's.  This is used * only by the client side of the batch enumerate operation. */boolxdr_ypall(XDR *xdrs, struct ypall_callback *callback){	bool_t more;	struct ypresp_key_val kv;	char keybuf[YPMAXRECORD];	char valbuf[YPMAXRECORD];	if (xdrs->x_op == XDR_ENCODE)		return (FALSE);	if (xdrs->x_op == XDR_FREE)		return (TRUE);	kv.keydat.dptr = keybuf;	kv.valdat.dptr = valbuf;	kv.keydat.dsize = YPMAXRECORD;	kv.valdat.dsize = YPMAXRECORD;	for (;;) {		if (!xdr_bool(xdrs, &more))			return (FALSE);		if (!more)			return (TRUE);		if (!xdr_ypresp_key_val(xdrs, &kv))			return (FALSE);		if ((*callback->foreach)(kv.status, kv.keydat.dptr,			    kv.keydat.dsize, kv.valdat.dptr, kv.valdat.dsize,			    callback->data))			return (TRUE);	}}

static bool_txdr_mntlistencode(XDR *xdrs, HASHSET *mntlist){    HASHSET_ITERATOR iterator = h_iterator(*mntlist);    for (;;) {        struct mntentry *m = (struct mntentry *)h_next(iterator);        bool_t more_data = (m != NULL);        if (!xdr_bool(xdrs, &more_data)) {            if (iterator != NULL)                free(iterator);            return (FALSE);        }        if (!more_data)            break;        if ((!xdr_name(xdrs, &m->m_host)) ||                (!xdr_dirpath(xdrs, &m->m_path))) {            if (iterator != NULL)                free(iterator);            return (FALSE);        }    }    if (iterator != NULL)        free(iterator);    return (TRUE);}

/* * Serializes/deserializes a ypmaplist. */static boolxdr_ypmaplist(XDR *xdrs, struct ypmaplist **lst){	bool_t more_elements;	int freeing = (xdrs->x_op == XDR_FREE);	struct ypmaplist **next;	for (;;) {		more_elements = (*lst != NULL);		if (!xdr_bool(xdrs, &more_elements))			return (FALSE);		if (!more_elements)			return (TRUE);  /* All done */		if (freeing)			next = &((*lst)->ypml_next);		if (!xdr_reference(xdrs, (caddr_t *)lst,			(uint_t)sizeof (struct ypmaplist),		    (xdrproc_t)xdr_ypmaplist_wrap_string))			return (FALSE);		lst = (freeing) ? next : &((*lst)->ypml_next);	}	/*NOTREACHED*/}

bool_txdr_gss_OID(XDR *xdrs, gss_OID *oidp){	gss_OID oid;	bool_t is_null;	switch (xdrs->x_op) {	case XDR_ENCODE:		oid = *oidp;		if (oid) {			is_null = FALSE;			if (!xdr_bool(xdrs, &is_null)			    || !xdr_gss_OID_desc(xdrs, oid))				return (FALSE);		} else {			is_null = TRUE;			if (!xdr_bool(xdrs, &is_null))				return (FALSE);		}		break;	case XDR_DECODE:		if (!xdr_bool(xdrs, &is_null))			return (FALSE);		if (is_null) {			*oidp = GSS_C_NO_OID;		} else {			oid = mem_alloc(sizeof(gss_OID_desc));			memset(oid, 0, sizeof(*oid));			if (!xdr_gss_OID_desc(xdrs, oid)) {				mem_free(oid, sizeof(gss_OID_desc));				return (FALSE);			}			*oidp = oid;		}		break;	case XDR_FREE:		oid = *oidp;		if (oid) {			xdr_gss_OID_desc(xdrs, oid);			mem_free(oid, sizeof(gss_OID_desc));		}	}	return (TRUE);}

bool_txdr_gss_OID_set(XDR *xdrs, gss_OID_set *setp){	gss_OID_set set;	bool_t is_null;	switch (xdrs->x_op) {	case XDR_ENCODE:		set = *setp;		if (set) {			is_null = FALSE;			if (!xdr_bool(xdrs, &is_null)			    || !xdr_gss_OID_set_desc(xdrs, set))				return (FALSE);		} else {			is_null = TRUE;			if (!xdr_bool(xdrs, &is_null))				return (FALSE);		}		break;	case XDR_DECODE:		if (!xdr_bool(xdrs, &is_null))			return (FALSE);		if (is_null) {			*setp = GSS_C_NO_OID_SET;		} else {			set = mem_alloc(sizeof(gss_OID_set_desc));			memset(set, 0, sizeof(*set));			if (!xdr_gss_OID_set_desc(xdrs, set)) {				mem_free(set, sizeof(gss_OID_set_desc));				return (FALSE);			}			*setp = set;		}		break;	case XDR_FREE:		set = *setp;		if (set) {			xdr_gss_OID_set_desc(xdrs, set);			mem_free(set, sizeof(gss_OID_set_desc));		}	}	return (TRUE);}

/* ARGSUSED */bool_txdr_encode_rlist_svc(XDR *xdrs, clist *rlist){	bool_t	vfalse = FALSE;	ASSERT(rlist == NULL);	return (xdr_bool(xdrs, &vfalse));}

bool_txdr_nlm4_lockargs (XDR *xdrs, nlm4_lockargs *objp){    if (!xdr_netobj (xdrs, &objp->cookie))        return FALSE;    if (!xdr_bool (xdrs, &objp->block))        return FALSE;    if (!xdr_bool (xdrs, &objp->exclusive))        return FALSE;    if (!xdr_nlm4_lock (xdrs, &objp->alock))        return FALSE;    if (!xdr_bool (xdrs, &objp->reclaim))        return FALSE;    if (!xdr_int (xdrs, &objp->state))        return FALSE;    return TRUE;}

voidF77_FUNC(xdrfbool,XDRFBOOL)(int *xdrid, int *pb, int *ret) {        xdr_fortran_lock();	*ret = xdr_bool(xdridptr[*xdrid], pb);	cnt += XDR_INT_SIZE;        xdr_fortran_unlock();}

/* * Serializes a stream of struct ypresp_key_val's.  This is used * only by the ypserv side of the transaction. */static boolxdrypserv_ypall(XDR *xdrs, struct ypreq_nokey *req){	bool_t more = TRUE;	struct ypresp_key_val resp;	DBM *fdb;	resp.keydat.dptr = resp.valdat.dptr = (char *)NULL;	resp.keydat.dsize = resp.valdat.dsize = 0;	if ((fdb = ypset_current_map(req->map, req->domain,					&resp.status)) != NULL) {		ypfilter(fdb, (datum *) NULL, &resp.keydat, &resp.valdat,				&resp.status, FALSE);		while (resp.status == YP_TRUE) {			if (!xdr_bool(xdrs, &more)) {				return (FALSE);			}			if (!xdr_ypresp_key_val(xdrs, &resp)) {				return (FALSE);			}			ypfilter(fdb, &resp.keydat, &resp.keydat, &resp.valdat,					&resp.status, FALSE);		}	}	if (!xdr_bool(xdrs, &more)) {		return (FALSE);	}	if (!xdr_ypresp_key_val(xdrs, &resp)) {		return (FALSE);	}	more = FALSE;	if (!xdr_bool(xdrs, &more)) {		return (FALSE);	}	return (TRUE);}

bool_txdr_primo_out (XDR *xdrs, primo_out *objp){    register int32_t *buf;    if (!xdr_bool (xdrs, &objp->res))        return FALSE;    return TRUE;}

bool_txdr_dirlistp3 (XDR *xdrs, dirlistp3 *objp){	 if (!xdr_pointer (xdrs, (char **)&objp->entries, sizeof (entryp3), (xdrproc_t) xdr_entryp3))		 return FALSE;	 if (!xdr_bool (xdrs, &objp->eof))		 return FALSE;	return TRUE;}