#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, u_int);
static bool_t xdrrec_putbytes(XDR *, caddr_t, u_int);
static u_int xdrrec_getpos(XDR *);
static bool_t xdrrec_setpos(XDR *, u_int);
static rpc_inline_t * 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 ((uint32_t)(1L << 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;
uint32_t *frag_header;
bool_t frag_sent;
int (*readit)();
uint32_t in_size;
caddr_t in_base;
caddr_t in_finger;
caddr_t in_boundry;
int32_t fbtbc;
bool_t last_frag;
u_int sendsize;
u_int recvsize;
} RECSTREAM;
static u_int fix_buf_size(u_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 *, int32_t);
void
xdrrec_create(
XDR *xdrs,
u_int sendsize,
u_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;
(u_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 = (uint32_t *)(void *)rstrm->out_base;
rstrm->out_finger += BYTES_PER_XDR_UNIT;
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(XDR *xdrs, long *lp)
{
register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
register int32_t *buflp = (int32_t *)(void *)(rstrm->in_finger);
uint32_t mylong;
if ((rstrm->fbtbc >= BYTES_PER_XDR_UNIT) &&
(((long)rstrm->in_boundry - (long)buflp) >=
BYTES_PER_XDR_UNIT)) {
*lp = (long)ntohl((uint32_t)(*buflp));
rstrm->fbtbc -= BYTES_PER_XDR_UNIT;
rstrm->in_finger += BYTES_PER_XDR_UNIT;
} else {
if (! xdrrec_getbytes(xdrs, (caddr_t)&mylong,
BYTES_PER_XDR_UNIT))
return (FALSE);
*lp = (long)(int32_t)ntohl(mylong);
}
return (TRUE);
}
static bool_t
xdrrec_putlong(XDR *xdrs, long *lp)
{
register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
register int32_t *dest_lp = ((int32_t *)(void *)(rstrm->out_finger));
if (rstrm->out_boundry - rstrm->out_finger < BYTES_PER_XDR_UNIT) {
rstrm->frag_sent = TRUE;
if (! flush_out(rstrm, FALSE))
return (FALSE);
dest_lp = ((int32_t *)(void *)(rstrm->out_finger));
}
rstrm->out_finger += BYTES_PER_XDR_UNIT;
*dest_lp = (int32_t)htonl((uint32_t)(*lp));
return (TRUE);
}
static bool_t
xdrrec_getbytes(XDR *xdrs, caddr_t addr, u_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(XDR *xdrs, caddr_t addr, u_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 u_int
xdrrec_getpos(XDR *xdrs)
{
register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
register int pos;
switch (xdrs->x_op) {
case XDR_ENCODE:
pos = rstrm->out_finger - rstrm->out_base
- BYTES_PER_XDR_UNIT;
break;
case XDR_DECODE:
pos = rstrm->in_boundry - rstrm->in_finger
- BYTES_PER_XDR_UNIT;
break;
default:
pos = -1;
break;
}
return ((u_int) pos);
}
static bool_t
xdrrec_setpos(XDR *xdrs, u_int pos)
{
register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
u_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_inline_t *
xdrrec_inline(XDR *xdrs, int len)
{
register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
rpc_inline_t * buf = NULL;
if (len < 0)
return (FALSE);
switch (xdrs->x_op) {
case XDR_ENCODE:
if (len <= (rstrm->out_boundry - rstrm->out_finger)) {
buf = (rpc_inline_t *)(void *) rstrm->out_finger;
rstrm->out_finger += len;
}
break;
case XDR_DECODE:
if ((len <= rstrm->fbtbc) &&
(len <= (rstrm->in_boundry - rstrm->in_finger))) {
buf = (rpc_inline_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)
{
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(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(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(XDR *xdrs, bool_t sendnow)
{
register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
register uint32_t len;
if (sendnow || rstrm->frag_sent ||
((long)rstrm->out_finger + BYTES_PER_XDR_UNIT >=
(long)rstrm->out_boundry)) {
rstrm->frag_sent = FALSE;
return (flush_out(rstrm, TRUE));
}
len = (long)(rstrm->out_finger) - (long)(rstrm->frag_header) -
BYTES_PER_XDR_UNIT;
*(rstrm->frag_header) = htonl((uint32_t)len | LAST_FRAG);
rstrm->frag_header = (uint32_t *)(void *)rstrm->out_finger;
rstrm->out_finger += BYTES_PER_XDR_UNIT;
return (TRUE);
}
static bool_t
flush_out(RECSTREAM *rstrm, bool_t eor)
{
register uint32_t eormask = (eor == TRUE) ? LAST_FRAG : 0;
register uint32_t len = (u_long)(rstrm->out_finger) -
(u_long)(rstrm->frag_header) - BYTES_PER_XDR_UNIT;
*(rstrm->frag_header) = htonl(len | eormask);
len = (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 = (uint32_t *)(void *)rstrm->out_base;
rstrm->out_finger = (caddr_t)rstrm->out_base + BYTES_PER_XDR_UNIT;
return (TRUE);
}
static bool_t
fill_input_buf(RECSTREAM *rstrm)
{
register caddr_t where;
u_int i;
register int len;
where = rstrm->in_base;
i = (u_int)((u_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(RECSTREAM *rstrm, caddr_t addr, 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;
{
uint32_t header;
if (! get_input_bytes(rstrm, (caddr_t)&header, sizeof(header)))
return (FALSE);
header = ntohl(header);
rstrm->last_frag = ((header & LAST_FRAG) == 0) ? FALSE : TRUE;
rstrm->fbtbc = header & (~LAST_FRAG);
return (TRUE);
}
static bool_t
skip_input_bytes(RECSTREAM *rstrm, int32_t 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 u_int
fix_buf_size(u_int s)
{
if (s < 100)
s = 4000;
return (RNDUP(s));
}