summary refs log tree commit diff
path: root/sunrpc/xdr.c
diff options
context:
space:
mode:
Diffstat (limited to 'sunrpc/xdr.c')
-rw-r--r--sunrpc/xdr.c819
1 files changed, 431 insertions, 388 deletions
diff --git a/sunrpc/xdr.c b/sunrpc/xdr.c
index 969fa6ba04..d666119376 100644
--- a/sunrpc/xdr.c
+++ b/sunrpc/xdr.c
@@ -57,72 +57,72 @@ static char sccsid[] = "@(#)xdr.c 1.35 87/08/12";
 /*
  * for unit alignment
  */
-static char xdr_zero[BYTES_PER_XDR_UNIT] = { 0, 0, 0, 0 };
+static const char xdr_zero[BYTES_PER_XDR_UNIT] =
+{0, 0, 0, 0};
 
 /*
  * Free a data structure using XDR
  * Not a filter, but a convenient utility nonetheless
  */
 void
-xdr_free(proc, objp)
-	xdrproc_t proc;
-	char *objp;
+xdr_free (proc, objp)
+     xdrproc_t proc;
+     char *objp;
 {
-	XDR x;
+  XDR x;
 
-	x.x_op = XDR_FREE;
-	(*proc)(&x, objp);
+  x.x_op = XDR_FREE;
+  (*proc) (&x, objp);
 }
 
 /*
  * XDR nothing
  */
 bool_t
-xdr_void(/* xdrs, addr */)
-	/* XDR *xdrs; */
-	/* caddr_t addr; */
+xdr_void (void)
 {
-
-	return (TRUE);
+  return TRUE;
 }
 
 /*
  * XDR integers
  */
 bool_t
-xdr_int(xdrs, ip)
-	XDR *xdrs;
-	int *ip;
+xdr_int (xdrs, ip)
+     XDR *xdrs;
+     int *ip;
 {
 
 #ifdef lint
-	(void) (xdr_short(xdrs, (short *)ip));
-	return (xdr_long(xdrs, (long *)ip));
+  (void) (xdr_short (xdrs, (short *) ip));
+  return (xdr_long (xdrs, (long *) ip));
 #else
-# if INT_MAX < LONG_MAX
-	long l;
-
-	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;
-	      case XDR_FREE:
-		return TRUE;
+#if INT_MAX < LONG_MAX
+  long l;
+
+  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;
 	}
-	return FALSE;
-# elif INT_MAX == LONG_MAX
-	return xdr_long(xdrs, (long *)ip);
-# elif INT_MAX == SHRT_MAX
-	return xdr_short(xdrs, (short *)ip);
-# else
-#	error unexpected integer sizes in_xdr_int()
-# endif
+      *ip = (int) l;
+    case XDR_FREE:
+      return TRUE;
+    }
+  return FALSE;
+#elif INT_MAX == LONG_MAX
+  return xdr_long (xdrs, (long *) ip);
+#elif INT_MAX == SHRT_MAX
+  return xdr_short (xdrs, (short *) ip);
+#else
+#error unexpected integer sizes in_xdr_int()
+#endif
 #endif
 }
 
@@ -130,38 +130,40 @@ xdr_int(xdrs, ip)
  * XDR unsigned integers
  */
 bool_t
-xdr_u_int(xdrs, up)
-	XDR *xdrs;
-	u_int *up;
+xdr_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));
+  (void) (xdr_short (xdrs, (short *) up));
+  return (xdr_u_long (xdrs, (u_long *) up));
 #else
