drew
/
acadia-newlib
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
acadia-newlib/newlib/libc/xdr/xdr_rec.c

905 lines
25 KiB
C
Raw Blame History

/*
* 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 <limits.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 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;
(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
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 >= 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
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) ((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
xdrrec_getpos (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
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 >= 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
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 ||
((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
__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 < 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
__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) ((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 */
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) ((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 */
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) ((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 */
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) ((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
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;
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;
}
Reference in New Issue View Git Blame Copy Permalink