- Missing prototypes, including pointers to functions

- 64 bit long type safe (wire protocols specified in explicit sized types)
- Support systems that don't do unaligned accesses
- Support for explicit int16 and int32 sizes in xdr

Obtained from: a diff of FreeBSD vs. OpenBSD/NetBSD rpc code.

7 files changed, 375 insertions, 150 deletions

diff --git a/lib/libc/xdr/xdr.c b/lib/libc/xdr/xdr.c
index 87b4f7a..0bc3794 100644
--- a/lib/libc/xdr/xdr.c
+++ b/lib/libc/xdr/xdr.c
@@ -30,7 +30,7 @@
 #if defined(LIBC_SCCS) && !defined(lint)
 /*static char *sccsid = "from: @(#)xdr.c 1.35 87/08/12";*/
 /*static char *sccsid = "from: @(#)xdr.c	2.1 88/07/29 4.0 RPCSRC";*/
-static char *rcsid = "$Id: xdr.c,v 1.2 1995/05/30 05:42:03 rgrimes Exp $";
+static char *rcsid = "$Id: xdr.c,v 1.3 1995/10/22 14:53:51 phk Exp $";
 #endif
 
 /*
@@ -45,6 +45,7 @@ static char *rcsid = "$Id: xdr.c,v 1.2 1995/05/30 05:42:03 rgrimes Exp $";
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include <rpc/types.h>
 #include <rpc/xdr.h>
@@ -88,6 +89,7 @@ xdr_void(/* xdrs, addr */)
 	return (TRUE);
 }
 
+
 /*
  * XDR integers
  */
@@ -96,17 +98,25 @@ xdr_int(xdrs, ip)
 	XDR *xdrs;
 	int *ip;
 {
+	long l;
 
-#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));
+	switch (xdrs->x_op) {
+
+	case XDR_ENCODE:
+		l = (long) *ip;
+		return (XDR_PUTLONG(xdrs, &l));
+
+	case XDR_DECODE:
+		if (!XDR_GETLONG(xdrs, &l)) {
+			return (FALSE);
+		}
+		*ip = (int) l;
+		return (TRUE);
+
+	case XDR_FREE:
+		return (TRUE);
 	}
-#endif
+	return (FALSE);
 }
 
 /*
@@ -117,19 +127,28 @@ xdr_u_int(xdrs, up)
 	XDR *xdrs;
 	u_int *up;
 {
+	u_long l;
 
-#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));
+	switch (xdrs->x_op) {
+
+	case XDR_ENCODE:
+		l = (u_long) *up;
+		return (XDR_PUTLONG(xdrs, (long *)&l));
+
+	case XDR_DECODE:
+		if (!XDR_GETLONG(xdrs, (long *)&l)) {
+			return (FALSE);
+		}
+		*up = (u_int) l;
+		return (TRUE);
+
+	case XDR_FREE:
+		return (TRUE);
 	}
-#endif
+	return (FALSE);
 }
 
+
 /*
  * XDR long integers
  * same as xdr_u_long - open coded to save a proc call!
@@ -139,15 +158,14 @@ xdr_long(xdrs, lp)
 	register XDR *xdrs;
 	long *lp;
 {
-
-	if (xdrs->x_op == XDR_ENCODE)
+	switch (xdrs->x_op) {
+	case XDR_ENCODE:
 		return (XDR_PUTLONG(xdrs, lp));
-
-	if (xdrs->x_op == XDR_DECODE)
+	case XDR_DECODE:
 		return (XDR_GETLONG(xdrs, lp));
-
-	if (xdrs->x_op == XDR_FREE)
+	case XDR_FREE:
 		return (TRUE);
+	}
 
 	return (FALSE);
 }
@@ -161,16 +179,79 @@ xdr_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)
+	switch (xdrs->x_op) {
+	case XDR_ENCODE:
 		return (XDR_PUTLONG(xdrs, (long *)ulp));
-	if (xdrs->x_op == XDR_FREE)
+	case XDR_DECODE:
+		return (XDR_GETLONG(xdrs, (long *)ulp));
+	case XDR_FREE:
 		return (TRUE);
+	}
 	return (FALSE);
 }
 
+
+/*
+ * XDR 32-bit integers
+ * same as xdr_u_int32_t - open coded to save a proc call!
+ */
+bool_t
+xdr_int32_t(xdrs, int32_p)
+	register XDR *xdrs;
+	int32_t *int32_p;
+{
+	long l;
+
+	switch (xdrs->x_op) {
+
+	case XDR_ENCODE:
+		l = (long) *int32_p;
+		return (XDR_PUTLONG(xdrs, &l));
+
+	case XDR_DECODE:
+		if (!XDR_GETLONG(xdrs, &l)) {
+			return (FALSE);
+		}
+		*int32_p = (int32_t) l;
+		return (TRUE);
+
+	case XDR_FREE:
+		return (TRUE);
+	}
+	return (FALSE);
+}
+
+/*
+ * XDR unsigned 32-bit integers
+ * same as xdr_int32_t - open coded to save a proc call!
+ */
+bool_t
+xdr_u_int32_t(xdrs, u_int32_p)
+	register XDR *xdrs;
+	u_int32_t *u_int32_p;
+{
+	u_long l;
+
+	switch (xdrs->x_op) {
+
+	case XDR_ENCODE:
+		l = (u_long) *u_int32_p;
+		return (XDR_PUTLONG(xdrs, (long *)&l));
+
+	case XDR_DECODE:
+		if (!XDR_GETLONG(xdrs, (long *)&l)) {
+			return (FALSE);
+		}
+		*u_int32_p = (u_int32_t) l;
+		return (TRUE);
+
+	case XDR_FREE:
+		return (TRUE);
+	}
+	return (FALSE);
+}
+
+
 /*
  * XDR short integers
  */
