[apple/xnu.git] / bsd / nfs / xdr_subs.h

/*
 * Copyright (c) 2000-2011 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
/*
 * Copyright (c) 1989, 1993
 *     The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Rick Macklem at The University of Guelph.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *     This product includes software developed by the University of
 *     California, Berkeley and its contributors.
 * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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.
 *
 *     @(#)xdr_subs.h  8.3 (Berkeley) 3/30/95
 * FreeBSD-Id: xdr_subs.h,v 1.9 1997/02/22 09:42:53 peter Exp $
 */

#ifndef _NFS_XDR_SUBS_H_
#define _NFS_XDR_SUBS_H_

#include <sys/appleapiopts.h>

#ifdef __APPLE_API_PRIVATE
/*
 * Macros used for conversion to/from xdr representation by nfs...
 * These use the MACHINE DEPENDENT routines ntohl, htonl
 * As defined by "XDR: External Data Representation Standard" RFC1014
 *
 * To simplify the implementation, we use ntohl/htonl even on big-endian
 * machines, and count on them being `#define'd away.  Some of these
 * might be slightly more efficient as quad_t copies on a big-endian,
 * but we cannot count on their alignment anyway.
 */

#define	fxdr_unsigned(t, v)	((t)ntohl((uint32_t)(v)))
#define	txdr_unsigned(v)	(htonl((uint32_t)(v)))

#define	fxdr_hyper(f, t) { \
	((uint32_t *)(t))[_QUAD_HIGHWORD] = ntohl(((uint32_t *)(f))[0]); \
	((uint32_t *)(t))[_QUAD_LOWWORD] = ntohl(((uint32_t *)(f))[1]); \
}
#define	txdr_hyper(f, t) { \
	((uint32_t *)(t))[0] = htonl(((uint32_t *)(f))[_QUAD_HIGHWORD]); \
	((uint32_t *)(t))[1] = htonl(((uint32_t *)(f))[_QUAD_LOWWORD]); \
}


/*
 * xdrbuf
 *
 * generalized functionality for managing the building/dissecting of XDR data
 */
typedef enum xdrbuf_type { XDRBUF_BUFFER=1 } xdrbuf_type;

struct xdrbuf {
	union {
		struct {
			char *			xbb_base;	/* base address of buffer */
			uint32_t		xbb_size;	/* size of buffer */
			uint32_t		xbb_len;	/* length of data in buffer */
		} xb_buffer;
	} xb_u;
	char *		xb_ptr;		/* pointer to current position */
	size_t		xb_left;	/* bytes remaining in current buffer */
	size_t		xb_growsize;	/* bytes to allocate when growing */
	xdrbuf_type	xb_type;	/* type of xdr buffer */
	uint32_t	xb_flags;	/* XB_* (see below) */
};

#define XB_CLEANUP	0x0001	/* needs cleanup */

#define XDRWORD		4	/* the basic XDR building block is a 4 byte (32 bit) word */
#define xdr_rndup(a)	(((a)+3)&(~0x3))	/* round up to XDRWORD size */
#define xdr_pad(a)	(xdr_rndup(a) - (a))	/* calculate round up padding */

void xb_init(struct xdrbuf *, xdrbuf_type);
void xb_init_buffer(struct xdrbuf *, char *, size_t);
void xb_cleanup(struct xdrbuf *);
void *xb_malloc(size_t);
void xb_free(void *);
int xb_grow(struct xdrbuf *);
void xb_set_cur_buf_len(struct xdrbuf *);
char *xb_buffer_base(struct xdrbuf *);
int xb_advance(struct xdrbuf *, uint32_t);
int xb_offset(struct xdrbuf *);
int xb_seek(struct xdrbuf *, uint32_t);
int xb_add_bytes(struct xdrbuf *, const char *, uint32_t, int);
int xb_get_bytes(struct xdrbuf *, char *, uint32_t, int);

#ifdef _NFS_XDR_SUBS_FUNCS_

/*
 * basic initialization of xdrbuf structure
 */
void
xb_init(struct xdrbuf *xbp, xdrbuf_type type)
{
	bzero(xbp, sizeof(*xbp));
	xbp->xb_type = type;
	xbp->xb_flags |= XB_CLEANUP;
}

