Add eXtensible Data Record (XDR) support

	* configure.host: Build libc/xdr only on cygwin.
	* Makefile.am: Install xdr headers.
	* libc/configure.in: Support new libc/xdr subdirectory.
	* libc/Makefile.am: Support new libc/xdr subdirectory.
	* libc/include/rpc/types.h: New.
	* libc/include/rpc/xdr.h: New.
	* libc/xdr/README: New.
	* libc/xdr/Makefile.am: New.
	* libc/xdr/dummy.c: New.
	* libc/xdr/xdr.c: New.
	* libc/xdr/xdr_array.c: New.
	* libc/xdr/xdr_float.c: New.
	* libc/xdr/xdr_float_vax.c: New.
	* libc/xdr/xdr_mem.c: New.
	* libc/xdr/xdr_private.c: New.
	* libc/xdr/xdr_private.h: New.
	* libc/xdr/xdr_rec.c: New.
	* libc/xdr/xdr_reference.c: New.
	* libc/xdr/xdr_sizeof.c: New.
	* libc/xdr/xdr_stdio.c: New.

	Regenerate using ac-2.63 and am-1.11.1
	* libc/xdr/Makefile.in: New.
	* Makefile.in: Regenerate.
	* libc/configure: Regenerate.
	* libc/Makefile.in: Regenerate.
	* libc/argz/Makefile.in: Regenerate.
	* libc/ctype/Makefile.in: Regenerate.
	* libc/errno/Makefile.in: Regenerate.
	* libc/iconv/ccs/binary/Makefile.in: Regenerate.
	* libc/iconv/ccs/Makefile.in: Regenerate.
	* libc/iconv/ces/Makefile.in: Regenerate.
	* libc/iconv/lib/Makefile.in: Regenerate.
	* libc/iconv/Makefile.in: Regenerate.
	* libc/locale/Makefile.in: Regenerate.
	* libc/misc/Makefile.in: Regenerate.
	* libc/posix/Makefile.in: Regenerate.
	* libc/reent/Makefile.in: Regenerate.
	* libc/search/Makefile.in: Regenerate.
	* libc/signal/Makefile.in: Regenerate.
	* libc/stdio/Makefile.in: Regenerate.
	* libc/stdio64/Makefile.in: Regenerate.
	* libc/stdlib/Makefile.in: Regenerate.
	* libc/string/Makefile.in: Regenerate.
	* libc/syscalls/Makefile.in: Regenerate.
	* libc/time/Makefile.in: Regenerate.
	* libc/unix/Makefile.in: Regenerate.

1 files changed, 926 insertions, 0 deletions