@@ -214,13 +295,72 @@ xdr_u_short(xdrs, usp)
 
 	case XDR_ENCODE:
 		l = (u_long) *usp;
+		return (XDR_PUTLONG(xdrs, (long *)&l));
+
+	case XDR_DECODE:
+		if (!XDR_GETLONG(xdrs, (long *)&l)) {
+			return (FALSE);
+		}
+		*usp = (u_short) l;
+		return (TRUE);
+
+	case XDR_FREE:
+		return (TRUE);
+	}
+	return (FALSE);
+}
+
+
+/*
+ * XDR 16-bit integers
+ */
+bool_t
+xdr_int16_t(xdrs, int16_p)
+	register XDR *xdrs;
+	int16_t *int16_p;
+{
+	long l;
+
+	switch (xdrs->x_op) {
+
+	case XDR_ENCODE:
+		l = (long) *int16_p;
 		return (XDR_PUTLONG(xdrs, &l));
 
 	case XDR_DECODE:
 		if (!XDR_GETLONG(xdrs, &l)) {
 			return (FALSE);
 		}
-		*usp = (u_short) l;
+		*int16_p = (int16_t) l;
+		return (TRUE);
+
+	case XDR_FREE:
+		return (TRUE);
+	}
+	return (FALSE);
+}
+
+/*
+ * XDR unsigned 16-bit integers
+ */
+bool_t
+xdr_u_int16_t(xdrs, u_int16_p)
+	register XDR *xdrs;
+	u_int16_t *u_int16_p;
+{
+	u_long l;
+
+	switch (xdrs->x_op) {
+
+	case XDR_ENCODE:
+		l = (u_long) *u_int16_p;
+		return (XDR_PUTLONG(xdrs, (long *)&l));
+
+	case XDR_DECODE:
+		if (!XDR_GETLONG(xdrs, (long *)&l)) {
+			return (FALSE);
+		}
+		*u_int16_p = (u_int16_t) l;
 		return (TRUE);
 
 	case XDR_FREE:
@@ -254,7 +394,7 @@ xdr_char(xdrs, cp)
 bool_t
 xdr_u_char(xdrs, cp)
 	XDR *xdrs;
-	char *cp;
+	u_char *cp;
 {
 	u_int u;
 
@@ -311,6 +451,8 @@ xdr_enum(xdrs, ep)
 	 */
 	if (sizeof (enum sizecheck) == sizeof (long)) {
 		return (xdr_long(xdrs, (long *)ep));
+	} else if (sizeof (enum sizecheck) == sizeof (int)) {
+		return (xdr_int(xdrs, (int *)ep));
 	} else if (sizeof (enum sizecheck) == sizeof (short)) {
 		return (xdr_short(xdrs, (short *)ep));
 	} else {
@@ -318,6 +460,7 @@ xdr_enum(xdrs, ep)
 	}
 #else
 	(void) (xdr_short(xdrs, (short *)ep));
+	(void) (xdr_int(xdrs, (int *)ep));
 	return (xdr_long(xdrs, (long *)ep));
 #endif
 }
@@ -355,7 +498,7 @@ xdr_opaque(xdrs, cp, cnt)
 		}
 		if (rndup == 0)
 			return (TRUE);
-		return (XDR_GETBYTES(xdrs, crud, rndup));
+		return (XDR_GETBYTES(xdrs, (caddr_t)crud, rndup));
 	}
 
 	if (xdrs->x_op == XDR_ENCODE) {
@@ -572,8 +715,5 @@ xdr_wrapstring(xdrs, cpp)
 	XDR *xdrs;
 	char **cpp;
 {
-	if (xdr_string(xdrs, cpp, LASTUNSIGNED)) {
-		return (TRUE);
-	}
-	return (FALSE);
+	return xdr_string(xdrs, cpp, LASTUNSIGNED);
 }
diff --git a/lib/libc/xdr/xdr_array.c b/lib/libc/xdr/xdr_array.c
index 35bbb2b..019c255 100644
--- a/lib/libc/xdr/xdr_array.c
+++ b/lib/libc/xdr/xdr_array.c
@@ -30,7 +30,7 @@
 #if defined(LIBC_SCCS) && !defined(lint)
 /*static char *sccsid = "from: @(#)xdr_array.c 1.10 87/08/11 Copyr 1984 Sun Micro";*/
 /*static char *sccsid = "from: @(#)xdr_array.c	2.1 88/07/29 4.0 RPCSRC";*/
-static char *rcsid = "$Id: xdr_array.c,v 1.2 1995/05/30 05:42:04 rgrimes Exp $";
+static char *rcsid = "$Id: xdr_array.c,v 1.3 1995/10/22 14:53:54 phk Exp $";
 #endif
 
 /*
@@ -48,8 +48,7 @@ static char *rcsid = "$Id: xdr_array.c,v 1.2 1995/05/30 05:42:04 rgrimes Exp $";
 #include <rpc/types.h>
 #include <rpc/xdr.h>
 
-#define LASTUNSIGNED	((u_int)0-1)
-
+#define LASTUNSIGNED ((u_int) 0-1)
 
 /*
  * XDR an array of arbitrary elements
@@ -98,7 +97,7 @@ xdr_array(xdrs, addrp, sizep, maxsize, elsize, elproc)
 					"xdr_array: out of memory\n");
 				return (FALSE);
 			}
-			bzero(target, nodesize);
+			memset(target, 0, nodesize);
 			break;
 
 		case XDR_FREE:
diff --git a/lib/libc/xdr/xdr_float.c b/lib/libc/xdr/xdr_float.c
index 105ca43..3fb402c 100644
--- a/lib/libc/xdr/xdr_float.c
+++ b/lib/libc/xdr/xdr_float.c
@@ -30,7 +30,7 @@
 #if defined(LIBC_SCCS) && !defined(lint)
 /*static char *sccsid = "from: @(#)xdr_float.c 1.12 87/08/11 Copyr 1984 Sun Micro";*/
 /*static char *sccsid = "from: @(#)xdr_float.c	2.1 88/07/29 4.0 RPCSRC";*/
-static char *rcsid = "$Id: xdr_float.c,v 1.1 1994/08/07 18:39:32 wollman Exp $";
+static char *rcsid = "$Id: xdr_float.c,v 1.2 1995/05/30 05:42:04 rgrimes Exp $";
 #endif
 
 /*
@@ -51,10 +51,13 @@ static char *rcsid = "$Id: xdr_float.c,v 1.1 1994/08/07 18:39:32 wollman Exp $";
 
 /*
  * NB: Not portable.
- * This routine works on Suns (Sky / 68000's), i386's, MIPS, NS32k and Vaxen.
+ * This routine works on machines with IEEE754 FP and Vaxen.
  */
 
-#if defined(mc68000)||defined(sparc)||defined(i386)||defined(mips)||defined(ns32000)
+#if defined(__m68k__) || defined(__sparc__) || defined(__i386__) || \
+    defined(__mips__) || defined(__ns32k__) || defined(__alpha__) || \
+    defined(__arm32__) || defined(__ppc__)
+#include <machine/endian.h>
 #define IEEEFP
 #endif
 
@@ -94,7 +97,10 @@ xdr_float(xdrs, fp)
 	register XDR *xdrs;
 	register float *fp;
 {
-#ifndef IEEEFP
+#ifdef IEEEFP
+	bool_t rv;
+	long tmpl;
+#else
 	struct ieee_single is;
 	struct vax_single vs, *vsp;
 	struct sgl_limits *lim;
@@ -104,7 +110,8 @@ xdr_float(xdrs, fp)
 
 	case XDR_ENCODE:
 #ifdef IEEEFP
-		return (XDR_PUTLONG(xdrs, (long *)fp));
+		tmpl = *(int32_t *)fp;
+		return (XDR_PUTLONG(xdrs, &tmpl));
 #else
 		vs = *((struct vax_single *)fp);
 		for (i = 0, lim = sgl_limits;
@@ -126,7 +133,9 @@ xdr_float(xdrs, fp)
 
 	case XDR_DECODE:
 #ifdef IEEEFP
-		return (XDR_GETLONG(xdrs, (long *)fp));
+		rv = XDR_GETLONG(xdrs, &tmpl);
+		*(int32_t *)fp = tmpl;
+		return (rv);
 #else
 		vsp = (struct vax_single *)fp;
 		if (!XDR_GETLONG(xdrs, (long *)&is))
@@ -154,10 +163,6 @@ xdr_float(xdrs, fp)
 	return (FALSE);
 }
 
-/*
- * This routine works on Suns (Sky / 68000's), i386's, MIPS and Vaxen.
- */
-
 #ifdef vax
 /* What IEEE double precision floating point looks like on a Vax */
 struct	ieee_double {
@@ -199,8 +204,12 @@ xdr_double(xdrs, dp)
 	register XDR *xdrs;
 	double *dp;
 {
+#ifdef IEEEFP
+	register int32_t *i32p;
+	bool_t rv;
+	long tmpl;
+#else
 	register long *lp;
-#ifndef IEEEFP
 	struct	ieee_double id;
 	struct	vax_double vd;
 	register struct dbl_limits *lim;
@@ -211,12 +220,23 @@ xdr_double(xdrs, dp)
 
 	case XDR_ENCODE:
 #ifdef IEEEFP
-		lp = (long *)dp;
+		i32p = (int32_t *)dp;
 #if BYTE_ORDER == BIG_ENDIAN
-		return (XDR_PUTLONG(xdrs, lp++) && XDR_PUTLONG(xdrs, lp));
+		tmpl = *i32p++;
+		rv = XDR_PUTLONG(xdrs, &tmpl);
+		if (!rv)
+			return (rv);
+		tmpl = *i32p;
+		rv = XDR_PUTLONG(xdrs, &tmpl);
 #else
-		return (XDR_PUTLONG(xdrs, lp+1) && XDR_PUTLONG(xdrs, lp));
+		tmpl = *(i32p+1);
+		rv = XDR_PUTLONG(xdrs, &tmpl);
+		if (!rv)
+			return (rv);
+		tmpl = *i32p;
+		rv = XDR_PUTLONG(xdrs, &tmpl);
 #endif
+		return (rv);
 #else
 		vd = *((struct vax_double *)dp);
 		for (i = 0, lim = dbl_limits;
@@ -244,12 +264,23 @@ xdr_double(xdrs, dp)
 
 	case XDR_DECODE:
 #ifdef IEEEFP
-		lp = (long *)dp;
+		i32p = (int32_t *)dp;
 #if BYTE_ORDER == BIG_ENDIAN
-		return (XDR_GETLONG(xdrs, lp++) && XDR_GETLONG(xdrs, lp));
+		rv = XDR_GETLONG(xdrs, &tmpl);
+		*i32p++ = tmpl;
+		if (!rv)
+			return (rv);
+		rv = XDR_GETLONG(xdrs, &tmpl);
+		*i32p = tmpl;
 #else
-		return (XDR_GETLONG(xdrs, lp+1) && XDR_GETLONG(xdrs, lp));
+		rv = XDR_GETLONG(xdrs, &tmpl);
+		*(i32p+1) = tmpl;
+		if (!rv)
+			return (rv);
+		rv = XDR_GETLONG(xdrs, &tmpl);
+		*i32p = tmpl;
 #endif
+		return (rv);
 #else
 		lp = (long *)&id;
 		if (!XDR_GETLONG(xdrs, lp++) || !XDR_GETLONG(xdrs, lp))
diff --git a/lib/libc/xdr/xdr_mem.c b/lib/libc/xdr/xdr_mem.c
index 6f82f67..0403c98 100644
--- a/lib/libc/xdr/xdr_mem.c
+++ b/lib/libc/xdr/xdr_mem.c
@@ -30,7 +30,7 @@
 #if defined(LIBC_SCCS) && !defined(lint)
 /*static char *sccsid = "from: @(#)xdr_mem.c 1.19 87/08/11 Copyr 1984 Sun Micro";*/
 /*static char *sccsid = "from: @(#)xdr_mem.c	2.1 88/07/29 4.0 RPCSRC";*/
-static char *rcsid = "$Id: xdr_mem.c,v 1.2 1995/05/30 05:42:06 rgrimes Exp $";
+static char *rcsid = "$Id: xdr_mem.c,v 1.3 1995/10/22 14:53:55 phk Exp $";
 #endif
 
 /*
@@ -49,23 +49,37 @@ static char *rcsid = "$Id: xdr_mem.c,v 1.2 1995/05/30 05:42:06 rgrimes Exp $";
 #include <rpc/xdr.h>
 #include <netinet/in.h>
 
-static bool_t	xdrmem_getlong();
-static bool_t	xdrmem_putlong();
+static bool_t	xdrmem_getlong_aligned();
+static bool_t	xdrmem_putlong_aligned();
+static bool_t	xdrmem_getlong_unaligned();
+static bool_t	xdrmem_putlong_unaligned();
 static bool_t	xdrmem_getbytes();
 static bool_t	xdrmem_putbytes();
-static u_int	xdrmem_getpos();
+static u_int	xdrmem_getpos(); /* XXX w/64-bit pointers, u_int not enough! */
 static bool_t	xdrmem_setpos();
-static long *	xdrmem_inline();
+static int32_t *xdrmem_inline_aligned();
+static int32_t *xdrmem_inline_unaligned();
 static void	xdrmem_destroy();
 
-static struct	xdr_ops xdrmem_ops = {
-	xdrmem_getlong,
-	xdrmem_putlong,
+static struct	xdr_ops xdrmem_ops_aligned = {
+	xdrmem_getlong_aligned,
+	xdrmem_putlong_aligned,
 	xdrmem_getbytes,
 	xdrmem_putbytes,
 	xdrmem_getpos,
 	xdrmem_setpos,
-	xdrmem_inline,
+	xdrmem_inline_aligned,
+	xdrmem_destroy
+};
+
+static struct	xdr_ops xdrmem_ops_unaligned = {
+	xdrmem_getlong_unaligned,
+	xdrmem_putlong_unaligned,
+	xdrmem_getbytes,
+	xdrmem_putbytes,
+	xdrmem_getpos,
+	xdrmem_setpos,
+	xdrmem_inline_unaligned,
 	xdrmem_destroy
 };
 
@@ -82,7 +96,8 @@ xdrmem_create(xdrs, addr, size, op)
 {
 
 	xdrs->x_op = op;
-	xdrs->x_ops = &xdrmem_ops;
+	xdrs->x_ops = ((size_t)addr & (sizeof(int32_t) - 1))
+		? &xdrmem_ops_unaligned : &xdrmem_ops_aligned;
 	xdrs->x_private = xdrs->x_base = addr;
 	xdrs->x_handy = size;
 }
@@ -91,31 +106,62 @@ static void
 xdrmem_destroy(/*xdrs*/)
 	/*XDR *xdrs;*/
 {
+
 }
 
 static bool_t
-xdrmem_getlong(xdrs, lp)
+xdrmem_getlong_aligned(xdrs, lp)
 	register XDR *xdrs;
 	long *lp;
 {
 
-	if ((xdrs->x_handy -= sizeof(long)) < 0)
+	if ((xdrs->x_handy -= sizeof(int32_t)) < 0)
 		return (FALSE);
-	*lp = (long)ntohl((u_long)(*((long *)(xdrs->x_private))));
-	xdrs->x_private += sizeof(long);
+	*lp = ntohl(*(int32_t *)(xdrs->x_private));
+	xdrs->x_private += sizeof(int32_t);
 	return (TRUE);
 }
 
 static bool_t
-xdrmem_putlong(xdrs, lp)
+xdrmem_putlong_aligned(xdrs, lp)
 	register XDR *xdrs;
 	long *lp;
 {
 
-	if ((xdrs->x_handy -= sizeof(long)) < 0)
+	if ((xdrs->x_handy -= sizeof(int32_t)) < 0)
 		return (FALSE);
-	*(long *)xdrs->x_private = (long)htonl((u_long)(*lp));
-	xdrs->x_private += sizeof(long);
+	*(int32_t *)xdrs->x_private = htonl(*lp);
+	xdrs->x_private += sizeof(int32_t);
+	return (TRUE);
+}
+
+static bool_t
+xdrmem_getlong_unaligned(xdrs, lp)
+	register XDR *xdrs;
+	long *lp;
+{
+	int32_t l;
+
+	if ((xdrs->x_handy -= sizeof(int32_t)) < 0)
+		return (FALSE);
+	memcpy(&l, xdrs->x_private, sizeof(int32_t));
+	*lp = ntohl(l);
+	xdrs->x_private += sizeof(int32_t);
+	return (TRUE);
+}
+
+static bool_t
+xdrmem_putlong_unaligned(xdrs, lp)
+	register XDR *xdrs;
+	long *lp;
+{
+	int32_t l;
+
+	if ((xdrs->x_handy -= sizeof(int32_t)) < 0)
+		return (FALSE);
+	l = htonl(*lp);
+	memcpy(xdrs->x_private, &l, sizeof(int32_t));
+	xdrs->x_private += sizeof(int32_t);
 	return (TRUE);
 }
 
@@ -128,7 +174,7 @@ xdrmem_getbytes(xdrs, addr, len)
 
 	if ((xdrs->x_handy -= len) < 0)
 		return (FALSE);
-	bcopy(xdrs->x_private, addr, len);
+	memcpy(addr, xdrs->x_private, len);
 	xdrs->x_private += len;
 	return (TRUE);
 }
@@ -142,7 +188,7 @@ xdrmem_putbytes(xdrs, addr, len)
 
 	if ((xdrs->x_handy -= len) < 0)
 		return (FALSE);
-	bcopy(addr, xdrs->x_private, len);
+	memcpy(xdrs->x_private, addr, len);
 	xdrs->x_private += len;
 	return (TRUE);
 }
@@ -152,7 +198,8 @@ xdrmem_getpos(xdrs)
 	register XDR *xdrs;
 {
 
-	return ((u_int)xdrs->x_private - (u_int)xdrs->x_base);
+	/* XXX w/64-bit pointers, u_int not enough! */
+	return ((u_long)xdrs->x_private - (u_long)xdrs->x_base);
 }
 
 static bool_t
@@ -166,21 +213,30 @@ xdrmem_setpos(xdrs, pos)
 	if ((long)newaddr > (long)lastaddr)
 		return (FALSE);
 	xdrs->x_private = newaddr;
-	xdrs->x_handy = (int)lastaddr - (int)newaddr;
+	xdrs->x_handy = (long)lastaddr - (long)newaddr;
 	return (TRUE);
 }
 
-static long *
-xdrmem_inline(xdrs, len)
+static int32_t *
+xdrmem_inline_aligned(xdrs, len)
 	register XDR *xdrs;
 	int len;
 {
-	long *buf = 0;
+	int32_t *buf = 0;
 
 	if (xdrs->x_handy >= len) {
 		xdrs->x_handy -= len;
-		buf = (long *) xdrs->x_private;
+		buf = (int32_t *) xdrs->x_private;
 		xdrs->x_private += len;
 	}
 	return (buf);
 }
+
+static int32_t *
+xdrmem_inline_unaligned(xdrs, len)
+	register XDR *xdrs;
+	int len;
+{
+	
+	return (0);
+}
diff --git a/lib/libc/xdr/xdr_rec.c b/lib/libc/xdr/xdr_rec.c
index 3b69f25..b05c93e 100644
--- a/lib/libc/xdr/xdr_rec.c
+++ b/lib/libc/xdr/xdr_rec.c
@@ -29,7 +29,7 @@
 #if defined(LIBC_SCCS) && !defined(lint)
 /*static char *sccsid = "from: @(#)xdr_rec.c 1.21 87/08/11 Copyr 1984 Sun Micro";*/
 /*static char *sccsid = "from: @(#)xdr_rec.c	2.2 88/08/01 4.0 RPCSRC";*/
-static char *rcsid = "$Id: xdr_rec.c,v 1.3 1995/05/30 05:42:09 rgrimes Exp $";
+static char *rcsid = "$Id: xdr_rec.c,v 1.4 1995/10/22 14:53:56 phk Exp $";
 #endif
 
 /*
@@ -68,7 +68,7 @@ static bool_t	xdrrec_getbytes();
 static bool_t	xdrrec_putbytes();
 static u_int	xdrrec_getpos();
 static bool_t	xdrrec_setpos();
-static long *	xdrrec_inline();
+static int32_t *xdrrec_inline();
 static void	xdrrec_destroy();
 
 static struct  xdr_ops xdrrec_ops = {
@@ -95,7 +95,7 @@ static struct  xdr_ops xdrrec_ops = {
  * meet the needs of xdr and rpc based on tcp.
  */
 
-#define LAST_FRAG ((u_long)(1 << 31))
+#define LAST_FRAG ((u_int32_t)(1 << 31))
 
 typedef struct rec_strm {
 	caddr_t tcp_handle;
@@ -103,16 +103,16 @@ typedef struct rec_strm {
 	/*
 	 * out-goung bits
 	 */
-	int (*writeit)();
+	int (*writeit) __P((caddr_t, caddr_t, int));
 	caddr_t out_base;	/* output buffer (points to frag header) */
 	caddr_t out_finger;	/* next output position */
 	caddr_t out_boundry;	/* data cannot up to this address */
-	u_long *frag_header;	/* beginning of curren fragment */
+	u_int32_t *frag_header;	/* beginning of current fragment */
 	bool_t frag_sent;	/* true if buffer sent in middle of record */
 	/*
 	 * in-coming bits
 	 */
-	int (*readit)();
+	int (*readit) __P((caddr_t, caddr_t, int));
 	u_long in_size;	/* fixed size of the input buffer */
 	caddr_t in_base;
 	caddr_t in_finger;	/* location of next byte to be had */
@@ -164,7 +164,7 @@ xdrrec_create(xdrs, sendsize, recvsize, tcp_handle, readit, writeit)
 		return;
 	}
 	for (rstrm->out_base = rstrm->the_buffer;
-		(u_int)rstrm->out_base % BYTES_PER_XDR_UNIT != 0;
+		(u_long)rstrm->out_base % BYTES_PER_XDR_UNIT != 0;
 		rstrm->out_base++);
 	rstrm->in_base = rstrm->out_base + sendsize;
 	/*
@@ -176,8 +176,8 @@ xdrrec_create(xdrs, sendsize, recvsize, tcp_handle, readit, writeit)
 	rstrm->readit = readit;
 	rstrm->writeit = writeit;
 	rstrm->out_finger = rstrm->out_boundry = rstrm->out_base;
-	rstrm->frag_header = (u_long *)rstrm->out_base;
-	rstrm->out_finger += sizeof(u_long);
+	rstrm->frag_header = (u_int32_t *)rstrm->out_base;
+	rstrm->out_finger += sizeof(u_int32_t);
 	rstrm->out_boundry += sendsize;
 	rstrm->frag_sent = FALSE;
 	rstrm->in_size = recvsize;
@@ -199,19 +199,19 @@ xdrrec_getlong(xdrs, lp)
 	long *lp;
 {
 	register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
-	register long *buflp = (long *)(rstrm->in_finger);
-	long mylong;
+	register int32_t *buflp = (int32_t *)(rstrm->in_finger);
+	int32_t mylong;
 
 	/* first try the inline, fast case */
-	if ((rstrm->fbtbc >= sizeof(long)) &&
-		(((int)rstrm->in_boundry - (int)buflp) >= sizeof(long))) {
-		*lp = (long)ntohl((u_long)(*buflp));
-		rstrm->fbtbc -= sizeof(long);
-		rstrm->in_finger += sizeof(long);
+	if ((rstrm->fbtbc >= sizeof(int32_t)) &&
+		(((long)rstrm->in_boundry - (long)buflp) >= sizeof(int32_t))) {
+		*lp = (long)ntohl((u_int32_t)(*buflp));
+		rstrm->fbtbc -= sizeof(int32_t);
+		rstrm->in_finger += sizeof(int32_t);
 	} else {
-		if (! xdrrec_getbytes(xdrs, (caddr_t)&mylong, sizeof(long)))
+		if (! xdrrec_getbytes(xdrs, (caddr_t)&mylong, sizeof(int32_t)))
 			return (FALSE);
-		*lp = (long)ntohl((u_long)mylong);
+		*lp = (long)ntohl((u_int32_t)mylong);
 	}
 	return (TRUE);
 }
@@ -222,21 +222,21 @@ xdrrec_putlong(xdrs, lp)
 	long *lp;
 {
 	register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
-	register long *dest_lp = ((long *)(rstrm->out_finger));
+	register int32_t *dest_lp = ((int32_t *)(rstrm->out_finger));
 
-	if ((rstrm->out_finger += sizeof(long)) > rstrm->out_boundry) {
+	if ((rstrm->out_finger += sizeof(int32_t)) > rstrm->out_boundry) {
 		/*
 		 * this case should almost never happen so the code is
 		 * inefficient
 		 */
-		rstrm->out_finger -= sizeof(long);
+		rstrm->out_finger -= sizeof(int32_t);
 		rstrm->frag_sent = TRUE;
 		if (! flush_out(rstrm, FALSE))
 			return (FALSE);
-		dest_lp = ((long *)(rstrm->out_finger));
-		rstrm->out_finger += sizeof(long);
+		dest_lp = ((int32_t *)(rstrm->out_finger));
+		rstrm->out_finger += sizeof(int32_t);
 	}
-	*dest_lp = (long)htonl((u_long)(*lp));
+	*dest_lp = (int32_t)htonl((u_int32_t)(*lp));
 	return (TRUE);
 }
 
@@ -275,12 +275,13 @@ xdrrec_putbytes(xdrs, addr, len)
 	register u_int len;
 {
 	register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
-	register int current;
+	register long current;
 
 	while (len > 0) {
-		current = (u_int)rstrm->out_boundry - (u_int)rstrm->out_finger;
+		current = (u_long)rstrm->out_boundry -
+			(u_long)rstrm->out_finger;
 		current = (len < current) ? len : current;
-		bcopy(addr, rstrm->out_finger, current);
+		memcpy(rstrm->out_finger, addr, current);
 		rstrm->out_finger += current;
 		addr += current;
 		len -= current;
@@ -300,7 +301,7 @@ xdrrec_getpos(xdrs)
 	register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
 	register long pos;
 
-	pos = lseek((int)rstrm->tcp_handle, (long) 0, 1);
+	pos = lseek((int)(long)rstrm->tcp_handle, (off_t) 0, 1);
 	if (pos != -1)
 		switch (xdrs->x_op) {
 
@@ -313,7 +314,7 @@ xdrrec_getpos(xdrs)
 			break;
 
 		default:
-			pos = (u_int) -1;
+			pos = -1;
 			break;
 		}
 	return ((u_int) pos);
@@ -355,19 +356,19 @@ xdrrec_setpos(xdrs, pos)
 	return (FALSE);
 }
 
-static long *
+static int32_t *
 xdrrec_inline(xdrs, len)
 	register XDR *xdrs;
 	int len;
 {
 	register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
-	long * buf = NULL;
+	int32_t * buf = NULL;
 
 	switch (xdrs->x_op) {
 
 	case XDR_ENCODE:
 		if ((rstrm->out_finger + len) <= rstrm->out_boundry) {
-			buf = (long *) rstrm->out_finger;
+			buf = (int32_t *) rstrm->out_finger;
 			rstrm->out_finger += len;
 		}
 		break;
@@ -375,7 +376,7 @@ xdrrec_inline(xdrs, len)
 	case XDR_DECODE:
 		if ((len <= rstrm->fbtbc) &&
 			((rstrm->in_finger + len) <= rstrm->in_boundry)) {
-			buf = (long *) rstrm->in_finger;
+			buf = (int32_t *) rstrm->in_finger;
 			rstrm->fbtbc -= len;
 			rstrm->in_finger += len;
 		}
@@ -459,16 +460,16 @@ xdrrec_endofrecord(xdrs, sendnow)
 	register u_long len;  /* fragment length */
 
 	if (sendnow || rstrm->frag_sent ||
-		((u_long)rstrm->out_finger + sizeof(u_long) >=
+		((u_long)rstrm->out_finger + sizeof(u_int32_t) >=
 		(u_long)rstrm->out_boundry)) {
 		rstrm->frag_sent = FALSE;
 		return (flush_out(rstrm, TRUE));
 	}
 	len = (u_long)(rstrm->out_finger) - (u_long)(rstrm->frag_header) -
-	   sizeof(u_long);
+	   sizeof(u_int32_t);
 	*(rstrm->frag_header) = htonl((u_long)len | LAST_FRAG);
-	rstrm->frag_header = (u_long *)rstrm->out_finger;
-	rstrm->out_finger += sizeof(u_long);
+	rstrm->frag_header = (u_int32_t *)rstrm->out_finger;
+	rstrm->out_finger += sizeof(u_int32_t);
 	return (TRUE);
 }
 
@@ -482,16 +483,16 @@ flush_out(rstrm, eor)
 	bool_t eor;
 {
 	register u_long eormask = (eor == TRUE) ? LAST_FRAG : 0;
-	register u_long len = (u_long)(rstrm->out_finger) -
-		(u_long)(rstrm->frag_header) - sizeof(u_long);
+	register u_int32_t len = (u_long)(rstrm->out_finger) -
+		(u_long)(rstrm->frag_header) - sizeof(u_int32_t);
 
 	*(rstrm->frag_header) = htonl(len | eormask);
 	len = (u_long)(rstrm->out_finger) - (u_long)(rstrm->out_base);
 	if ((*(rstrm->writeit))(rstrm->tcp_handle, rstrm->out_base, (int)len)
 		!= (int)len)
 		return (FALSE);
-	rstrm->frag_header = (u_long *)rstrm->out_base;
-	rstrm->out_finger = (caddr_t)rstrm->out_base + sizeof(u_long);
+	rstrm->frag_header = (u_int32_t *)rstrm->out_base;
+	rstrm->out_finger = (caddr_t)rstrm->out_base + sizeof(u_int32_t);
 	return (TRUE);
 }
 
@@ -500,11 +501,11 @@ fill_input_buf(rstrm)
 	register RECSTREAM *rstrm;
 {
 	register caddr_t where;
-	u_int i;
-	register int len;
+	u_long i;
+	register long len;
 
 	where = rstrm->in_base;
-	i = (u_int)rstrm->in_boundry % BYTES_PER_XDR_UNIT;
+	i = (u_long)rstrm->in_boundry % BYTES_PER_XDR_UNIT;
 	where += i;
 	len = rstrm->in_size - i;
 	if ((len = (*(rstrm->readit))(rstrm->tcp_handle, where, len)) == -1)
@@ -521,17 +522,17 @@ get_input_bytes(rstrm, addr, len)
 	register caddr_t addr;
 	register int len;
 {
-	register int current;
+	register long current;
 
 	while (len > 0) {
-		current = (int)rstrm->in_boundry - (int)rstrm->in_finger;
+		current = (long)rstrm->in_boundry - (long)rstrm->in_finger;
 		if (current == 0) {
 			if (! fill_input_buf(rstrm))
 				return (FALSE);
 			continue;
 		}
 		current = (len < current) ? len : current;
-		bcopy(rstrm->in_finger, addr, current);
+		memcpy(addr, rstrm->in_finger, current);
 		rstrm->in_finger += current;
 		addr += current;
 		len -= current;
@@ -543,7 +544,7 @@ static bool_t  /* next two bytes of the input stream are treated as a header */
 set_input_fragment(rstrm)
 	register RECSTREAM *rstrm;
 {
-	u_long header;
+	u_int32_t header;
 
 	if (! get_input_bytes(rstrm, (caddr_t)&header, sizeof(header)))
 		return (FALSE);
@@ -558,10 +559,10 @@ skip_input_bytes(rstrm, cnt)
 	register RECSTREAM *rstrm;
 	long cnt;
 {
-	register int current;
+	register long current;
 
 	while (cnt > 0) {
-		current = (int)rstrm->in_boundry - (int)rstrm->in_finger;
+		current = (long)rstrm->in_boundry - (long)rstrm->in_finger;
 		if (current == 0) {
 			if (! fill_input_buf(rstrm))
 				return (FALSE);
diff --git a/lib/libc/xdr/xdr_reference.c b/lib/libc/xdr/xdr_reference.c
index 91ccff2..0cf1fde 100644
--- a/lib/libc/xdr/xdr_reference.c
+++ b/lib/libc/xdr/xdr_reference.c
@@ -30,7 +30,7 @@
 #if defined(LIBC_SCCS) && !defined(lint)
 /*static char *sccsid = "from: @(#)xdr_reference.c 1.11 87/08/11 SMI";*/
 /*static char *sccsid = "from: @(#)xdr_reference.c	2.1 88/07/29 4.0 RPCSRC";*/
-static char *rcsid = "$Id: xdr_reference.c,v 1.2 1995/05/30 05:42:12 rgrimes Exp $";
+static char *rcsid = "$Id: xdr_reference.c,v 1.3 1995/10/22 14:53:58 phk Exp $";
 #endif
 
 /*
@@ -48,7 +48,7 @@ static char *rcsid = "$Id: xdr_reference.c,v 1.2 1995/05/30 05:42:12 rgrimes Exp
 #include <rpc/types.h>
 #include <rpc/xdr.h>
 
-#define LASTUNSIGNED	((u_int)0-1)
+#define LASTUNSIGNED ((u_int) 0-1)
 
 /*
  * XDR an indirect pointer
@@ -81,7 +81,7 @@ xdr_reference(xdrs, pp, size, proc)
 				    "xdr_reference: out of memory\n");
 				return (FALSE);
 			}
-			bzero(loc, (int)size);
+			memset(loc, 0, (int)size);
 			break;
 	}
 
diff --git a/lib/libc/xdr/xdr_stdio.c b/lib/libc/xdr/xdr_stdio.c
index 5cfdf20..64b0b82 100644
--- a/lib/libc/xdr/xdr_stdio.c
+++ b/lib/libc/xdr/xdr_stdio.c
@@ -30,7 +30,7 @@
 #if defined(LIBC_SCCS) && !defined(lint)
 /*static char *sccsid = "from: @(#)xdr_stdio.c 1.16 87/08/11 Copyr 1984 Sun Micro";*/
 /*static char *sccsid = "from: @(#)xdr_stdio.c	2.1 88/07/29 4.0 RPCSRC";*/
-static char *rcsid = "$Id: xdr_stdio.c,v 1.1 1994/08/07 18:39:35 wollman Exp $";
+static char *rcsid = "$Id: xdr_stdio.c,v 1.2 1995/05/30 05:42:12 rgrimes Exp $";
 #endif
 
 /*
@@ -53,7 +53,7 @@ static bool_t	xdrstdio_getbytes();
 static bool_t	xdrstdio_putbytes();
 static u_int	xdrstdio_getpos();
 static bool_t	xdrstdio_setpos();
-static long *	xdrstdio_inline();
+static int32_t *xdrstdio_inline();
 static void	xdrstdio_destroy();
 
 /*
@@ -99,7 +99,7 @@ xdrstdio_destroy(xdrs)
 {
 	(void)fflush((FILE *)xdrs->x_private);
 	/* xx should we close the file ?? */
-};
+}
 
 static bool_t
 xdrstdio_getlong(xdrs, lp)
@@ -107,11 +107,10 @@ xdrstdio_getlong(xdrs, lp)
 	register long *lp;
 {
 
-	if (fread((caddr_t)lp, sizeof(long), 1, (FILE *)xdrs->x_private) != 1)
+	if (fread((caddr_t)lp, sizeof(int32_t), 1,
+		(FILE *)xdrs->x_private) != 1)
 		return (FALSE);
-#ifndef mc68000
-	*lp = ntohl(*lp);
-#endif
+	*lp = (long)ntohl((int32_t)*lp);
 	return (TRUE);
 }
 
@@ -121,11 +120,10 @@ xdrstdio_putlong(xdrs, lp)
 	long *lp;
 {
 
-#ifndef mc68000
-	long mycopy = htonl(*lp);
-	lp = &mycopy;
-#endif
-	if (fwrite((caddr_t)lp, sizeof(long), 1, (FILE *)xdrs->x_private) != 1)
+	long mycopy = (long)htonl((int32_t)*lp);
+
+	if (fwrite((caddr_t)&mycopy, sizeof(int32_t), 1,
+		(FILE *)xdrs->x_private) != 1)
 		return (FALSE);
 	return (TRUE);
 }
@@ -172,7 +170,7 @@ xdrstdio_setpos(xdrs, pos)
 		FALSE : TRUE);
 }
 
-static long *
+static int32_t *
 xdrstdio_inline(xdrs, len)
 	XDR *xdrs;
 	u_int len;