/*
 * initialize a single-buffer xdrbuf
 */
void
xb_init_buffer(struct xdrbuf *xbp, char *buf, size_t buflen)
{
	xb_init(xbp, XDRBUF_BUFFER);
	xbp->xb_u.xb_buffer.xbb_base = buf;
	xbp->xb_u.xb_buffer.xbb_size = buflen;
	xbp->xb_u.xb_buffer.xbb_len = buflen;
	xbp->xb_growsize = 512;
	xbp->xb_ptr = buf;
	xbp->xb_left = buflen;
	if (buf) /* when using an existing buffer, xb code should skip cleanup */
		xbp->xb_flags &= ~XB_CLEANUP;
}

/*
 * get the pointer to the single-buffer xdrbuf's buffer
 */
char *
xb_buffer_base(struct xdrbuf *xbp)
{
	return (xbp->xb_u.xb_buffer.xbb_base);
}

/*
 * clean up any resources held by an xdrbuf
 */
void
xb_cleanup(struct xdrbuf *xbp)
{
	if (!(xbp->xb_flags & XB_CLEANUP))
		return;
	switch (xbp->xb_type) {
	case XDRBUF_BUFFER:
		if (xbp->xb_u.xb_buffer.xbb_base)
			xb_free(xbp->xb_u.xb_buffer.xbb_base);
		break;
	}
	xbp->xb_flags &= ~XB_CLEANUP;
}

/*
 * set the length of valid data in the current buffer to
 * be up to the current location within the buffer
 */
void
xb_set_cur_buf_len(struct xdrbuf *xbp)
{
	switch (xbp->xb_type) {
	case XDRBUF_BUFFER:
		xbp->xb_u.xb_buffer.xbb_len = xbp->xb_ptr - xbp->xb_u.xb_buffer.xbb_base;
		break;
	}
}

/*
 * advance forward through existing data in xdrbuf
 */
int
xb_advance(struct xdrbuf *xbp, uint32_t len)
{
	uint32_t tlen;

	while (len) {
		if (xbp->xb_left <= 0)
			return (EBADRPC);
		tlen = MIN(xbp->xb_left, len);
		if (tlen) {
			xbp->xb_ptr += tlen;
			xbp->xb_left -= tlen;
			len -= tlen;
		}
	}
	return (0);
}

/*
 * Calculate the current offset in the XDR buffer.
 */
int
xb_offset(struct xdrbuf *xbp)
{
	uint32_t offset = 0;

	switch (xbp->xb_type) {
	case XDRBUF_BUFFER:
		offset = xbp->xb_ptr - xbp->xb_u.xb_buffer.xbb_base;
		break;
	}

	return (offset);
}

/*
 * Seek to the given offset in the existing data in the XDR buffer.
 */
int
xb_seek(struct xdrbuf *xbp, uint32_t offset)
{

	switch (xbp->xb_type) {
	case XDRBUF_BUFFER:
		xbp->xb_ptr = xbp->xb_u.xb_buffer.xbb_base + offset;
		xbp->xb_left = xbp->xb_u.xb_buffer.xbb_len - offset;
		break;
	}

	return (0);
}

/*
 * allocate memory
 */
void *
xb_malloc(size_t size)
{
	void *buf = NULL;

#ifdef KERNEL
	MALLOC(buf, void *, size, M_TEMP, M_WAITOK);
#else
	buf = malloc(size);
#endif
	return (buf);
}
/*
 * free a chunk of memory allocated with xb_malloc()
 */
void
xb_free(void *buf)
{
#ifdef KERNEL
	FREE(buf, M_TEMP);
#else
	free(buf);
#endif
}

/*
 * Increase space available for new data in XDR buffer.
 */
