/* xdr.c - generic XDR routines implementation *//* Copyright 1984-2000 Wind River Systems, Inc. */#include "copyright_wrs.h"/* * Copyright (C) 1984, Sun Microsystems, Inc. * * Sun RPC is a product of Sun Microsystems, Inc. and is provided for * unrestricted use provided that this legend is included on all tape * media and as a part of the software program in whole or part.  Users * may copy or modify Sun RPC without charge, but are not authorized * to license or distribute it to anyone else except as part of a product or * program developed by the user. * * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. * * Sun RPC is provided with no support and without any obligation on the * part of Sun Microsystems, Inc. to assist in its use, correction, * modification or enhancement. * * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC * OR ANY PART THEREOF. * * In no event will Sun Microsystems, Inc. be liable for any lost revenue * or profits or other special, indirect and consequential damages, even if * Sun has been advised of the possibility of such damages. * * Sun Microsystems, Inc. * 2550 Garcia Avenue * Mountain View, California  94043 *//*modification history--------------------01k,18apr00,ham  fixed compilation warnings.01j,29jan96,mem  replaced test of CPU_FAMILY with test of _BYTE_ORDER01i,09jun93,hdn  added support for I80X8601i,17oct94,ism  fixed xdr_u_char() to match header fix (SPR#2675)01h,26may92,rrr  the tree shuffle01g,04oct91,rrr  passed through the ansification filter		  -changed includes to have absolute path from h/		  -fixed #else and #endif		  -changed copyright notice01f,05aug91,del   moved include "vxWorks.h", added ixdr_get_long function		  for I960 version only.01e,10may90,dnw   changed xdr_bytes to not mem_alloc/mem_free if count=0 bytes01d,27oct89,hjb   upgraded to 4.001c,05apr88,gae   changed fprintf() to printErr().01b,11nov87,jlf   added wrs copyright, title, mod history, etc.01a,01nov87,rdc   first VxWorks version*/#ifndef lint/* static char sccsid[] = "@(#)xdr.c 1.1 86/02/03 Copyr 1984 Sun Micro"; */#endif/* * xdr.c, Generic XDR routines implementation. * * These are the "generic" xdr routines used to serialize and de-serialize * most common data items.  See xdr.h for more info on the interface to * xdr. */#include "rpc/rpctypes.h"#include "vxWorks.h"#include "rpc/xdr.h"#include "memLib.h"#include "netinet/in.h"#include "private/funcBindP.h"#include "stdlib.h"#include "string.h"#define	PRINTERR if (_func_printErr != NULL) _func_printErr/* * constants specific to the xdr "protocol" */#define XDR_FALSE	((long) 0)#define XDR_TRUE	((long) 1)#define LASTUNSIGNED	((u_int) 0-1)#define BUFSIZ 1024/* * for unit alignment */static char xdr_zero[BYTES_PER_XDR_UNIT] = { 0, 0, 0, 0 };/**************************************************************************** xdr_free - free a data structure using XDR** Not a filter, but a convenient utility nonetheless*/void xdr_free (proc, objp)				/* 4.0 */    xdrproc_t proc;					/* 4.0 */    char *objp;						/* 4.0 */    {							/* 4.0 */    XDR x;						/* 4.0 */    x.x_op = XDR_FREE;					/* 4.0 */    (*proc) (&x, objp);					/* 4.0 */    }							/* 4.0 *//* * XDR nothing */bool_txdr_void(/* xdrs, addr */)	/* XDR *xdrs; */	/* caddr_t addr; */{	return (TRUE);}/* * XDR integers */bool_txdr_int(xdrs, ip)	XDR *xdrs;	int *ip;{#ifdef lint	(void) (xdr_short(xdrs, (short *)ip));	return (xdr_long(xdrs, (long *)ip));#else	if (sizeof (int) == sizeof (long)) {		return (xdr_long(xdrs, (long *)ip));	} else {		return (xdr_short(xdrs, (short *)ip));	}#endif}/* * XDR unsigned integers */bool_txdr_u_int(xdrs, up)	XDR *xdrs;	u_int *up;{#ifdef lint	(void) (xdr_short(xdrs, (short *)up));	return (xdr_u_long(xdrs, (u_long *)up));#else	if (sizeof (u_int) == sizeof (u_long)) {		return (xdr_u_long(xdrs, (u_long *)up));	} else {		return (xdr_short(xdrs, (short *)up));	}#endif}/* * XDR long integers * same as xdr_u_long - open coded to save a proc call! */bool_txdr_long(xdrs, lp)	register XDR *xdrs;	long *lp;{	if (xdrs->x_op == XDR_ENCODE)		return (XDR_PUTLONG(xdrs, lp));	if (xdrs->x_op == XDR_DECODE)		return (XDR_GETLONG(xdrs, lp));	if (xdrs->x_op == XDR_FREE)		return (TRUE);	return (FALSE);}/* * XDR unsigned long integers * same as xdr_long - open coded to save a proc call! */bool_txdr_u_long(xdrs, ulp)	register XDR *xdrs;	u_long *ulp;{	if (xdrs->x_op == XDR_DECODE)		return (XDR_GETLONG(xdrs, (long *)ulp));	if (xdrs->x_op == XDR_ENCODE)		return (XDR_PUTLONG(xdrs, (long *)ulp));	if (xdrs->x_op == XDR_FREE)		return (TRUE);	return (FALSE);}/* * XDR short integers */bool_txdr_short(xdrs, sp)	register XDR *xdrs;	short *sp;{	long l;	switch (xdrs->x_op) {	case XDR_ENCODE:		l = (long) *sp;		return (XDR_PUTLONG(xdrs, &l));	case XDR_DECODE:		if (!XDR_GETLONG(xdrs, &l)) {			return (FALSE);		}		*sp = (short) l;		return (TRUE);	case XDR_FREE:		return (TRUE);	}	return (FALSE);}/* * XDR unsigned short integers */bool_txdr_u_short(xdrs, usp)	register XDR *xdrs;	u_short *usp;{	u_long l;	switch (xdrs->x_op) {	case XDR_ENCODE:		l = (u_long) *usp;		return (XDR_PUTLONG(xdrs, &l));	case XDR_DECODE:		if (!XDR_GETLONG(xdrs, &l)) {			return (FALSE);		}		*usp = (u_short) l;		return (TRUE);	case XDR_FREE:		return (TRUE);	}	return (FALSE);}/* * XDR a char */bool_t							/* 4.0 */xdr_char(xdrs, cp)					/* 4.0 */	XDR *xdrs;					/* 4.0 */	char *cp;					/* 4.0 */{							/* 4.0 */	int i;						/* 4.0 */	i = (*cp);					/* 4.0 */	if (!xdr_int(xdrs, &i)) {			/* 4.0 */		return (FALSE);				/* 4.0 */	}						/* 4.0 */	*cp = i;					/* 4.0 */	return (TRUE);					/* 4.0 */}							/* 4.0 *//* * XDR an unsigned char */bool_t							/* 4.0 */xdr_u_char(xdrs, ucp)					/* 4.0 */	XDR *xdrs;					/* 4.0 */	u_char *ucp;					/* 4.0 */{							/* 4.0 */	u_int u;					/* 4.0 */	u = (*ucp);					/* 4.0 */	if (!xdr_u_int(xdrs, &u)) {			/* 4.0 */		return (FALSE);				/* 4.0 */	}						/* 4.0 */	*ucp = u;					/* 4.0 */	return (TRUE);					/* 4.0 */}							/* 4.0 *//* * XDR booleans */bool_txdr_bool(xdrs, bp)	register XDR *xdrs;	bool_t *bp;{	long lb;	switch (xdrs->x_op) {	case XDR_ENCODE:		lb = *bp ? XDR_TRUE : XDR_FALSE;		return (XDR_PUTLONG(xdrs, &lb));	case XDR_DECODE:		if (!XDR_GETLONG(xdrs, &lb)) {			return (FALSE);		}		*bp = (lb == XDR_FALSE) ? FALSE : TRUE;		return (TRUE);	case XDR_FREE:		return (TRUE);	}	return (FALSE);}/* * XDR enumerations */bool_txdr_enum(xdrs, ep)	XDR *xdrs;	enum_t *ep;{#ifndef lint				/* 4.0 */	enum sizecheck { SIZEVAL };	/* used to find the size of an enum */	/*	 * enums are treated as ints	 */	if (sizeof (enum sizecheck) == sizeof (long)) {		return (xdr_long(xdrs, (long *)ep));	} else if (sizeof (enum sizecheck) == sizeof (short)) {		return (xdr_short(xdrs, (short *)ep));	} else {		return (FALSE);	}#else	(void) (xdr_short(xdrs, (short *)ep));	return (xdr_long(xdrs, (long *)ep));#endif}/* * XDR opaque data * Allows the specification of a fixed size sequence of opaque bytes. * cp points to the opaque object and cnt gives the byte length. */bool_txdr_opaque(xdrs, cp, cnt)	register XDR *xdrs;	caddr_t cp;	register u_int cnt;{	register u_int rndup;	static int crud[BYTES_PER_XDR_UNIT];	/*	 * if no data we are done	 */	if (cnt == 0)		return (TRUE);	/*	 * round byte count to full xdr units	 */	rndup = cnt % BYTES_PER_XDR_UNIT;	if (rndup > 0)		rndup = BYTES_PER_XDR_UNIT - rndup;	if (xdrs->x_op == XDR_DECODE) {		if (!XDR_GETBYTES(xdrs, cp, cnt)) {			return (FALSE);		}		if (rndup == 0)			return (TRUE);		return (XDR_GETBYTES(xdrs, crud, rndup));	}	if (xdrs->x_op == XDR_ENCODE) {		if (!XDR_PUTBYTES(xdrs, cp, cnt)) {			return (FALSE);		}		if (rndup == 0)			return (TRUE);		return (XDR_PUTBYTES(xdrs, xdr_zero, rndup));	}	if (xdrs->x_op == XDR_FREE) {		return (TRUE);	}	return (FALSE);}/* * XDR counted bytes * *cpp is a pointer to the bytes, *sizep is the count. * If *cpp is NULL maxsize bytes are allocated */bool_txdr_bytes(xdrs, cpp, sizep, maxsize)	register XDR *xdrs;	char **cpp;	register u_int *sizep;	u_int maxsize;{	register char *sp = *cpp;  /* sp is the actual string pointer */	register u_int nodesize;	/*	 * first deal with the length since xdr bytes are counted	 */	if (! xdr_u_int(xdrs, sizep)) {		return (FALSE);	}	nodesize = *sizep;	/* if zero length, then return immediately.	 * this avoids mem_alloc/mem_free of 0 bytes.	 */	if (nodesize == 0) {		return (TRUE);	}	if ((nodesize > maxsize) && (xdrs->x_op != XDR_FREE)) {		return (FALSE);	}	/*	 * now deal with the actual bytes	 */	switch (xdrs->x_op) {	case XDR_DECODE:		if (sp == NULL) {			*cpp = sp = (char *)mem_alloc(nodesize);		}		if (sp == NULL) {			PRINTERR ("xdr_bytes: out of memory\n");			return (FALSE);		}		/* fall into ... */	case XDR_ENCODE:		return (xdr_opaque(xdrs, sp, nodesize));	case XDR_FREE:		if (sp != NULL) {			mem_free(sp, nodesize);			*cpp = NULL;		}		return (TRUE);	}	return (FALSE);}/* * Implemented here due to commanlity of the object. */bool_t							/* 4.0 */xdr_netobj (xdrs, np)					/* 4.0 */    XDR *xdrs;						/* 4.0 */    struct netobj *np;					/* 4.0 */    {							/* 4.0 */    return (xdr_bytes (xdrs, &np->n_bytes, &np->n_len, MAX_NETOBJ_SZ));/* 4.0 */    }							/* 4.0 *//* * XDR a descriminated union * Support routine for discriminated unions. * You create an array of xdrdiscrim structures, terminated with * an entry with a null procedure pointer.  The routine gets * the discriminant value and then searches the array of xdrdiscrims * looking for that value.  It calls the procedure given in the xdrdiscrim * to handle the discriminant.  If there is no specific routine a default * routine may be called. * If there is no specific or default routine an error is returned. */bool_txdr_union(xdrs, dscmp, unp, choices, dfault)	register XDR *xdrs;	enum_t *dscmp;		/* enum to decide which arm to work on */	caddr_t unp;		/* the union itself */	struct xdr_discrim *choices;	/* [value, xdr proc] for each arm */	xdrproc_t dfault;	/* default xdr routine */{	register enum_t dscm;	/*	 * we deal with the discriminator;  it's an enum	 */	if (! xdr_enum(xdrs, dscmp)) {		return (FALSE);	}	dscm = *dscmp;	/*	 * search choices for a value that matches the discriminator.	 * if we find one, execute the xdr routine for that value.	 */	for (; choices->proc != NULL_xdrproc_t; choices++) {		if (choices->value == dscm)			return ((*(choices->proc))(xdrs, unp, LASTUNSIGNED));	}	/*	 * no match - execute the default xdr routine if there is one	 */	return ((dfault == NULL_xdrproc_t) ? FALSE :	    (*dfault)(xdrs, unp, LASTUNSIGNED));}/* * Non-portable xdr primitives. * Care should be taken when moving these routines to new architectures. *//* * XDR null terminated ASCII strings * xdr_string deals with "C strings" - arrays of bytes that are * terminated by a NULL character.  The parameter cpp references a * pointer to storage; If the pointer is null, then the necessary * storage is allocated.  The last parameter is the max allowed length * of the string as specified by a protocol. */bool_txdr_string(xdrs, cpp, maxsize)	register XDR *xdrs;	char **cpp;	u_int maxsize;{	register char *sp = *cpp;  /* sp is the actual string pointer */	u_int size;	u_int nodesize;	/*	 * first deal with the length since xdr strings are counted-strings	 */	switch (xdrs->x_op)				/* 4.0 */	    {						/* 4.0 */	    case XDR_FREE:				/* 4.0 */		if (sp == NULL)	/* already free */	/* 4.0 */		    {					/* 4.0 */		    return (TRUE);			/* 4.0 */		    }					/* 4.0 */		/* fall through */			/* 4.0 */	    case XDR_ENCODE:				/* 4.0 */		size = strlen (sp);			/* 4.0 */		break;					/* 4.0 */	    case XDR_DECODE:				/* 4.0 */		break;					/* 4.0 */	    }						/* 4.0 */	if (! xdr_u_int(xdrs, &size)) {		return (FALSE);	}	if (size > maxsize) {		return (FALSE);	}	nodesize = size + 1;	/*	 * now deal with the actual bytes	 */	switch (xdrs->x_op) {	case XDR_DECODE:		if (sp == NULL)			*cpp = sp = (char *)mem_alloc(nodesize);		if (sp == NULL) {			PRINTERR ("xdr_string: out of memory\n");			return (FALSE);		}		sp[size] = 0;		/* fall into ... */	case XDR_ENCODE:		return (xdr_opaque(xdrs, sp, size));	case XDR_FREE:		mem_free(sp, nodesize);		/* 4.0 */		*cpp = NULL;		return (TRUE);	}	return (FALSE);}/* * Wrapper for xdr_string that can be called directly from * routines like clnt_call */bool_txdr_wrapstring(xdrs, cpp)	XDR *xdrs;	char **cpp;{	if (xdr_string(xdrs, cpp, BUFSIZ)) {		return(TRUE);	}	return(FALSE);}#if	(_BYTE_ORDER != _BIG_ENDIAN)/******************************************************************************** idxdr_get_long - function replacement for IXDR_GET_LONG.** this repleaces the IXDR_GET_LONG macro because macro expansion* of ntohl screws up the incrementing of buf.* Note: this is only for non-big endian versions.*/u_long ixdr_get_long (buf)    u_long **buf;    {    u_long retval = ntohl (**buf);	/* read data from buffer */    ++*buf;				/* increment buffer pointer */    return (retval);    }#endif	/* (_BYTE_ORDER != _BIG_ENDIAN) */