diff --git a/newlib/libc/xdr/xdr_rec.c b/newlib/libc/xdr/xdr_rec.c
new file mode 100644
index 000000000..f2fafadb1
--- /dev/null
+++ b/newlib/libc/xdr/xdr_rec.c
@@ -0,0 +1,926 @@
+
+/*
+ * Copyright (c) 2009, Sun Microsystems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - 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.
+ * - Neither the name of Sun Microsystems, Inc. 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 COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER 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_rec.c, Implements TCP/IP based XDR streams with a "record marking"
+ * layer above tcp (for rpc's use).
+ *
+ * Copyright (C) 1984, Sun Microsystems, Inc.
+ *
+ * These routines interface XDRSTREAMS to a tcp/ip connection.
+ * There is a record marking layer between the xdr stream
+ * and the tcp transport level.  A record is composed on one or more
+ * record fragments.  A record fragment is a thirty-two bit header followed
+ * by n bytes of data, where n is contained in the header.  The header
+ * is represented as a htonl(u_long).  Thegh order bit encodes
+ * whether or not the fragment is the last fragment of the record
+ * (1 => fragment is last, 0 => more fragments to follow.
+ * The other 31 bits encode the byte length of the fragment.
+ */
+
+#include <stddef.h>
+#include <sys/types.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include <rpc/types.h>
+#include <rpc/xdr.h>
+
+#include "xdr_private.h"
+
+#ifndef ntohl
+# define ntohl(x) xdr_ntohl(x)
+#endif
+#ifndef htonl
+# define htonl(x) xdr_htonl(x)
+#endif
+
+enum xprt_stat
+{
+  XPRT_DIED,
+  XPRT_MOREREQS,
+  XPRT_IDLE
+};
+
+static bool_t _EXFUN (xdrrec_getlong, (XDR *, long *));
+static bool_t _EXFUN (xdrrec_putlong, (XDR *, _CONST long *));
+static bool_t _EXFUN (xdrrec_getbytes, (XDR *, char *, u_int));
+static bool_t _EXFUN (xdrrec_putbytes, (XDR *, _CONST char *, u_int));
+static u_int _EXFUN (xdrrec_getpos, (XDR *));
+static bool_t _EXFUN (xdrrec_setpos, (XDR *, u_int));
+static int32_t * _EXFUN (xdrrec_inline, (XDR *, u_int));
+static void _EXFUN (xdrrec_destroy, (XDR *));
+static bool_t _EXFUN (xdrrec_getint32, (XDR *, int32_t *));
+static bool_t _EXFUN (xdrrec_putint32, (XDR *, _CONST int32_t *));
+
+static _CONST struct xdr_ops xdrrec_ops = {
+  xdrrec_getlong,
+  xdrrec_putlong,
+  xdrrec_getbytes,
+  xdrrec_putbytes,
+  xdrrec_getpos,
+  xdrrec_setpos,
+  xdrrec_inline,
+  xdrrec_destroy,
+  xdrrec_getint32,
+  xdrrec_putint32
+};
+
+/*
+ * A record is composed of one or more record fragments.
+ * A record fragment is a four-byte header followed by zero to
+ * 2**32-1 bytes.  The header is treated as a long unsigned and is
+ * encode/decoded to the network via htonl/ntohl.  The low order 31 bits
+ * are a byte count of the fragment.  The highest order bit is a boolean:
+ * 1 => this fragment is the last fragment of the record,
+ * 0 => this fragment is followed by more fragment(s).
+ *
+ * The fragment/record machinery is not general;  it is constructed to
+ * meet the needs of xdr and rpc based on tcp.
+ */
+
+#define LAST_FRAG ((u_int32_t)(UINT32_C(1) << 31))
+
+typedef struct rec_strm
+{
+  caddr_t tcp_handle;
+  /*
+   * out-goung bits
+   */
+  caddr_t out_buffer;           /* buffer as allocated; may not be aligned */
+  int (*writeit) (void *, void *, 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_int32_t *frag_header;       /* beginning of curren fragment */
+  bool_t frag_sent;             /* true if buffer sent in middle of record */
+  /*
+   * in-coming bits
+   */
+  caddr_t in_buffer;            /* buffer as allocated; may not be aligned */
+  int (*readit) (void *, void *, 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 */
+  caddr_t in_boundry;           /* can read up to this location */
+  long fbtbc;                   /* fragment bytes to be consumed */
+  bool_t last_frag;
+  u_int sendsize;               /* must be <= INT_MAX */
+  u_int recvsize;               /* must be <= INT_MAX */
+
+  bool_t nonblock;
+  bool_t in_haveheader;
+  u_int32_t in_header;
+  char *in_hdrp;
+  int in_hdrlen;
+  int in_reclen;
+  int in_received;
+  int in_maxrec;
+} RECSTREAM;
+
+static u_int fix_buf_size (u_int);
+static bool_t flush_out (RECSTREAM *, bool_t);
+static bool_t fill_input_buf (RECSTREAM *);
+static bool_t get_input_bytes (RECSTREAM *, char *, size_t);
+static bool_t set_input_fragment (RECSTREAM *);
+static bool_t skip_input_bytes (RECSTREAM *, long);
+static bool_t realloc_stream (RECSTREAM *, int);
+
+bool_t _EXFUN (__xdrrec_getrec, (XDR *, enum xprt_stat *, bool_t));
+bool_t _EXFUN (__xdrrec_setnonblock, (XDR *, int));
+
+/*
+ * Create an xdr handle for xdrrec
+ * xdrrec_create fills in xdrs.  Sendsize and recvsize are
+ * send and recv buffer sizes (0 => use default), and must be <= INT_MAX.
+ * tcp_handle is an opaque handle that is passed as the first parameter to
+ * the procedures readit and writeit.  Readit and writeit are read and
+ * write respectively.   They are like the system
+ * calls except that they take an opaque handle rather than an fd.
+ */
+void
+_DEFUN (xdrrec_create, (xdrs, sendsize, recvsize, tcp_handle, readit, writeit),
+        XDR * xdrs _AND
+	u_int sendsize _AND
+	u_int recvsize _AND
+	void *tcp_handle _AND
+        int _EXPARM (readit, (void *, void *, int)) _AND
+        int _EXPARM (writeit, (void *, void *, int)))
+{
+  RECSTREAM *rstrm;
+  /* Although sendsize and recvsize are u_int, we require
+   * that they be less than INT_MAX, because often we need
+   * to compare against values held in (signed) integers.
+   * Please don't try to use send/recv buffers > 2GB...
+   */
+  assert (sendsize < (u_int)INT_MAX);
+  assert (recvsize < (u_int)INT_MAX);
+
+  rstrm = (RECSTREAM *) mem_alloc (sizeof (RECSTREAM));
+  if (rstrm == NULL)
+    {
+      xdr_warnx ("xdrrec_create: out of memory");
+      /*
+       *  This is bad.  Should rework xdrrec_create to
+       *  return a handle, and in this case return NULL
+       */
+      errno = ENOMEM;
+      return;
+    }
+
+
+  /* allocate send buffer; insure BYTES_PER_UNIT alignment */
+  rstrm->sendsize = sendsize = fix_buf_size (sendsize);
+  rstrm->out_buffer = mem_alloc (rstrm->sendsize + BYTES_PER_XDR_UNIT);
+  if (rstrm->out_buffer == NULL)
+    {
+      xdr_warnx ("xdrrec_create: out of memory");
+      mem_free (rstrm, sizeof (RECSTREAM));
+      errno = ENOMEM;
+      return;
+    }
+  for (rstrm->out_base = rstrm->out_buffer;
+       (long) rstrm->out_base % BYTES_PER_XDR_UNIT != 0; rstrm->out_base++)
+    ;
+
+  /* allocate recv buffer; insure BYTES_PER_UNIT alignment */
+  rstrm->recvsize = recvsize = fix_buf_size (recvsize);
+  rstrm->in_buffer = mem_alloc (recvsize + BYTES_PER_XDR_UNIT);
+  if (rstrm->in_buffer == NULL)
+    {
+      xdr_warnx ("xdrrec_create: out of memory");
+      mem_free (rstrm->out_buffer, sendsize + BYTES_PER_XDR_UNIT);
+      mem_free (rstrm, sizeof (RECSTREAM));
+      errno = ENOMEM;
+      return;
+    }
+  for (rstrm->in_base = rstrm->in_buffer;
+       (long) rstrm->in_base % BYTES_PER_XDR_UNIT != 0; rstrm->in_base++)
+    ;
+
+  /*
+   * now the rest ...
+   */
+  xdrs->x_ops = &xdrrec_ops;
+  xdrs->x_private = rstrm;
+  rstrm->tcp_handle = tcp_handle;
+  rstrm->readit = readit;
+  rstrm->writeit = writeit;
+  rstrm->out_finger = rstrm->out_boundry = rstrm->out_base;
+  rstrm->frag_header = (u_int32_t *) (void *) rstrm->out_base;
+  rstrm->out_finger += sizeof (u_int32_t);
+  rstrm->out_boundry += sendsize;
+  rstrm->frag_sent = FALSE;
+  rstrm->in_size = recvsize;
+  rstrm->in_boundry = rstrm->in_base;
+  rstrm->in_finger = (rstrm->in_boundry += recvsize);
+  rstrm->fbtbc = 0;
+  rstrm->last_frag = TRUE;
+  rstrm->in_haveheader = FALSE;
+  rstrm->in_hdrlen = 0;
+  rstrm->in_hdrp = (char *) (void *) &rstrm->in_header;
+  rstrm->nonblock = FALSE;
+  rstrm->in_reclen = 0;
+  rstrm->in_received = 0;
+}
+
+
+/*
+ * The reoutines defined below are the xdr ops which will go into the
+ * xdr handle filled in by xdrrec_create.
+ */
+
+static bool_t
+_DEFUN (xdrrec_getlong, (xdrs, lp),
+        XDR * xdrs _AND
+	long *lp)
+{
+  RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+  int32_t *buflp = (int32_t *) (void *) (rstrm->in_finger);
+  int32_t mylong;
+
+  /* first try the inline, fast case */
+  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, (char *) (void *) &mylong,
+                            sizeof (int32_t)))
+        return FALSE;
+      *lp = (long) ntohl ((u_int32_t) mylong);
+    }
+  return TRUE;
+}
+
+static bool_t
+_DEFUN (xdrrec_putlong, (xdrs, lp),
+        XDR * xdrs _AND
+	_CONST long *lp)
+{
+  RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+  int32_t *dest_lp = ((int32_t *) (void *) (rstrm->out_finger));
+
+  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 (int32_t);
+      rstrm->frag_sent = TRUE;
+      if (!flush_out (rstrm, FALSE))
+        return FALSE;
+      dest_lp = ((int32_t *) (void *) (rstrm->out_finger));
+      rstrm->out_finger += sizeof (int32_t);
+    }
+  *dest_lp = (int32_t) htonl ((u_int32_t) (*lp));
+  return TRUE;
+}
+
+static bool_t                   /* must manage buffers, fragments, and records */
+_DEFUN (xdrrec_getbytes, (xdrs, addr, len),
+        XDR * xdrs _AND
+	char *addr _AND
+	u_int len)
+{
+  RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+  size_t current;
+
+  while (len > 0)
+    {
+      current = (int) rstrm->fbtbc;
+      if (current == 0)
+        {
+          if (rstrm->last_frag)
+            return FALSE;
+          if (!set_input_fragment (rstrm))
+            return FALSE;
+          continue;
+        }
+      current = (len < current) ? len : current;
+      if (!get_input_bytes (rstrm, addr, current))
+        return FALSE;
+      addr += current;
+      rstrm->fbtbc -= current;
+      len -= current;
+    }
+  return TRUE;
+}
+
+static bool_t
+_DEFUN (xdrrec_putbytes, (xdrs, addr, len),
+        XDR * xdrs _AND
+        _CONST char *addr _AND
+	u_int len)
+{
+  RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+  size_t current;
+
+  while (len > 0)
+    {
+      current = (size_t) ((u_long) rstrm->out_boundry -
+                          (u_long) rstrm->out_finger);
+      current = (len < current) ? len : current;
+      memmove (rstrm->out_finger, addr, current);
+      rstrm->out_finger += current;
+      addr += current;
+      len -= current;
+      if (rstrm->out_finger == rstrm->out_boundry)
+        {
+          rstrm->frag_sent = TRUE;
+          if (!flush_out (rstrm, FALSE))
+            return FALSE;
+        }
+    }
+  return TRUE;
+}
+
+static u_int
+_DEFUN (xdrrec_getpos, (xdrs),
+        XDR * xdrs)
+{
+  RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
+  off_t pos;
+
+  pos = lseek ((int) (u_long) rstrm->tcp_handle, (off_t) 0, 1);
+  if (pos != -1)
+    switch (xdrs->x_op)
+      {
+
+      case XDR_ENCODE:
+        pos += rstrm->out_finger - rstrm->out_base;
+        break;
+
+      case XDR_DECODE:
+        pos -= rstrm->in_boundry - rstrm->in_finger;
+        break;
+
+      default:
+        pos = (off_t) - 1;
+        break;
+      }
+  return ((u_int) pos);
+}
+
+static bool_t
+_DEFUN (xdrrec_setpos, (xdrs, pos),
+        XDR * xdrs _AND
+	u_int pos)
+{
+  RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
+  u_int currpos = xdrrec_getpos (xdrs);
+  int delta = currpos - pos;
+  char *newpos;
+
+  if ((int) currpos != -1)
+    switch (xdrs->x_op)
+      {
+
+      case XDR_ENCODE:
+        newpos = rstrm->out_finger - delta;
+        if ((newpos > (char *) (void *) (rstrm->frag_header)) &&
+            (newpos < rstrm->out_boundry))
+          {
+            rstrm->out_finger = newpos;
+            return TRUE;
+          }
+        break;
+
+      case XDR_DECODE:
+        newpos = rstrm->in_finger - delta;
+        if ((delta < (int) (rstrm->fbtbc)) &&
+            (newpos <= rstrm->in_boundry) && (newpos >= rstrm->in_base))
+          {
+            rstrm->in_finger = newpos;
+            rstrm->fbtbc -= delta;
+            return TRUE;
+          }
+        break;
+
+      case XDR_FREE:
+        break;
+      }
+  return FALSE;
+}
+
+static int32_t *
+_DEFUN (xdrrec_inline, (xdrs, len),
+        XDR * xdrs _AND
+	u_int len)
+{
+  RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
+  int32_t *buf = NULL;
+  /* len represents the number of bytes to extract
+   * from the buffer. The number of bytes remaining
+   * in the buffer is rstrm->fbtbc, which is a long.
+   * Thus, the buffer size maximum is 2GB (!), and
+   * we require that no one ever try to read more
+   * than than number of bytes at once.
+   */
+  assert (len < (u_int)LONG_MAX);
+
+  switch (xdrs->x_op)
+    {
+
+    case XDR_ENCODE:
+      if ((rstrm->out_finger + len) <= rstrm->out_boundry)
+        {
+          buf = (int32_t *) (void *) rstrm->out_finger;
+          rstrm->out_finger += len;
+        }
+      break;
+
+    case XDR_DECODE:
+      if (((long)len <= rstrm->fbtbc) &&
+          ((rstrm->in_finger + len) <= rstrm->in_boundry))
+        {
+          buf = (int32_t *) (void *) rstrm->in_finger;
+          rstrm->fbtbc -= len;
+          rstrm->in_finger += len;
+        }
+      break;
+
+    case XDR_FREE:
+      break;
+    }
+  return (buf);
+}
+
+static void
+_DEFUN (xdrrec_destroy, (xdrs),
+        XDR * xdrs)
+{
+  RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
+
+  mem_free (rstrm->out_buffer, rstrm->sendsize + BYTES_PER_XDR_UNIT);
+  mem_free (rstrm->in_buffer, rstrm->recvsize + BYTES_PER_XDR_UNIT);
+  mem_free (rstrm, sizeof (RECSTREAM));
+}
+
+static bool_t
+_DEFUN (xdrrec_getint32, (xdrs, ip),
+        XDR *xdrs _AND
+	int32_t *ip)
+{
+  RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+  int32_t *bufip = (int32_t *) (void *) (rstrm->in_finger);
+  int32_t mylong;
+
+  /* first try the inline, fast case */
+  if ((rstrm->fbtbc >= sizeof (int32_t)) &&
+      (( rstrm->in_boundry - (char *) bufip) >= sizeof (int32_t)))
+    {
+      *ip = (int32_t) ntohl (*bufip);
+      rstrm->fbtbc -= sizeof (int32_t);
+      rstrm->in_finger += sizeof (int32_t);
+    }
+  else
+    {
+      if (!xdrrec_getbytes (xdrs, (char *) (void *) &mylong,
+                            sizeof (int32_t)))
+        return FALSE;
+      *ip = (int32_t) ntohl (mylong);
+    }
+  return TRUE;
+}
+
+static bool_t
+_DEFUN (xdrrec_putint32, (xdrs, ip),
+        XDR *xdrs _AND
+	_CONST int32_t *ip)
+{
+  RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+  int32_t *dest_ip = ((int32_t *) (void *) (rstrm->out_finger));
+
+  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 (int32_t);
+      rstrm->frag_sent = TRUE;
+      if (!flush_out (rstrm, FALSE))
+        return FALSE;
+      dest_ip = ((int32_t *) (void *) (rstrm->out_finger));
+      rstrm->out_finger += sizeof (int32_t);
+    }
+  *dest_ip = (int32_t) htonl (*ip);
+  return TRUE;
+}
+
+/*
+ * Exported routines to manage xdr records
+ */
+
+/*
+ * Before reading (deserializing from the stream, one should always call
+ * this procedure to guarantee proper record alignment.
+ */
+bool_t
+_DEFUN (xdrrec_skiprecord, (xdrs),
+        XDR * xdrs)
+{
+  RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+  enum xprt_stat xstat;
+
+  if (rstrm->nonblock)
+    {
+      if (__xdrrec_getrec (xdrs, &xstat, FALSE))
+        {
+          rstrm->fbtbc = 0;
+          return TRUE;
+        }
+      if (rstrm->in_finger == rstrm->in_boundry && xstat == XPRT_MOREREQS)
+        {
+          rstrm->fbtbc = 0;
+          return TRUE;
+        }
+      return FALSE;
+    }
+
+  while (rstrm->fbtbc > 0 || (!rstrm->last_frag))
+    {
+      if (!skip_input_bytes (rstrm, rstrm->fbtbc))
+        return FALSE;
+      rstrm->fbtbc = 0;
+      if ((!rstrm->last_frag) && (!set_input_fragment (rstrm)))
+        return FALSE;
+    }
+  rstrm->last_frag = FALSE;
+  return TRUE;
+}
+
+/*
+ * Look ahead function.
+ * Returns TRUE iff there is no more input in the buffer
+ * after consuming the rest of the current record.
+ */
+bool_t
+_DEFUN (xdrrec_eof, (xdrs),
+        XDR * xdrs)
+{
+  RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+
+  while (rstrm->fbtbc > 0 || (!rstrm->last_frag))
+    {
+      if (!skip_input_bytes (rstrm, rstrm->fbtbc))
+        return TRUE;
+      rstrm->fbtbc = 0;
+      if ((!rstrm->last_frag) && (!set_input_fragment (rstrm)))
+        return TRUE;
+    }
+  if (rstrm->in_finger == rstrm->in_boundry)
+    return TRUE;
+  return FALSE;
+}
+
+/*
+ * The client must tell the package when an end-of-record has occurred.
+ * The second paraemters tells whether the record should be flushed to the
+ * (output) tcp stream.  (This let's the package support batched or
+ * pipelined procedure calls.)  TRUE => immmediate flush to tcp connection.
+ */
+bool_t
+_DEFUN (xdrrec_endofrecord, (xdrs, sendnow),
+        XDR * xdrs _AND
+	bool_t sendnow)
+{
+  RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+  u_long len;                   /* fragment length */
+
+  if (sendnow || rstrm->frag_sent ||
+      ((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_int32_t);
+  *(rstrm->frag_header) = htonl ((u_int32_t) len | LAST_FRAG);
+  rstrm->frag_header = (u_int32_t *) (void *) rstrm->out_finger;
+  rstrm->out_finger += sizeof (u_int32_t);
+  return TRUE;
+}
+
+/*
+ * Fill the stream buffer with a record for a non-blocking connection.
+ * Return true if a record is available in the buffer, false if not.
+ */
+bool_t
+_DEFUN (__xdrrec_getrec, (xdrs, statp, expectdata),
+        XDR * xdrs _AND
+	enum xprt_stat * statp _AND
+	bool_t expectdata)
+{
+  RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+  ssize_t n;
+  int fraglen;
+
+  if (!rstrm->in_haveheader)
+    {
+      n = rstrm->readit (rstrm->tcp_handle, rstrm->in_hdrp,
+                         (int) sizeof (rstrm->in_header) - rstrm->in_hdrlen);
+      if (n == 0)
+        {
+          *statp = expectdata ? XPRT_DIED : XPRT_IDLE;
+          return FALSE;
+        }
+      if (n < 0)
+        {
+          *statp = XPRT_DIED;
+          return FALSE;
+        }
+      rstrm->in_hdrp += n;
+      rstrm->in_hdrlen += n;
+      if (rstrm->in_hdrlen < sizeof (rstrm->in_header))
+        {
+          *statp = XPRT_MOREREQS;
+          return FALSE;
+        }
+      rstrm->in_header = ntohl (rstrm->in_header);
+      fraglen = (int) (rstrm->in_header & ~LAST_FRAG);
+      if (fraglen == 0 || fraglen > rstrm->in_maxrec ||
+          (rstrm->in_reclen + fraglen) > rstrm->in_maxrec)
+        {
+          *statp = XPRT_DIED;
+          return FALSE;
+        }
+      rstrm->in_reclen += fraglen;
+      if (rstrm->in_reclen > (int)rstrm->recvsize) /* guaranteed recvsize < INT_MAX */
+        realloc_stream (rstrm, rstrm->in_reclen);
+      if (rstrm->in_header & LAST_FRAG)
+        {
+          rstrm->in_header &= ~LAST_FRAG;
+          rstrm->last_frag = TRUE;
+        }
+      /*
+       * We can only reasonably expect to read once from a
+       * non-blocking stream. Reading the fragment header
+       * may have drained the stream.
+       */
+      expectdata = FALSE;
+    }
+
+  n = rstrm->readit (rstrm->tcp_handle,
+                     rstrm->in_base + rstrm->in_received,
+                     (rstrm->in_reclen - rstrm->in_received));
+
+  if (n < 0)
+    {
+      *statp = XPRT_DIED;
+      return FALSE;
+    }
+
+  if (n == 0)
+    {
+      *statp = expectdata ? XPRT_DIED : XPRT_IDLE;
+      return FALSE;
+    }
+
+  rstrm->in_received += n;
+
+  if (rstrm->in_received == rstrm->in_reclen)
+    {
+      rstrm->in_haveheader = FALSE;
+      rstrm->in_hdrp = (char *) (void *) &rstrm->in_header;
+      rstrm->in_hdrlen = 0;
+      if (rstrm->last_frag)
+        {
+          rstrm->fbtbc = rstrm->in_reclen;
+          rstrm->in_boundry = rstrm->in_base + rstrm->in_reclen;
+          rstrm->in_finger = rstrm->in_base;
+          rstrm->in_reclen = rstrm->in_received = 0;
+          *statp = XPRT_MOREREQS;
+          return TRUE;
+        }
+    }
+
+  *statp = XPRT_MOREREQS;
+  return FALSE;
+}
+
+bool_t
+_DEFUN (__xdrrec_setnonblock, (xdrs, maxrec),
+        XDR * xdrs _AND
+	int maxrec)
+{
+  RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+
+  rstrm->nonblock = TRUE;
+  if (maxrec == 0)
+    maxrec = rstrm->recvsize;
+  rstrm->in_maxrec = maxrec;
+  return TRUE;
+}
+
+/*
+ * Internal useful routines
+ */
+static bool_t
+_DEFUN (flush_out, (rstrm, eor),
+        RECSTREAM * rstrm _AND
+	bool_t eor)
+{
+  u_int32_t eormask = (eor == TRUE) ? LAST_FRAG : 0;
+  u_int32_t len = (u_int32_t) ((u_long) (rstrm->out_finger) -
+                               (u_long) (rstrm->frag_header) -
+                               sizeof (u_int32_t));
+
+  *(rstrm->frag_header) = htonl (len | eormask);
+  len = (u_int32_t) ((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_int32_t *) (void *) rstrm->out_base;
+  rstrm->out_finger = (char *) rstrm->out_base + sizeof (u_int32_t);
+  return TRUE;
+}
+
+static bool_t                   /* knows nothing about records!  Only about input buffers */
+_DEFUN (fill_input_buf, (rstrm),
+        RECSTREAM * rstrm)
+{
+  char *where;
+  u_int32_t i;
+  int len;
+
+  if (rstrm->nonblock)
+    return FALSE;
+
+  where = rstrm->in_base;
+  i = (u_int32_t) ((u_long) rstrm->in_boundry % BYTES_PER_XDR_UNIT);
+  where += i;
+  len = (u_int32_t) (rstrm->in_size - i);
+  if ((len = (*(rstrm->readit)) (rstrm->tcp_handle, where, len)) == -1)
+    return FALSE;
+  rstrm->in_finger = where;
+  where += len;
+  rstrm->in_boundry = where;
+  return TRUE;
+}
+
+static bool_t                   /* knows nothing about records!  Only about input buffers */
+_DEFUN (get_input_bytes, (rstrm, addr, len),
+        RECSTREAM * rstrm _AND
+	char *addr _AND
+	size_t len)
+{
+  size_t current;
+
+  if (rstrm->nonblock)
+    {
+      if ((rstrm->in_boundry < rstrm->in_finger) ||               /* <-- should never happen, but avoids... */
+         (len > (size_t) (rstrm->in_boundry - rstrm->in_finger))) /* <-- signed/unsigned comparison */
+        return FALSE;
+      memcpy (addr, rstrm->in_finger, (size_t) len);
+      rstrm->in_finger += len;
+      return TRUE;
+    }
+
+  while (len > 0)
+    {
+      current = (size_t) ((long) rstrm->in_boundry - (long) rstrm->in_finger);
+      if (current == 0)
+        {
+          if (!fill_input_buf (rstrm))
+            return FALSE;
+          continue;
+        }
+      current = (len < current) ? len : current;
+      memmove (addr, rstrm->in_finger, current);
+      rstrm->in_finger += current;
+      addr += current;
+      len -= current;
+    }
+  return TRUE;
+}
+
+static bool_t                   /* next two bytes of the input stream are treated as a header */
+_DEFUN (set_input_fragment, (rstrm),
+        RECSTREAM * rstrm)
+{
+  u_int32_t header;
+
+  if (rstrm->nonblock)
+    return FALSE;
+  if (!get_input_bytes (rstrm, (char *) (void *) &header, sizeof (header)))
+    return FALSE;
+  header = ntohl (header);
+  rstrm->last_frag = ((header & LAST_FRAG) == 0) ? FALSE : TRUE;
+  /*
+   * Sanity check. Try not to accept wildly incorrect
+   * record sizes. Unfortunately, the only record size
+   * we can positively identify as being 'wildly incorrect'
+   * is zero. Ridiculously large record sizes may look wrong,
+   * but we don't have any way to be certain that they aren't
+   * what the client actually intended to send us.
+   */
+  if (header == 0)
+    return FALSE;
+  rstrm->fbtbc = header & (~LAST_FRAG);
+  return TRUE;
+}
+
+static bool_t                   /* consumes input bytes; knows nothing about records! */
+_DEFUN (skip_input_bytes, (rstrm, cnt),
+        RECSTREAM * rstrm _AND
+	long cnt)
+{
+  size_t current;
+
+  while (cnt > 0)
+    {
+      current = (size_t) ((long) rstrm->in_boundry - (long) rstrm->in_finger);
+      if (current == 0)
+        {
+          if (!fill_input_buf (rstrm))
+            return FALSE;
+          continue;
+        }
+      /* in this loop (prior to last line), cnt > 0 so size_t cast is safe*/
+      current = (size_t) (((size_t)cnt < current) ? (size_t)cnt : current);
+      rstrm->in_finger += current;
+      cnt -= current;
+    }
+  return TRUE;
+}
+
+static u_int
+_DEFUN (fix_buf_size, (s),
+        u_int s)
+{
+
+  if (s < 100)
+    s = 4000;
+  return (RNDUP (s));
+}
+
+/*
+ * Reallocate the input buffer for a non-block stream.
+ */
+static bool_t
+_DEFUN (realloc_stream, (rstrm, size),
+        RECSTREAM * rstrm _AND
+	int size)
+{
+  ptrdiff_t diff;
+  char *buf;
+  char *buf_algn;
+
+  if (size > (int)rstrm->recvsize) /* recvsize guaranteed < INT_MAX */
+    {
+      buf = realloc (rstrm->in_buffer, (size_t) (size + BYTES_PER_XDR_UNIT));
+      if (buf == NULL)
+        return FALSE;
+      for (buf_algn = buf;
+           (long) buf_algn % BYTES_PER_XDR_UNIT != 0; buf_algn++)
+        ;
+      diff = buf_algn - rstrm->in_base;
+      rstrm->in_finger += diff;
+      rstrm->in_base = buf_algn;
+      rstrm->in_buffer = buf;
+      rstrm->in_boundry = buf_algn + size;
+      rstrm->recvsize = size;
+      rstrm->in_size = size;
+    }
+
+  return TRUE;
+}
+