int
xb_grow(struct xdrbuf *xbp)
{
	char *newbuf, *oldbuf;
	size_t newsize, oldsize;

	switch (xbp->xb_type) {
	case XDRBUF_BUFFER:
		oldsize = xbp->xb_u.xb_buffer.xbb_size;
		oldbuf = xbp->xb_u.xb_buffer.xbb_base;
		newsize = oldsize + xbp->xb_growsize;
		newbuf = xb_malloc(newsize);
		if (newbuf == NULL)
			return (ENOMEM);
		if (oldbuf != NULL) {
			bcopy(oldbuf, newbuf, oldsize);
			xb_free(oldbuf);
		}
		xbp->xb_u.xb_buffer.xbb_base = newbuf;
		xbp->xb_u.xb_buffer.xbb_size = newsize;
		xbp->xb_ptr = newbuf + oldsize;
		xbp->xb_left = xbp->xb_growsize;
		break;
	}

	return (0);
}

/*
 * xb_add_bytes()
 *
 * Add "count" bytes of opaque data pointed to by "buf" to the given XDR buffer.
 */
int
xb_add_bytes(struct xdrbuf *xbp, const char *buf, uint32_t count, int nopad)
{
	uint32_t len, tlen;
	int error;

	len = nopad ? count : xdr_rndup(count);

	/* copy in "count" bytes and zero out any pad bytes */
	while (len) {
		if (xbp->xb_left <= 0) {
			/* need more space */
			if ((error = xb_grow(xbp)))
				return (error);
			if (xbp->xb_left <= 0)
				return (ENOMEM);
		}
		tlen = MIN(xbp->xb_left, len);
		if (tlen) {
			if (count) {
				if (tlen > count)
					tlen = count;
				bcopy(buf, xbp->xb_ptr, tlen);
			} else {
				bzero(xbp->xb_ptr, tlen);
			}
			xbp->xb_ptr += tlen;
			xbp->xb_left -= tlen;
			len -= tlen;
			if (count) {
				buf += tlen;
				count -= tlen;
			}
		}
	}
	return (0);
}

/*
 * xb_get_bytes()
 *
 * Get "count" bytes of opaque data from the given XDR buffer.
 */
int
xb_get_bytes(struct xdrbuf *xbp, char *buf, uint32_t count, int nopad)
{
	uint32_t len, tlen;

	len = nopad ? count : xdr_rndup(count);

	/* copy in "count" bytes and zero out any pad bytes */
	while (len) {
		if (xbp->xb_left <= 0)
			return (ENOMEM);
		tlen = MIN(xbp->xb_left, len);
		if (tlen) {
			if (count) {
				if (tlen > count)
					tlen = count;
				bcopy(xbp->xb_ptr, buf, tlen);
			}
			xbp->xb_ptr += tlen;
			xbp->xb_left -= tlen;
			len -= tlen;
			if (count) {
				buf += tlen;
				count -= tlen;
			}
		}
	}
	return (0);
}

#endif /* _NFS_XDR_SUBS_FUNCS_ */


/*
 * macros for building XDR data
 */

/* finalize the data that has been added to the buffer */
#define xb_build_done(E, XB) \
	do { \
		if (E) break; \
		xb_set_cur_buf_len(XB); \
	} while (0)

/* add a 32-bit value */
#define xb_add_32(E, XB, VAL) \
	do { \
		uint32_t __tmp; \
		if (E) break; \
		__tmp = txdr_unsigned(VAL); \
		(E) = xb_add_bytes((XB), (void*)&__tmp, XDRWORD, 0); \
	} while (0)

/* add a 64-bit value */
#define xb_add_64(E, XB, VAL) \
	do { \
		uint64_t __tmp1, __tmp2; \
		if (E) break; \
		__tmp1 = (VAL); \
		txdr_hyper(&__tmp1, &__tmp2); \
		(E) = xb_add_bytes((XB), (char*)&__tmp2, 2 * XDRWORD, 0); \
	} while (0)

/* add an array of XDR words */
#define xb_add_word_array(E, XB, A, LEN) \
	do { \
		uint32_t __i; \
		xb_add_32((E), (XB), (LEN)); \
		for (__i=0; __i < (uint32_t)(LEN); __i++) \
			xb_add_32((E), (XB), (A)[__i]); \
	} while (0)
#define xb_add_bitmap(E, XB, B, LEN)	xb_add_word_array((E), (XB), (B), (LEN))

