From 3d7c4998ac37629eae7ad07a48844cf2ce8ec750 Mon Sep 17 00:00:00 2001 From: Corinna Vinschen Date: Tue, 2 Mar 2010 12:05:18 +0000 Subject: 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. --- newlib/libc/xdr/xdr_rec.c | 926 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 926 insertions(+) create mode 100644 newlib/libc/xdr/xdr_rec.c (limited to 'newlib/libc/xdr/xdr_rec.c') 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 +#include +#include +#include +#include +#include +#include + +#include +#include + +#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; +} + -- cgit v1.2.3