
/*
 * 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.
 */

#define _DEFAULT_SOURCE
#include <stddef.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>
#include <errno.h>
#include <limits.h>

#include <rpc/types.h>
#include <rpc/xdr.h>

#include "xdr_private.h"

#ifdef __GNUCLIKE_PRAGMA_DIAGNOSTIC
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic ignored "-Wunknown-warning-option"
#pragma GCC diagnostic ignored "-Wanalyzer-malloc-leak"
#endif

#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               xdrrec_getlong(XDR *, long *);
static bool_t               xdrrec_putlong(XDR *, const long *);
static bool_t               xdrrec_getbytes(XDR *, char *, u_int);
static bool_t               xdrrec_putbytes(XDR *, const char *, u_int);
static u_int                xdrrec_getpos(XDR *);
static bool_t               xdrrec_setpos(XDR *, u_int);
static int32_t             *xdrrec_inline(XDR *, u_int);
static void                 xdrrec_destroy(XDR *);
static bool_t               xdrrec_getint32(XDR *, int32_t *);
static bool_t               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        __xdrrec_getrec(XDR *, enum xprt_stat *, bool_t);
bool_t        __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
xdrrec_create(XDR *xdrs, u_int sendsize, u_int recvsize, void *tcp_handle,
              int (*readit)(void *, void *, int), int (*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; (intptr_t)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; (intptr_t)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
xdrrec_getlong(XDR *xdrs, 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 >= (long)sizeof(int32_t))
        && (((intptr_t)rstrm->in_boundry - (intptr_t)buflp) >= (long)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
xdrrec_putlong(XDR *xdrs, 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 */
xdrrec_getbytes(XDR *xdrs, char *addr, 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
xdrrec_putbytes(XDR *xdrs, const char *addr, u_int len)
{
    RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
    size_t     current;

    while (len > 0) {
        current = (size_t)((uintptr_t)rstrm->out_boundry - (uintptr_t)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
xdrrec_getpos(XDR *xdrs)
{
    RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
    off_t      pos;

    pos = lseek((int)(uintptr_t)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
xdrrec_setpos(XDR *xdrs, 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 *
xdrrec_inline(XDR *xdrs, 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
xdrrec_destroy(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
xdrrec_getint32(XDR *xdrs, 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 >= (long)sizeof(int32_t))
        && ((rstrm->in_boundry - (char *)bufip) >= (ssize_t)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
xdrrec_putint32(XDR *xdrs, 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
xdrrec_skiprecord(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
xdrrec_eof(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
xdrrec_endofrecord(XDR *xdrs, bool_t sendnow)
{
    RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
    u_long     len; /* fragment length */

    if (sendnow || rstrm->frag_sent
        || ((uintptr_t)rstrm->out_finger + sizeof(u_int32_t) >= (uintptr_t)rstrm->out_boundry)) {
        rstrm->frag_sent = FALSE;
        return (flush_out(rstrm, TRUE));
    }
    len = (uintptr_t)(rstrm->out_finger) - (uintptr_t)(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
__xdrrec_getrec(XDR *xdrs, enum xprt_stat *statp, 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 < (int)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 */
            if (!realloc_stream(rstrm, rstrm->in_reclen)) {
                *statp = XPRT_DIED;
                return FALSE;
            }
        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
__xdrrec_setnonblock(XDR *xdrs, 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
flush_out(RECSTREAM *rstrm, bool_t eor)
{
    u_int32_t eormask = (eor == TRUE) ? LAST_FRAG : 0;
    u_int32_t len = (u_int32_t)((uintptr_t)(rstrm->out_finger) - (uintptr_t)(rstrm->frag_header)
                                - sizeof(u_int32_t));

    *(rstrm->frag_header) = htonl(len | eormask);
    len = (u_int32_t)((uintptr_t)(rstrm->out_finger) - (uintptr_t)(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 */
fill_input_buf(RECSTREAM *rstrm)
{
    char     *where;
    u_int32_t i;
    int       len;

    if (rstrm->nonblock)
        return FALSE;

    where = rstrm->in_base;
    i = (u_int32_t)((uintptr_t)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 */
get_input_bytes(RECSTREAM *rstrm, char *addr, 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)((intptr_t)rstrm->in_boundry - (intptr_t)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 */
set_input_fragment(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! */
skip_input_bytes(RECSTREAM *rstrm, long cnt)
{
    size_t current;

    while (cnt > 0) {
        current = (size_t)((intptr_t)rstrm->in_boundry - (intptr_t)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
fix_buf_size(u_int s)
{

    if (s < 100)
        s = 4000;
    return (RNDUP(s));
}

/*
 * Reallocate the input buffer for a non-block stream.
 */
static bool_t
realloc_stream(RECSTREAM *rstrm, 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;
        rstrm->in_buffer = buf;
        buf_algn = (char *)RNDUP((uintptr_t)buf);
        diff = buf_algn - buf;
        rstrm->in_finger += diff;
        rstrm->in_base = buf_algn;
        rstrm->in_boundry = buf_algn + size;
        rstrm->recvsize = size;
        rstrm->in_size = size;
    }

    return TRUE;
}