/* add a file handle */
#define xb_add_fh(E, XB, FHP, FHLEN) \
	do { \
		xb_add_32((E), (XB), (FHLEN)); \
		if (E) break; \
		(E) = xb_add_bytes((XB), (char*)(FHP), (FHLEN), 0); \
	} while (0)

/* add a string */
#define xb_add_string(E, XB, S, LEN) \
	do { \
		xb_add_32((E), (XB), (LEN)); \
		if (E) break; \
		(E) = xb_add_bytes((XB), (const char*)(S), (LEN), 0); \
	} while (0)


/*
 * macros for decoding XDR data
 */

/* skip past data in the buffer */
#define xb_skip(E, XB, LEN) \
	do { \
		if (E) break; \
		(E) = xb_advance((XB), (LEN)); \
	} while (0)

/* get a 32-bit value */
#define xb_get_32(E, XB, LVAL) \
	do { \
		uint32_t __tmp; \
		if (E) break; \
		(E) = xb_get_bytes((XB), (char*)&__tmp, XDRWORD, 0); \
		if (E) break; \
		(LVAL) = fxdr_unsigned(uint32_t, __tmp); \
	} while (0)

/* get a 64-bit value */
#define xb_get_64(E, XB, LVAL) \
	do { \
		uint64_t __tmp; \
		if (E) break; \
		(E) = xb_get_bytes((XB), (char*)&__tmp, 2 * XDRWORD, 0); \
		if (E) break; \
		fxdr_hyper(&__tmp, &(LVAL)); \
	} while (0)

/* get an array of XDR words (of a given expected/maximum length) */
#define xb_get_word_array(E, XB, A, LEN) \
	do { \
		uint32_t __len = 0, __i; \
		xb_get_32((E), (XB), __len); \
		if (E) break; \
		for (__i=0; __i < MIN(__len, (uint32_t)(LEN)); __i++) \
			xb_get_32((E), (XB), (A)[__i]); \
		if (E) break; \
		for (; __i < __len; __i++) \
			xb_skip((E), (XB), XDRWORD); \
		for (; __i < (uint32_t)(LEN); __i++) \
			(A)[__i] = 0; \
		(LEN) = __len; \
	} while (0)
#define xb_get_bitmap(E, XB, B, LEN)	xb_get_word_array((E), (XB), (B), (LEN))

#endif /* __APPLE_API_PRIVATE */
#endif /* _NFS_XDR_SUBS_H_ */
Commit	Line	Data
1c79356b	1	/*
6d2010ae	2	* Copyright (c) 2000-2011 Apple Inc. All rights reserved.
5d5c5d0d	3	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	5	*
2d21ac55 A	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
8f6c56a5	14	*
2d21ac55 A	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
8f6c56a5 A	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
8f6c56a5 A	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
2d21ac55 A	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
8f6c56a5	25	*
2d21ac55	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	27	*/
	28	/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
	29	/*
	30	* Copyright (c) 1989, 1993
91447636	31	* The Regents of the University of California. All rights reserved.
1c79356b A	32	*
	33	* This code is derived from software contributed to Berkeley by
	34	* Rick Macklem at The University of Guelph.
	35	*
	36	* Redistribution and use in source and binary forms, with or without
	37	* modification, are permitted provided that the following conditions
	38	* are met:
	39	* 1. Redistributions of source code must retain the above copyright
	40	* notice, this list of conditions and the following disclaimer.
	41	* 2. Redistributions in binary form must reproduce the above copyright
	42	* notice, this list of conditions and the following disclaimer in the
	43	* documentation and/or other materials provided with the distribution.
	44	* 3. All advertising materials mentioning features or use of this software
	45	* must display the following acknowledgement:
91447636 A	46	* This product includes software developed by the University of
91447636 A	47	* California, Berkeley and its contributors.
1c79356b A	48	* 4. Neither the name of the University nor the names of its contributors
	49	* may be used to endorse or promote products derived from this software
	50	* without specific prior written permission.
	51	*
	52	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	53	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	54	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	55	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	56	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	57	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	58	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	59	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	60	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	61	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	62	* SUCH DAMAGE.
	63	*
91447636	64	* @(#)xdr_subs.h 8.3 (Berkeley) 3/30/95
1c79356b A	65	* FreeBSD-Id: xdr_subs.h,v 1.9 1997/02/22 09:42:53 peter Exp $
1c79356b A	66	*/
1c79356b A	67
	68	#ifndef _NFS_XDR_SUBS_H_
	69	#define _NFS_XDR_SUBS_H_
	70