-# if UINT_MAX < ULONG_MAX
-	u_long l;
-
-	switch (xdrs->x_op) {
-	      case XDR_ENCODE:
-		l = (u_long) *up;
-		return XDR_PUTLONG(xdrs, &l);
-
-	      case XDR_DECODE:
-		if (!XDR_GETLONG(xdrs, &l)) {
-			return FALSE;
-		}
-		*up = (u_int) l;
-	      case XDR_FREE:
-		return TRUE;
+#if UINT_MAX < ULONG_MAX
+  u_long l;
+
+  switch (xdrs->x_op)
+    {
+    case XDR_ENCODE:
+      l = (u_long) * up;
+      return XDR_PUTLONG (xdrs, &l);
+
+    case XDR_DECODE:
+      if (!XDR_GETLONG (xdrs, &l))
+	{
+	  return FALSE;
 	}
-	return FALSE;
-# elif UINT_MAX == ULONG_MAX
-	return xdr_u_long(xdrs, (u_long *)up);
-# elif UINT_MAX == USHRT_MAX
-	return xdr_short(xdrs, (short *)up);
-# else
-#	error unexpected integer sizes in_xdr_u_int()
-# endif
+      *up = (u_int) l;
+    case XDR_FREE:
+      return TRUE;
+    }
+  return FALSE;
+#elif UINT_MAX == ULONG_MAX
+  return xdr_u_long (xdrs, (u_long *) up);
+#elif UINT_MAX == USHRT_MAX
+  return xdr_short (xdrs, (short *) up);
+#else
+#error unexpected integer sizes in_xdr_u_int()
+#endif
 #endif
 }
 
@@ -170,21 +172,21 @@ xdr_u_int(xdrs, up)
  * same as xdr_u_long - open coded to save a proc call!
  */
 bool_t
-xdr_long(xdrs, lp)
-	register XDR *xdrs;
-	long *lp;
+xdr_long (xdrs, lp)
+     XDR *xdrs;
+     long *lp;
 {
 
-	if (xdrs->x_op == XDR_ENCODE)
-		return (XDR_PUTLONG(xdrs, 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_DECODE)
+    return XDR_GETLONG (xdrs, lp);
 
-	if (xdrs->x_op == XDR_FREE)
-		return (TRUE);
+  if (xdrs->x_op == XDR_FREE)
+    return TRUE;
 
-	return (FALSE);
+  return FALSE;
 }
 
 /*
@@ -192,77 +194,82 @@ xdr_long(xdrs, lp)
  * same as xdr_long - open coded to save a proc call!
  */
 bool_t
-xdr_u_long(xdrs, ulp)
-	register XDR *xdrs;
-	u_long *ulp;
+xdr_u_long (xdrs, ulp)
+     XDR *xdrs;
+     u_long *ulp;
 {
-	switch (xdrs->x_op) {
-	      case XDR_DECODE:
-		return XDR_GETLONG(xdrs, (long *)ulp);
-
-	      case XDR_ENCODE:
-		return XDR_PUTLONG(xdrs, (long *)ulp);
-
-	      case XDR_FREE:
-		return TRUE;
-	}
-	return FALSE;
+  switch (xdrs->x_op)
+    {
+    case XDR_DECODE:
+      return XDR_GETLONG (xdrs, (long *) ulp);
+
+    case XDR_ENCODE:
+      return XDR_PUTLONG (xdrs, (long *) ulp);
+
+    case XDR_FREE:
+      return TRUE;
+    }
+  return FALSE;
 }
 
 /*
  * XDR short integers
  */
 bool_t
-xdr_short(xdrs, sp)
-	register XDR *xdrs;
-	short *sp;
+xdr_short (xdrs, sp)
+     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;
+  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;
 	}
-	return FALSE;
+      *sp = (short) l;
+      return TRUE;
+
+    case XDR_FREE:
+      return TRUE;
+    }
+  return FALSE;
 }
 
 /*
  * XDR unsigned short integers
  */
 bool_t
-xdr_u_short(xdrs, usp)
-	register XDR *xdrs;
-	u_short *usp;
+xdr_u_short (xdrs, usp)
+     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;
+  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;
 	}
-	return FALSE;
+      *usp = (u_short) l;
+      return TRUE;
+
+    case XDR_FREE:
+      return TRUE;
+    }
+  return FALSE;
 }
 
 
@@ -270,110 +277,124 @@ xdr_u_short(xdrs, usp)
  * XDR a char
  */
 bool_t
-xdr_char(xdrs, cp)
-	XDR *xdrs;
-	char *cp;
+xdr_char (xdrs, cp)
+     XDR *xdrs;
+     char *cp;
 {
-	int i;
-
-	i = (*cp);
-	if (!xdr_int(xdrs, &i)) {
-		return FALSE;
-	}
-	*cp = i;
-	return TRUE;
+  int i;
+
+  i = (*cp);
+  if (!xdr_int (xdrs, &i))
+    {
+      return FALSE;
+    }
+  *cp = i;
+  return TRUE;
 }
 
 /*
  * XDR an unsigned char
  */
 bool_t
