#if !defined(lint) && defined(SCCSIDS)
static char sccsid[] = "@(#)xdr_rec.c 1.21 87/08/11 Copyr 1984 Sun Micro";
#endif
#include <stdio.h>
#include <gssrpc/types.h>
#include <gssrpc/xdr.h>
#include <netinet/in.h>
#include <unistd.h>
#include <string.h>
static bool_t xdrrec_getlong(XDR *, long *);
static bool_t xdrrec_putlong(XDR *, long *);
static bool_t xdrrec_getbytes(XDR *, caddr_t, unsigned int);
static bool_t xdrrec_putbytes(XDR *, caddr_t, unsigned int);
static unsigned int xdrrec_getpos(XDR *);
static bool_t xdrrec_setpos(XDR *, unsigned int);
static rpc_int32 * xdrrec_inline(XDR *, int);
static void xdrrec_destroy(XDR *);
static struct xdr_ops xdrrec_ops = {
xdrrec_getlong,
xdrrec_putlong,
xdrrec_getbytes,
xdrrec_putbytes,
xdrrec_getpos,
xdrrec_setpos,
xdrrec_inline,
xdrrec_destroy
};
#define LAST_FRAG ((rpc_u_int32)(1 << 31))
typedef struct rec_strm {
caddr_t tcp_handle;
caddr_t the_buffer;
int (*writeit)();
caddr_t out_base;
caddr_t out_finger;
caddr_t out_boundry;
rpc_u_int32 *frag_header;
bool_t frag_sent;
int (*readit)();
rpc_u_int32 in_size;
caddr_t in_base;
caddr_t in_finger;
caddr_t in_boundry;
rpc_int32 fbtbc;
bool_t last_frag;
unsigned int sendsize;
unsigned int recvsize;
} RECSTREAM;
static unsigned int fix_buf_size(unsigned int);
static bool_t flush_out(RECSTREAM *, bool_t);
static bool_t get_input_bytes(RECSTREAM *, caddr_t, int);
static bool_t set_input_fragment(RECSTREAM *);
static bool_t skip_input_bytes(RECSTREAM *, rpc_int32);
void
xdrrec_create(xdrs, sendsize, recvsize, tcp_handle, readit, writeit)
register XDR *xdrs;
register unsigned int sendsize;
register unsigned int recvsize;
caddr_t tcp_handle;
int (*readit)();
int (*writeit)();
{
register RECSTREAM *rstrm =
(RECSTREAM *)mem_alloc(sizeof(RECSTREAM));
if (rstrm == NULL) {
(void)fprintf(stderr, "xdrrec_create: out of memory\n");
return;
}
rstrm->sendsize = sendsize = fix_buf_size(sendsize);
rstrm->recvsize = recvsize = fix_buf_size(recvsize);
rstrm->the_buffer = mem_alloc(sendsize + recvsize + BYTES_PER_XDR_UNIT);
if (rstrm->the_buffer == NULL) {
(void)fprintf(stderr, "xdrrec_create: out of memory\n");
return;
}
for (rstrm->out_base = rstrm->the_buffer;
(unsigned long)rstrm->out_base % BYTES_PER_XDR_UNIT != 0;
rstrm->out_base++);
rstrm->in_base = rstrm->out_base + sendsize;
xdrs->x_ops = &xdrrec_ops;
xdrs->x_private = (caddr_t)rstrm;
rstrm->tcp_handle = tcp_handle;
rstrm->readit = readit;
rstrm->writeit = writeit;
rstrm->out_finger = rstrm->out_boundry = rstrm->out_base;
rstrm->frag_header = (rpc_u_int32 *)(void *)rstrm->out_base;
rstrm->out_finger += sizeof(rpc_u_int32);
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;
}
static bool_t
xdrrec_getlong(xdrs, lp)
XDR *xdrs;
long *lp;
{
register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
register rpc_int32 *buflp = (rpc_int32 *)(void *)(rstrm->in_finger);
int mylong;
if ((rstrm->fbtbc >= sizeof(rpc_int32)) &&
(((long)rstrm->in_boundry - (long)buflp) >= sizeof(rpc_int32))) {
*lp = (long)ntohl((rpc_u_int32)(*buflp));
rstrm->fbtbc -= sizeof(rpc_int32);
rstrm->in_finger += sizeof(rpc_int32);
} else {
if (! xdrrec_getbytes(xdrs, (caddr_t)&mylong, sizeof(rpc_int32)))
return (FALSE);
*lp = (long)ntohl((unsigned int)mylong);
}
return (TRUE);
}
static bool_t
xdrrec_putlong(xdrs, lp)
XDR *xdrs;
long *lp;
{
register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
register rpc_int32 *dest_lp = ((rpc_int32 *)(void *)(rstrm->out_finger));
if ((rstrm->out_finger += sizeof(rpc_int32)) > rstrm->out_boundry) {
rstrm->out_finger -= sizeof(rpc_int32);
rstrm->frag_sent = TRUE;
if (! flush_out(rstrm, FALSE))
return (FALSE);
dest_lp = ((rpc_int32 *)(void *)(rstrm->out_finger));
rstrm->out_finger += sizeof(rpc_int32);
}
*dest_lp = (rpc_int32)htonl((rpc_u_int32)(*lp));
return (TRUE);
}
static bool_t
xdrrec_getbytes(xdrs, addr, len)
XDR *xdrs;
register caddr_t addr;
register unsigned int len;
{
register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
register int current;
while (len > 0) {
current = 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(xdrs, addr, len)
XDR *xdrs;
register caddr_t addr;
register unsigned int len;
{
register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
register size_t current;
while (len > 0) {
current = (size_t) ((long)rstrm->out_boundry -
(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 unsigned int
xdrrec_getpos(xdrs)
register XDR *xdrs;
{
register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
register int pos;
#ifdef __osf__
pos = -1;
#else
pos = lseek((int)rstrm->tcp_handle, (off_t) 0, 1);
#endif
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 = (unsigned int) -1;
break;
}
return ((unsigned int) pos);
}
static bool_t
xdrrec_setpos(xdrs, pos)
register XDR *xdrs;
unsigned int pos;
{
register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
unsigned int currpos = xdrrec_getpos(xdrs);
int delta = currpos - pos;
caddr_t newpos;
if ((int)currpos != -1)
switch (xdrs->x_op) {
case XDR_ENCODE:
newpos = rstrm->out_finger - delta;
if ((newpos > (caddr_t)(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 rpc_int32 *
xdrrec_inline(xdrs, len)
register XDR *xdrs;
int len;
{
register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
rpc_int32 * buf = NULL;
switch (xdrs->x_op) {
case XDR_ENCODE:
if ((rstrm->out_finger + len) <= rstrm->out_boundry) {
buf = (rpc_int32 *)(void *) rstrm->out_finger;
rstrm->out_finger += len;
}
break;
case XDR_DECODE:
if ((len <= rstrm->fbtbc) &&
((rstrm->in_finger + len) <= rstrm->in_boundry)) {
buf = (rpc_int32 *)(void *) rstrm->in_finger;
rstrm->fbtbc -= len;
rstrm->in_finger += len;
}
break;
case XDR_FREE:
break;
}
return (buf);
}
static void
xdrrec_destroy(xdrs)
register XDR *xdrs;
{
register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
mem_free(rstrm->the_buffer,
rstrm->sendsize + rstrm->recvsize + BYTES_PER_XDR_UNIT);
mem_free((caddr_t)rstrm, sizeof(RECSTREAM));
}
bool_t
xdrrec_skiprecord(xdrs)
XDR *xdrs;
{
register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
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);
}
bool_t
xdrrec_eof(xdrs)
XDR *xdrs;
{
register 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);
}
bool_t
xdrrec_endofrecord(xdrs, sendnow)
XDR *xdrs;
bool_t sendnow;
{
register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
register rpc_u_int32 len;
if (sendnow || rstrm->frag_sent ||
((long)rstrm->out_finger + sizeof(unsigned int) >=
(long)rstrm->out_boundry)) {
rstrm->frag_sent = FALSE;
return (flush_out(rstrm, TRUE));
}
len = (long)(rstrm->out_finger) - (long)(rstrm->frag_header) -
sizeof(unsigned int);
*(rstrm->frag_header) = htonl((unsigned int)len | LAST_FRAG);
rstrm->frag_header = (rpc_u_int32 *)(void *)rstrm->out_finger;
rstrm->out_finger += sizeof(unsigned int);
return (TRUE);
}
static bool_t
flush_out(rstrm, eor)
register RECSTREAM *rstrm;
bool_t eor;
{
register rpc_u_int32 eormask = (eor == TRUE) ? LAST_FRAG : 0;
register rpc_u_int32 len = (unsigned long)(rstrm->out_finger) -
(unsigned long)(rstrm->frag_header) - sizeof(rpc_u_int32);
*(rstrm->frag_header) = htonl(len | eormask);
len = (unsigned long)(rstrm->out_finger) - (unsigned long)(rstrm->out_base);
if ((*(rstrm->writeit))(rstrm->tcp_handle, rstrm->out_base, (int)len)
!= (int)len)
return (FALSE);
rstrm->frag_header = (rpc_u_int32 *)(void *)rstrm->out_base;
rstrm->out_finger = (caddr_t)rstrm->out_base + sizeof(rpc_u_int32);
return (TRUE);
}
static bool_t
fill_input_buf(rstrm)
register RECSTREAM *rstrm;
{
register caddr_t where;
unsigned int i;
register int len;
where = rstrm->in_base;
i = (unsigned int)((unsigned long)rstrm->in_boundry % BYTES_PER_XDR_UNIT);
where += i;
len = 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
get_input_bytes(rstrm, addr, len)
register RECSTREAM *rstrm;
register caddr_t addr;
register int len;
{
register size_t current;
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
set_input_fragment(rstrm)
register RECSTREAM *rstrm;
{
rpc_u_int32 header;
if (! get_input_bytes(rstrm, (caddr_t)&header, sizeof(header)))
return (FALSE);
header = (int)ntohl(header);
rstrm->last_frag = ((header & LAST_FRAG) == 0) ? FALSE : TRUE;
rstrm->fbtbc = header & (~LAST_FRAG);
return (TRUE);
}
static bool_t
skip_input_bytes(rstrm, cnt)
register RECSTREAM *rstrm;
rpc_int32 cnt;
{
register int current;
while (cnt > 0) {
current = (int)((long)rstrm->in_boundry -
(long)rstrm->in_finger);
if (current == 0) {
if (! fill_input_buf(rstrm))
return (FALSE);
continue;
}
current = (cnt < current) ? cnt : current;
rstrm->in_finger += current;
cnt -= current;
}
return (TRUE);
}
static unsigned int
fix_buf_size(s)
register unsigned int s;
{
if (s < 100)
s = 4000;
return (RNDUP(s));
}