9bccf70c A	71	#include <sys/appleapiopts.h>
	72
	73	#ifdef __APPLE_API_PRIVATE
1c79356b A	74	/*
	75	* Macros used for conversion to/from xdr representation by nfs...
	76	* These use the MACHINE DEPENDENT routines ntohl, htonl
	77	* As defined by "XDR: External Data Representation Standard" RFC1014
	78	*
	79	* To simplify the implementation, we use ntohl/htonl even on big-endian
	80	* machines, and count on them being `#define'd away. Some of these
	81	* might be slightly more efficient as quad_t copies on a big-endian,
	82	* but we cannot count on their alignment anyway.
	83	*/
	84
b0d623f7 A	85	#define fxdr_unsigned(t, v) ((t)ntohl((uint32_t)(v)))
b0d623f7 A	86	#define txdr_unsigned(v) (htonl((uint32_t)(v)))
1c79356b	87
1c79356b	88	#define fxdr_hyper(f, t) { \
b0d623f7 A	89	((uint32_t )(t))[_QUAD_HIGHWORD] = ntohl(((uint32_t )(f))[0]); \
b0d623f7 A	90	((uint32_t )(t))[_QUAD_LOWWORD] = ntohl(((uint32_t )(f))[1]); \
1c79356b A	91	}
1c79356b A	92	#define txdr_hyper(f, t) { \
b0d623f7 A	93	((uint32_t )(t))[0] = htonl(((uint32_t )(f))[_QUAD_HIGHWORD]); \
b0d623f7 A	94	((uint32_t )(t))[1] = htonl(((uint32_t )(f))[_QUAD_LOWWORD]); \
1c79356b A	95	}
1c79356b A	96
6d2010ae A	97
	98	/*
	99	* xdrbuf
	100	*
	101	* generalized functionality for managing the building/dissecting of XDR data
	102	*/
	103	typedef enum xdrbuf_type { XDRBUF_BUFFER=1 } xdrbuf_type;
	104
	105	struct xdrbuf {
	106	union {
	107	struct {
	108	char * xbb_base; /* base address of buffer */
	109	uint32_t xbb_size; /* size of buffer */
	110	uint32_t xbb_len; /* length of data in buffer */
	111	} xb_buffer;
	112	} xb_u;
	113	char * xb_ptr; /* pointer to current position */
	114	size_t xb_left; /* bytes remaining in current buffer */
	115	size_t xb_growsize; /* bytes to allocate when growing */
	116	xdrbuf_type xb_type; /* type of xdr buffer */
	117	uint32_t xb_flags; /* XB_* (see below) */
	118	};
	119
	120	#define XB_CLEANUP 0x0001 /* needs cleanup */
	121
	122	#define XDRWORD 4 /* the basic XDR building block is a 4 byte (32 bit) word */
	123	#define xdr_rndup(a) (((a)+3)&(~0x3)) /* round up to XDRWORD size */
	124	#define xdr_pad(a) (xdr_rndup(a) - (a)) /* calculate round up padding */
	125
	126	void xb_init(struct xdrbuf *, xdrbuf_type);
	127	void xb_init_buffer(struct xdrbuf , char , size_t);
	128	void xb_cleanup(struct xdrbuf *);
	129	void *xb_malloc(size_t);
	130	void xb_free(void *);
	131	int xb_grow(struct xdrbuf *);
	132	void xb_set_cur_buf_len(struct xdrbuf *);
	133	char xb_buffer_base(struct xdrbuf );
	134	int xb_advance(struct xdrbuf *, uint32_t);
	135	int xb_offset(struct xdrbuf *);
	136	int xb_seek(struct xdrbuf *, uint32_t);
	137	int xb_add_bytes(struct xdrbuf , const char , uint32_t, int);
	138	int xb_get_bytes(struct xdrbuf , char , uint32_t, int);
	139
	140	#ifdef _NFS_XDR_SUBS_FUNCS_
	141
	142	/*
	143	* basic initialization of xdrbuf structure
	144	*/
	145	void
	146	xb_init(struct xdrbuf *xbp, xdrbuf_type type)
	147	{
	148	bzero(xbp, sizeof(*xbp));
	149	xbp->xb_type = type;
	150	xbp->xb_flags \|= XB_CLEANUP;
	151	}
	152
	153	/*
	154	* initialize a single-buffer xdrbuf
	155	*/
	156	void
	157	xb_init_buffer(struct xdrbuf xbp, char buf, size_t buflen)
	158	{
	159	xb_init(xbp, XDRBUF_BUFFER);
	160	xbp->xb_u.xb_buffer.xbb_base = buf;
161	xbp->xb_u.xb_buffer.xbb_size = buflen;
162	xbp->xb_u.xb_buffer.xbb_len = buflen;
163	xbp->xb_growsize = 512;
164	xbp->xb_ptr = buf;
165	xbp->xb_left = buflen;
166	if (buf) /* when using an existing buffer, xb code should skip cleanup */
167	xbp->xb_flags &= ~XB_CLEANUP;
168	}
169
170	/*
171	* get the pointer to the single-buffer xdrbuf's buffer
172	*/
173	char *
174	xb_buffer_base(struct xdrbuf *xbp)
175	{
176	return (xbp->xb_u.xb_buffer.xbb_base);
177	}
178
179	/*
180	* clean up any resources held by an xdrbuf
181	*/
182	void
183	xb_cleanup(struct xdrbuf *xbp)
184	{
185	if (!(xbp->xb_flags & XB_CLEANUP))
186	return;
187	switch (xbp->xb_type) {
188	case XDRBUF_BUFFER:
189	if (xbp->xb_u.xb_buffer.xbb_base)
190	xb_free(xbp->xb_u.xb_buffer.xbb_base);
191	break;
192	}
193	xbp->xb_flags &= ~XB_CLEANUP;
194	}
195
196	/*
197	* set the length of valid data in the current buffer to
198	* be up to the current location within the buffer
199	*/
200	void
201	xb_set_cur_buf_len(struct xdrbuf *xbp)
202	{
203	switch (xbp->xb_type) {
204	case XDRBUF_BUFFER:
205	xbp->xb_u.xb_buffer.xbb_len = xbp->xb_ptr - xbp->xb_u.xb_buffer.xbb_base;
206	break;
207	}
208	}
209
210	/*
211	* advance forward through existing data in xdrbuf
212	*/
213	int
214	xb_advance(struct xdrbuf *xbp, uint32_t len)
215	{
216	uint32_t tlen;
217
218	while (len) {
219	if (xbp->xb_left <= 0)
220	return (EBADRPC);
221	tlen = MIN(xbp->xb_left, len);
222	if (tlen) {
223	xbp->xb_ptr += tlen;
224	xbp->xb_left -= tlen;
225	len -= tlen;
226	}
227	}
228	return (0);
229	}
230
231	/*
232	* Calculate the current offset in the XDR buffer.
233	*/
234	int
235	xb_offset(struct xdrbuf *xbp)
236	{
237	uint32_t offset = 0;
238
239	switch (xbp->xb_type) {
240	case XDRBUF_BUFFER:
241	offset = xbp->xb_ptr - xbp->xb_u.xb_buffer.xbb_base;
242	break;
243	}
244
245	return (offset);
246	}
247
248	/*
249	* Seek to the given offset in the existing data in the XDR buffer.
250	*/
251	int
252	xb_seek(struct xdrbuf *xbp, uint32_t offset)
253	{
254
255	switch (xbp->xb_type) {
256	case XDRBUF_BUFFER:
257	xbp->xb_ptr = xbp->xb_u.xb_buffer.xbb_base + offset;
258	xbp->xb_left = xbp->xb_u.xb_buffer.xbb_len - offset;
259	break;
260	}
261
262	return (0);
263	}
264
265	/*
266	* allocate memory
267	*/
268	void *
269	xb_malloc(size_t size)
270	{
271	void *buf = NULL;
272
273	#ifdef KERNEL
274	MALLOC(buf, void *, size, M_TEMP, M_WAITOK);
275	#else
276	buf = malloc(size);
277	#endif
278	return (buf);
279	}
280	/*
281	* free a chunk of memory allocated with xb_malloc()
282	*/
283	void
284	xb_free(void *buf)
285	{
286	#ifdef KERNEL
287	FREE(buf, M_TEMP);
288	#else
289	free(buf);
290	#endif
291	}
292
293	/*
294	* Increase space available for new data in XDR buffer.
295	*/
296	int
297	xb_grow(struct xdrbuf *xbp)
298	{
299	char newbuf, oldbuf;
300	size_t newsize, oldsize;
301
302	switch (xbp->xb_type) {
303	case XDRBUF_BUFFER:
304	oldsize = xbp->xb_u.xb_buffer.xbb_size;
305	oldbuf = xbp->xb_u.xb_buffer.xbb_base;
306	newsize = oldsize + xbp->xb_growsize;
307	newbuf = xb_malloc(newsize);
308	if (newbuf == NULL)
309	return (ENOMEM);
310	if (oldbuf != NULL) {
311	bcopy(oldbuf, newbuf, oldsize);
312	xb_free(oldbuf);
313	}
314	xbp->xb_u.xb_buffer.xbb_base = newbuf;
315	xbp->xb_u.xb_buffer.xbb_size = newsize;
316	xbp->xb_ptr = newbuf + oldsize;
317	xbp->xb_left = xbp->xb_growsize;
318	break;
319	}
320
321	return (0);
322	}
323
324	/*
325	* xb_add_bytes()
326	*
327	* Add "count" bytes of opaque data pointed to by "buf" to the given XDR buffer.
328	*/
329	int
330	xb_add_bytes(struct xdrbuf xbp, const char buf, uint32_t count, int nopad)
331	{
332	uint32_t len, tlen;
333	int error;
334
335	len = nopad ? count : xdr_rndup(count);
336
337	/* copy in "count" bytes and zero out any pad bytes */
338	while (len) {
339	if (xbp->xb_left <= 0) {
340	/* need more space */
341	if ((error = xb_grow(xbp)))
342	return (error);
343	if (xbp->xb_left <= 0)
344	return (ENOMEM);
345	}
346	tlen = MIN(xbp->xb_left, len);
347	if (tlen) {
348	if (count) {
349	if (tlen > count)
350	tlen = count;
351	bcopy(buf, xbp->xb_ptr, tlen);
352	} else {
353	bzero(xbp->xb_ptr, tlen);
354	}
355	xbp->xb_ptr += tlen;
356	xbp->xb_left -= tlen;
357	len -= tlen;
358	if (count) {
359	buf += tlen;
360	count -= tlen;
361	}
362	}
363	}
364	return (0);
365	}
366
367	/*
368	* xb_get_bytes()
369	*
370	* Get "count" bytes of opaque data from the given XDR buffer.
371	*/
372	int
373	xb_get_bytes(struct xdrbuf xbp, char buf, uint32_t count, int nopad)
374	{
375	uint32_t len, tlen;
376
377	len = nopad ? count : xdr_rndup(count);
378
379	/* copy in "count" bytes and zero out any pad bytes */
380	while (len) {
381	if (xbp->xb_left <= 0)
382	return (ENOMEM);
383	tlen = MIN(xbp->xb_left, len);
384	if (tlen) {
385	if (count) {
386	if (tlen > count)
387	tlen = count;
388	bcopy(xbp->xb_ptr, buf, tlen);
389	}
390	xbp->xb_ptr += tlen;
391	xbp->xb_left -= tlen;
392	len -= tlen;
393	if (count) {
394	buf += tlen;
395	count -= tlen;
396	}
397	}
398	}
399	return (0);
400	}
401
402	#endif /* _NFS_XDR_SUBS_FUNCS_ */
403
404
405	/*
406	* macros for building XDR data
407	*/
408
409	/* finalize the data that has been added to the buffer */
410	#define xb_build_done(E, XB) \
411	do { \
412	if (E) break; \
413	xb_set_cur_buf_len(XB); \
414	} while (0)
415
416	/* add a 32-bit value */
417	#define xb_add_32(E, XB, VAL) \
418	do { \
419	uint32_t __tmp; \
420	if (E) break; \
421	__tmp = txdr_unsigned(VAL); \
422	(E) = xb_add_bytes((XB), (void*)&__tmp, XDRWORD, 0); \
423	} while (0)
424
425	/* add a 64-bit value */
426	#define xb_add_64(E, XB, VAL) \
427	do { \
428	uint64_t __tmp1, __tmp2; \
429	if (E) break; \
430	__tmp1 = (VAL); \
431	txdr_hyper(&__tmp1, &__tmp2); \
432	(E) = xb_add_bytes((XB), (char)&__tmp2, 2 XDRWORD, 0); \
433	} while (0)
434
435	/* add an array of XDR words */
436	#define xb_add_word_array(E, XB, A, LEN) \
437	do { \
438	uint32_t __i; \
439	xb_add_32((E), (XB), (LEN)); \
440	for (__i=0; __i < (uint32_t)(LEN); __i++) \
441	xb_add_32((E), (XB), (A)[__i]); \
442	} while (0)
443	#define xb_add_bitmap(E, XB, B, LEN) xb_add_word_array((E), (XB), (B), (LEN))
444
445	/* add a file handle */
446	#define xb_add_fh(E, XB, FHP, FHLEN) \
447	do { \
448	xb_add_32((E), (XB), (FHLEN)); \
449	if (E) break; \
450	(E) = xb_add_bytes((XB), (char*)(FHP), (FHLEN), 0); \
451	} while (0)
452
453	/* add a string */
454	#define xb_add_string(E, XB, S, LEN) \
455	do { \
456	xb_add_32((E), (XB), (LEN)); \
457	if (E) break; \
458	(E) = xb_add_bytes((XB), (const char*)(S), (LEN), 0); \
459	} while (0)
460
461
462	/*
463	* macros for decoding XDR data
464	*/
465
466	/* skip past data in the buffer */
467	#define xb_skip(E, XB, LEN) \
468	do { \
469	if (E) break; \
470	(E) = xb_advance((XB), (LEN)); \
471	} while (0)
472
473	/* get a 32-bit value */
474	#define xb_get_32(E, XB, LVAL) \
475	do { \
476	uint32_t __tmp; \
477	if (E) break; \
478	(E) = xb_get_bytes((XB), (char*)&__tmp, XDRWORD, 0); \
479	if (E) break; \
480	(LVAL) = fxdr_unsigned(uint32_t, __tmp); \
481	} while (0)
482
483	/* get a 64-bit value */
484	#define xb_get_64(E, XB, LVAL) \
485	do { \
486	uint64_t __tmp; \
487	if (E) break; \
488	(E) = xb_get_bytes((XB), (char)&__tmp, 2 XDRWORD, 0); \
489	if (E) break; \
490	fxdr_hyper(&__tmp, &(LVAL)); \
491	} while (0)
492
493	/* get an array of XDR words (of a given expected/maximum length) */
494	#define xb_get_word_array(E, XB, A, LEN) \
495	do { \
496	uint32_t __len = 0, __i; \
497	xb_get_32((E), (XB), __len); \
498	if (E) break; \
499	for (__i=0; __i < MIN(__len, (uint32_t)(LEN)); __i++) \
500	xb_get_32((E), (XB), (A)[__i]); \
501	if (E) break; \
502	for (; __i < __len; __i++) \
503	xb_skip((E), (XB), XDRWORD); \
504	for (; __i < (uint32_t)(LEN); __i++) \
505	(A)[__i] = 0; \
506	(LEN) = __len; \
507	} while (0)
508	#define xb_get_bitmap(E, XB, B, LEN) xb_get_word_array((E), (XB), (B), (LEN))
509
9bccf70c A	510	#endif /* __APPLE_API_PRIVATE */
9bccf70c A	511	#endif /* _NFS_XDR_SUBS_H_ */