928 lines
26 KiB
C
928 lines
26 KiB
C
|
|
/*
|
|
* 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 _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,
|
|
u_int sendsize,
|
|
u_int recvsize,
|
|
void *tcp_handle,
|
|
int _EXPARM (readit, (void *, void *, int)),
|
|
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,
|
|
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,
|
|
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,
|
|
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
|
|
_DEFUN (xdrrec_putbytes, (xdrs, addr, len),
|
|
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
|
|
_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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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
|
|
_DEFUN (__xdrrec_setnonblock, (xdrs, maxrec),
|
|
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
|
|
_DEFUN (flush_out, (rstrm, eor),
|
|
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 */
|
|
_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,
|
|
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 */
|
|
_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,
|
|
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,
|
|
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;
|
|
}
|
|
|