-xdr_u_char(xdrs, cp)
-	XDR *xdrs;
-	u_char *cp;
+xdr_u_char (xdrs, cp)
+     XDR *xdrs;
+     u_char *cp;
 {
-	u_int u;
-
-	u = (*cp);
-	if (!xdr_u_int(xdrs, &u)) {
-		return FALSE;
-	}
-	*cp = u;
-	return TRUE;
+  u_int u;
+
+  u = (*cp);
+  if (!xdr_u_int (xdrs, &u))
+    {
+      return FALSE;
+    }
+  *cp = u;
+  return TRUE;
 }
 
 /*
  * XDR booleans
  */
 bool_t
-xdr_bool(xdrs, bp)
-	register XDR *xdrs;
-	bool_t *bp;
+xdr_bool (xdrs, bp)
+     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;
+  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;
 	}
-	return FALSE;
+      *bp = (lb == XDR_FALSE) ? FALSE : TRUE;
+      return TRUE;
+
+    case XDR_FREE:
+      return TRUE;
+    }
+  return FALSE;
 }
 
 /*
  * XDR enumerations
  */
 bool_t
-xdr_enum(xdrs, ep)
-	XDR *xdrs;
-	enum_t *ep;
+xdr_enum (xdrs, ep)
+     XDR *xdrs;
+     enum_t *ep;
 {
 #ifndef lint
-	enum sizecheck { SIZEVAL };	/* used to find the size of an enum */
-
-	/*
-	 * enums are treated as ints
-	 */
-	if (sizeof (enum sizecheck) == 4) {
-# if INT_MAX < LONG_MAX
-		long l;
-
-		switch (xdrs->x_op) {
-		      case XDR_ENCODE:
-			l = *ep;
-			return XDR_PUTLONG(xdrs, &l);
-
-		      case XDR_DECODE:
-			if (!XDR_GETLONG(xdrs, &l)) {
-				return FALSE;
-			}
-			*ep = l;
-		      case XDR_FREE:
-			return TRUE;
-
-		}
-		return FALSE;
-# else
-		return (xdr_long(xdrs, (long *)ep));
-# endif
-	} else if (sizeof (enum sizecheck) == sizeof (short)) {
-		return xdr_short(xdrs, (short *)ep);
-	} else {
-		return FALSE;
+  enum sizecheck
+    {
+      SIZEVAL
+    };				/* used to find the size of an enum */
+
+  /*
+   * enums are treated as ints
+   */
+  if (sizeof (enum sizecheck) == 4)
+    {
+#if INT_MAX < LONG_MAX
+      long l;
+
+      switch (xdrs->x_op)
+	{
+	case XDR_ENCODE:
+	  l = *ep;
+	  return XDR_PUTLONG (xdrs, &l);
+
+	case XDR_DECODE:
+	  if (!XDR_GETLONG (xdrs, &l))
+	    {
+	      return FALSE;
+	    }
+	  *ep = l;
+	case XDR_FREE:
+	  return TRUE;
+
 	}
+      return FALSE;
+#else
+      return xdr_long (xdrs, (long *) ep);
+#endif
+    }
+  else if (sizeof (enum sizecheck) == sizeof (short))
+    {
+      return xdr_short (xdrs, (short *) ep);
+    }
+  else
+    {
+      return FALSE;
+    }
 #else /* lint */
-	(void) (xdr_short(xdrs, (short *)ep));
-	return (xdr_long(xdrs, (long *)ep));
+  (void) (xdr_short (xdrs, (short *) ep));
+  return xdr_long (xdrs, (long *) ep);
 #endif /* lint */
 }
 
@@ -383,48 +404,51 @@ xdr_enum(xdrs, ep)
  * cp points to the opaque object and cnt gives the byte length.
  */
 bool_t
-xdr_opaque(xdrs, cp, cnt)
-	register XDR *xdrs;
-	caddr_t cp;
-	register u_int cnt;
+xdr_opaque (xdrs, cp, cnt)
+     XDR *xdrs;
+     caddr_t cp;
+     u_int cnt;
 {
-	register u_int rndup;
-	static 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;
-
-	switch (xdrs->x_op) {
-	      case XDR_DECODE:
-		if (!XDR_GETBYTES(xdrs, cp, cnt)) {
-			return FALSE;
-		}
-		if (rndup == 0)
-			return TRUE;
-		return XDR_GETBYTES(xdrs, crud, rndup);
-
-	      case XDR_ENCODE:
-		if (!XDR_PUTBYTES(xdrs, cp, cnt)) {
-			return FALSE;
-		}
-		if (rndup == 0)
-			return TRUE;
-		return XDR_PUTBYTES(xdrs, xdr_zero, rndup);
-
-	      case XDR_FREE:
-		return TRUE;
+  u_int rndup;
+  static char 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;
+
+  switch (xdrs->x_op)
+    {
+    case XDR_DECODE:
+      if (!XDR_GETBYTES (xdrs, cp, cnt))
+	{
+	  return FALSE;
 	}
-	return FALSE;
+      if (rndup == 0)
+	return TRUE;
+      return XDR_GETBYTES (xdrs, (caddr_t)crud, rndup);
+
+    case XDR_ENCODE:
+      if (!XDR_PUTBYTES (xdrs, cp, cnt))
+	{
+	  return FALSE;
+	}
+      if (rndup == 0)
+	return TRUE;
+      return XDR_PUTBYTES (xdrs, xdr_zero, rndup);
+
+    case XDR_FREE:
+      return TRUE;
+    }
+  return FALSE;
 }
 
 /*
@@ -433,66 +457,73 @@ xdr_opaque(xdrs, cp, cnt)
  * If *cpp is NULL maxsize bytes are allocated
  */
 bool_t
-xdr_bytes(xdrs, cpp, sizep, maxsize)
-	register XDR *xdrs;
-	char **cpp;
-	register u_int *sizep;
-	u_int maxsize;
+xdr_bytes (xdrs, cpp, sizep, maxsize)
+     XDR *xdrs;
+     char **cpp;
+     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;
+  char *sp = *cpp;	/* sp is the actual string pointer */
+  u_int nodesize;
+
+  /*
+   * first deal with the length since xdr bytes are counted
+   */
+  if (!xdr_u_int (xdrs, sizep))
+    {
+      return FALSE;
+    }
+  nodesize = *sizep;
+  if ((nodesize > maxsize) && (xdrs->x_op != XDR_FREE))
+    {
+      return FALSE;
+    }
+
+  /*
+   * now deal with the actual bytes
+   */
+  switch (xdrs->x_op)
+    {
+    case XDR_DECODE:
+      if (nodesize == 0)
+	{
+	  return TRUE;
+	}
+      if (sp == NULL)
+	{
+	  *cpp = sp = (char *) mem_alloc (nodesize);
 	}
-	nodesize = *sizep;
-	if ((nodesize > maxsize) && (xdrs->x_op != XDR_FREE)) {
-		return FALSE;
+      if (sp == NULL)
+	{
+	  (void) fprintf (stderr, "xdr_bytes: out of memory\n");
+	  return FALSE;
 	}
+      /* fall into ... */
 
-	/*
-	 * now deal with the actual bytes
-	 */
-	switch (xdrs->x_op) {
-	      case XDR_DECODE:
-		if (nodesize == 0) {
-			return TRUE;
-		}
-		if (sp == NULL) {
-			*cpp = sp = (char *)mem_alloc(nodesize);
-		}
-		if (sp == NULL) {
-			(void) fprintf(stderr, "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;
+    case XDR_ENCODE:
+      return xdr_opaque (xdrs, sp, nodesize);
+
+    case XDR_FREE:
+      if (sp != NULL)
+	{
+	  mem_free (sp, nodesize);
+	  *cpp = NULL;
 	}
-	return FALSE;
+      return TRUE;
+    }
+  return FALSE;
 }
 
 /*
  * Implemented here due to commonality of the object.
  */
 bool_t
-xdr_netobj(xdrs, np)
-	XDR *xdrs;
-	struct netobj *np;
+xdr_netobj (xdrs, np)
+     XDR *xdrs;
+     struct netobj *np;
 {
 
-	return xdr_bytes(xdrs, &np->n_bytes, &np->n_len, MAX_NETOBJ_SZ);
+  return xdr_bytes (xdrs, &np->n_bytes, &np->n_len, MAX_NETOBJ_SZ);
 }
 
 /*
@@ -507,37 +538,39 @@ xdr_netobj(xdrs, np)
  * If there is no specific or default routine an error is returned.
  */
 bool_t
-xdr_union(xdrs, dscmp, unp, choices, dfault)
-	register XDR *xdrs;
-	enum_t *dscmp;		/* enum to decide which arm to work on */
-	char *unp;		/* the union itself */
-	struct xdr_discrim *choices;	/* [value, xdr proc] for each arm */
-	xdrproc_t dfault;	/* default xdr routine */
+xdr_union (xdrs, dscmp, unp, choices, dfault)
+     XDR *xdrs;
+     enum_t *dscmp;		/* enum to decide which arm to work on */
+     char *unp;			/* the union itself */
+     const 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));
+  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));
 }
 
 
@@ -556,64 +589,73 @@ xdr_union(xdrs, dscmp, unp, choices, dfault)
  * of the string as specified by a protocol.
  */
 bool_t
-xdr_string(xdrs, cpp, maxsize)
-	register XDR *xdrs;
-	char **cpp;
-	u_int maxsize;
+xdr_string (xdrs, cpp, maxsize)
+     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) {
-	      case XDR_FREE:
-		if (sp == NULL) {
-			return TRUE;	/* already free */
-		}
-		/* fall through... */
-	      case XDR_ENCODE:
-		if (sp == NULL)
-		  	return FALSE;
-		size = strlen(sp);
-		break;
+  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)
+    {
+    case XDR_FREE:
+      if (sp == NULL)
+	{
+	  return TRUE;		/* already free */
 	}
-	if (! xdr_u_int(xdrs, &size)) {
-		return FALSE;
-	}
-	if (size > maxsize) {
-		return FALSE;
+      /* fall through... */
+    case XDR_ENCODE:
+      if (sp == NULL)
+	return FALSE;
+      size = strlen (sp);
+      break;
+    case XDR_DECODE:
+      break;
+    }
+  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 (nodesize == 0)
+	{
+	  return TRUE;
 	}
-	nodesize = size + 1;
-
-	/*
-	 * now deal with the actual bytes
-	 */
-	switch (xdrs->x_op) {
-	      case XDR_DECODE:
-		if (nodesize == 0) {
-			return TRUE;
-		}
-		if (sp == NULL)
-			*cpp = sp = (char *)mem_alloc(nodesize);
-		if (sp == NULL) {
-			(void) fprintf(stderr, "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);
-		*cpp = NULL;
-		return TRUE;
+      if (sp == NULL)
+	*cpp = sp = (char *) mem_alloc (nodesize);
+      if (sp == NULL)
+	{
+	  (void) fprintf (stderr, "xdr_string: out of memory\n");
+	  return FALSE;
 	}
-	return FALSE;
+      sp[size] = 0;
+      /* fall into ... */
+
+    case XDR_ENCODE:
+      return xdr_opaque (xdrs, sp, size);
+
+    case XDR_FREE:
+      mem_free (sp, nodesize);
+      *cpp = NULL;
+      return TRUE;
+    }
+  return FALSE;
 }
 
 /*
@@ -621,12 +663,13 @@ xdr_string(xdrs, cpp, maxsize)
  * routines like clnt_call
  */
 bool_t
-xdr_wrapstring(xdrs, cpp)
-	XDR *xdrs;
-	char **cpp;
+xdr_wrapstring (xdrs, cpp)
+     XDR *xdrs;
+     char **cpp;
 {
-	if (xdr_string(xdrs, cpp, LASTUNSIGNED)) {
-		return TRUE;
-	}
-	return FALSE;
+  if (xdr_string (xdrs, cpp, LASTUNSIGNED))
+    {
+      return TRUE;
+    }
+  return FALSE;
 }