Label elements of rx structures
[openafs.git] / src / rx / xdr_rec.c
index 32aa256..d19f763 100644 (file)
@@ -26,9 +26,6 @@
  * Mountain View, California  94043
  */
 #ifndef        NeXT
-#ifndef lint
-static char sccsid[] = "@(#)xdr_rec.c 1.1 86/02/03 Copyr 1984 Sun Micro";
-#endif
 
 /*  * xdr_rec.c, Implements TCP/IP based XDR streams with a "record marking"
  * layer above tcp (for rpc's use).
@@ -46,45 +43,22 @@ static char sccsid[] = "@(#)xdr_rec.c 1.1 86/02/03 Copyr 1984 Sun Micro";
  * The other 31 bits encode the byte length of the fragment.
  */
 
+#include <afsconfig.h>
 #include <afs/param.h>
+
+
 #include <stdio.h>
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
 #include "xdr.h"
 #ifndef AFS_NT40_ENV
 #include <sys/time.h>
 #include <netinet/in.h>
 #endif
 
-#ifndef osi_alloc
-char *osi_alloc();
-#endif
-extern afs_int32 lseek();
-
-static u_int   fix_buf_size();
-
-static bool_t  flush_out();
-static bool_t  get_input_bytes();
-static bool_t  set_input_fragment();
-static bool_t  skip_input_bytes();
-
-static bool_t  xdrrec_getint32();
-static bool_t  xdrrec_putint32();
-static bool_t  xdrrec_getbytes();
-static bool_t  xdrrec_putbytes();
-static u_int   xdrrec_getpos();
-static bool_t  xdrrec_setpos();
-static afs_int32 *     xdrrec_inline();
-static void    xdrrec_destroy();
-
-static struct  xdr_ops xdrrec_ops = {
-       xdrrec_getint32,
-       xdrrec_putint32,
-       xdrrec_getbytes,
-       xdrrec_putbytes,
-       xdrrec_getpos,
-       xdrrec_setpos,
-       xdrrec_inline,
-       xdrrec_destroy
-};
+#include <string.h>
+
 
 /*  * A record is composed of one or more record fragments.
  * A record fragment is a two-byte header followed by zero to
@@ -101,28 +75,57 @@ static struct  xdr_ops xdrrec_ops = {
 #define LAST_FRAG ((afs_uint32)(1 << 31))
 
 typedef struct rec_strm {
-       caddr_t tcp_handle;
-       /*       * out-goung bits
-        */
-       int (*writeit)();
-       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 */
-       afs_uint32 *frag_header;        /* beginning of curren fragment */
-       bool_t frag_sent;       /* true if buffer sent in middle of record */
-       /*       * in-coming bits
-        */
-       int (*readit)();
-       afs_uint32 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 */
-       afs_int32 fbtbc;                /* fragment bytes to be consumed */
-       bool_t last_frag;
-       u_int sendsize;
-       u_int recvsize;
+    caddr_t tcp_handle;
+    /*       * out-goung bits
+     */
+    int (*writeit) (caddr_t tcp_handle, caddr_t out_base, int len);
+    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 */
+    afs_uint32 *frag_header;   /* beginning of curren fragment */
+    bool_t frag_sent;          /* true if buffer sent in middle of record */
+    /*       * in-coming bits
+     */
+    int (*readit) (caddr_t tcp_handle, caddr_t out_base, int len);
+    afs_uint32 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 */
+    afs_int32 fbtbc;           /* fragment bytes to be consumed */
+    bool_t last_frag;
+    u_int sendsize;
+    u_int recvsize;
 } RECSTREAM;
 
+/* Prototypes for static routines */
+static bool_t xdrrec_getint32(XDR * xdrs, afs_int32 * lp);
+static bool_t xdrrec_putint32(XDR * xdrs, afs_int32 * lp);
+static bool_t xdrrec_getbytes(XDR * xdrs, caddr_t addr,
+                             u_int len);
+static bool_t xdrrec_putbytes(XDR * xdrs, caddr_t addr,
+                             u_int len);
+static u_int xdrrec_getpos(XDR * xdrs);
+static bool_t xdrrec_setpos(XDR * xdrs, u_int pos);
+static afs_int32 *xdrrec_inline(XDR * xdrs, u_int len);
+static void xdrrec_destroy(XDR * xdrs);
+static bool_t flush_out(RECSTREAM * rstrm, bool_t eor);
+static bool_t fill_input_buf(RECSTREAM * rstrm);
+static bool_t get_input_bytes(RECSTREAM * rstrm,
+                             caddr_t addr, int len);
+static bool_t set_input_fragment(RECSTREAM * rstrm);
+static bool_t skip_input_bytes(RECSTREAM * rstrm, int cnt);
+static u_int fix_buf_size(u_int s);
+
+static struct xdr_ops xdrrec_ops = {
+    .x_getint32 = xdrrec_getint32,
+    .x_putint32 = xdrrec_putint32,
+    .x_getbytes = xdrrec_getbytes,
+    .x_putbytes = xdrrec_putbytes,
+    .x_getpos = xdrrec_getpos,
+    .x_setpos = xdrrec_setpos,
+    .x_inline = xdrrec_inline,
+    .x_destroy = xdrrec_destroy
+};
 
 /*  * Create an xdr handle for xdrrec
  * xdrrec_create fills in xdrs.  Sendsize and recvsize are
@@ -132,48 +135,48 @@ typedef struct rec_strm {
  * write respectively.   They are like the system
  * calls expect that they take an opaque handle rather than an fd.
  */
+/*
+       int (*readit)();  * like read, but pass it a tcp_handle, not sock *
+       int (*writeit)();  * like write, but pass it a tcp_handle, not sock *
+*/
 void
-xdrrec_create(xdrs, sendsize, recvsize, tcp_handle, readit, writeit)
-       register XDR *xdrs;
-       u_int sendsize;
-       u_int recvsize;
-       caddr_t tcp_handle;
-       int (*readit)();  /* like read, but pass it a tcp_handle, not sock */
-       int (*writeit)();  /* like write, but pass it a tcp_handle, not sock */
+xdrrec_create(XDR * xdrs, u_int sendsize, u_int recvsize,
+             caddr_t tcp_handle, int (*readit) (caddr_t tcp_handle,
+                                                caddr_t out_base, int len),
+             int (*writeit) (caddr_t tcp_handle, caddr_t out_base, int len))
 {
-       register RECSTREAM *rstrm =
-           (RECSTREAM *)osi_alloc(sizeof(RECSTREAM));
-
-       if (rstrm == NULL) {
-               /* 
-                *  This is bad.  Should rework xdrrec_create to 
-                *  return a handle, and in this case return NULL
-                */
-               return;
-       }
-       xdrs->x_ops = &xdrrec_ops;
-       xdrs->x_private = (caddr_t)rstrm;
-       rstrm->tcp_handle = tcp_handle;
-       rstrm->readit = readit;
-       rstrm->writeit = writeit;
-       sendsize = fix_buf_size(sendsize);
-       if ((rstrm->out_base = rstrm->out_finger = rstrm->out_boundry =
-           osi_alloc(sendsize)) == NULL) {
-               return;
-       }
-       rstrm->frag_header = (afs_uint32 *)rstrm->out_base;
-       rstrm->out_finger += sizeof(afs_uint32);
-       rstrm->out_boundry += sendsize;
-       rstrm->frag_sent = FALSE;
-       rstrm->in_size = recvsize = fix_buf_size(recvsize);
-       if ((rstrm->in_base = rstrm->in_boundry=osi_alloc(recvsize)) == NULL) {
-               return;
-       }
-       rstrm->in_finger = (rstrm->in_boundry += recvsize);
-       rstrm->fbtbc = 0;
-       rstrm->last_frag = TRUE;
-       rstrm->sendsize = sendsize;
-       rstrm->recvsize = recvsize;
+    RECSTREAM *rstrm = (RECSTREAM *) osi_alloc(sizeof(RECSTREAM));
+
+    if (rstrm == NULL) {
+       /* 
+        *  This is bad.  Should rework xdrrec_create to 
+        *  return a handle, and in this case return NULL
+        */
+       return;
+    }
+    xdrs->x_ops = &xdrrec_ops;
+    xdrs->x_private = (caddr_t) rstrm;
+    rstrm->tcp_handle = tcp_handle;
+    rstrm->readit = readit;
+    rstrm->writeit = writeit;
+    sendsize = fix_buf_size(sendsize);
+    if ((rstrm->out_base = rstrm->out_finger = rstrm->out_boundry =
+        osi_alloc(sendsize)) == NULL) {
+       return;
+    }
+    rstrm->frag_header = (afs_uint32 *) rstrm->out_base;
+    rstrm->out_finger += sizeof(afs_uint32);
+    rstrm->out_boundry += sendsize;
+    rstrm->frag_sent = FALSE;
+    rstrm->in_size = recvsize = fix_buf_size(recvsize);
+    if ((rstrm->in_base = rstrm->in_boundry = osi_alloc(recvsize)) == NULL) {
+       return;
+    }
+    rstrm->in_finger = (rstrm->in_boundry += recvsize);
+    rstrm->fbtbc = 0;
+    rstrm->last_frag = TRUE;
+    rstrm->sendsize = sendsize;
+    rstrm->recvsize = recvsize;
 }
 
 
@@ -182,205 +185,188 @@ xdrrec_create(xdrs, sendsize, recvsize, tcp_handle, readit, writeit)
  */
 
 static bool_t
-xdrrec_getint32(xdrs, lp)
-       XDR *xdrs;
-       afs_int32 *lp;
+xdrrec_getint32(XDR * xdrs, afs_int32 * lp)
 {
-       register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
-       register afs_int32 *buflp = (afs_int32 *)(rstrm->in_finger);
-       afs_int32 myint32;
-
-       /* first try the inline, fast case */
-       if ((rstrm->fbtbc >= sizeof(afs_int32)) &&
-           (((int)rstrm->in_boundry - (int)buflp) >= sizeof(afs_int32))) {
-               *lp = ntohl(*buflp);
-               rstrm->fbtbc -= sizeof(afs_int32);
-               rstrm->in_finger += sizeof(afs_int32);
-       } else {
-               if (! xdrrec_getbytes(xdrs, (caddr_t)&myint32, sizeof(afs_int32)))
-                       return (FALSE);
-               *lp = ntohl(myint32);
-       }
-       return (TRUE);
+    RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+    afs_int32 *buflp = (afs_int32 *) (rstrm->in_finger);
+    afs_int32 myint32;
+
+    /* first try the inline, fast case */
+    if ((rstrm->fbtbc >= sizeof(afs_int32))
+       && (((int)((char *)rstrm->in_boundry - (char *)buflp)) >= sizeof(afs_int32))) {
+       *lp = ntohl(*buflp);
+       rstrm->fbtbc -= sizeof(afs_int32);
+       rstrm->in_finger += sizeof(afs_int32);
+    } else {
+       if (!xdrrec_getbytes(xdrs, (caddr_t) & myint32, sizeof(afs_int32)))
+           return (FALSE);
+       *lp = ntohl(myint32);
+    }
+    return (TRUE);
 }
 
 static bool_t
-xdrrec_putint32(xdrs, lp)
-       XDR *xdrs;
-       afs_int32 *lp;
+xdrrec_putint32(XDR * xdrs, afs_int32 * lp)
 {
-       register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
-       register afs_int32 *dest_lp = ((afs_int32 *)(rstrm->out_finger));
-
-       if ((rstrm->out_finger += sizeof(afs_int32)) > rstrm->out_boundry) {
-               /*
-                * this case should almost never happen so the code is
-                * inefficient
-                */
-               rstrm->out_finger -= sizeof(afs_int32);
-               rstrm->frag_sent = TRUE;
-               if (! flush_out(rstrm, FALSE))
-                       return (FALSE);
-               dest_lp = ((afs_int32 *)(rstrm->out_finger));
-               rstrm->out_finger += sizeof(afs_int32);
-       }
-       *dest_lp = htonl(*lp);
-       return (TRUE);
+    RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+    afs_int32 *dest_lp = ((afs_int32 *) (rstrm->out_finger));
+
+    if ((rstrm->out_finger += sizeof(afs_int32)) > rstrm->out_boundry) {
+       /*
+        * this case should almost never happen so the code is
+        * inefficient
+        */
+       rstrm->out_finger -= sizeof(afs_int32);
+       rstrm->frag_sent = TRUE;
+       if (!flush_out(rstrm, FALSE))
+           return (FALSE);
+       dest_lp = ((afs_int32 *) (rstrm->out_finger));
+       rstrm->out_finger += sizeof(afs_int32);
+    }
+    *dest_lp = htonl(*lp);
+    return (TRUE);
 }
 
-static bool_t  /* must manage buffers, fragments, and records */
-xdrrec_getbytes(xdrs, addr, len)
-       XDR *xdrs;
-       register caddr_t addr;
-       register u_int len;
+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;
+    RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+    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;
        }
-       return (TRUE);
+       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 u_int len;
+xdrrec_putbytes(XDR * xdrs, caddr_t addr, u_int len)
 {
-       register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
-       register int current;
-
-       while (len > 0) {
-               current = (u_int)rstrm->out_boundry - (u_int)rstrm->out_finger;
-               current = (len < current) ? len : current;
-               bcopy(addr, rstrm->out_finger, 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);
-               }
+    RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+    int current;
+
+    while (len > 0) {
+       current = (u_int) (rstrm->out_boundry - rstrm->out_finger);
+       current = (len < current) ? len : current;
+       memcpy(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);
+    }
+    return (TRUE);
 }
 
 static u_int
-xdrrec_getpos(xdrs)
-       register XDR *xdrs;
+xdrrec_getpos(XDR * xdrs)
 {
-       register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
-       register u_int pos;
-
-       pos = (u_int) lseek((int)rstrm->tcp_handle, 0, 1);
-       if ((int)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 = (u_int) -1;
-                       break;
-               }
-       return (pos);
-}
+    RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
+    u_int pos;
 
-static bool_t
-xdrrec_setpos(xdrs, pos)
-       register 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;
-               }
-       return (FALSE);
+    pos = (u_int) lseek((int)rstrm->tcp_handle, 0, 1);
+    if ((int)pos != -1)
+       switch (xdrs->x_op) {
+
+       case XDR_ENCODE:
+           pos += (u_int)(rstrm->out_finger - rstrm->out_base);
+           break;
+
+       case XDR_DECODE:
+           pos -= (u_int)(rstrm->in_boundry - rstrm->in_finger);
+           break;
+
+       default:
+           pos = (u_int) - 1;
+           break;
+       }
+    return (pos);
 }
 
-static afs_int32 *
-xdrrec_inline(xdrs, len)
-       register XDR *xdrs;
-       int len;
+static bool_t
+xdrrec_setpos(XDR * xdrs, u_int pos)
 {
-       register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
-       afs_int32 * buf = NULL;
+    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:
-               if ((rstrm->out_finger + len) <= rstrm->out_boundry) {
-                       buf = (afs_int32 *) rstrm->out_finger;
-                       rstrm->out_finger += len;
-               }
-               break;
+           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:
-               if ((len <= rstrm->fbtbc) &&
-                   ((rstrm->in_finger + len) <= rstrm->in_boundry)) {
-                       buf = (afs_int32 *) rstrm->in_finger;
-                       rstrm->fbtbc -= len;
-                       rstrm->in_finger += len;
-               }
-               break;
+           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;
        }
-       return (buf);
+    return (FALSE);
+}
+
+static afs_int32 *
+xdrrec_inline(XDR * xdrs, u_int len)
+{
+    RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
+    afs_int32 *buf = NULL;
+
+    switch (xdrs->x_op) {
+
+    case XDR_ENCODE:
+       if ((rstrm->out_finger + len) <= rstrm->out_boundry) {
+           buf = (afs_int32 *) rstrm->out_finger;
+           rstrm->out_finger += len;
+       }
+       break;
+
+    case XDR_DECODE:
+       if ((len <= rstrm->fbtbc)
+           && ((rstrm->in_finger + len) <= rstrm->in_boundry)) {
+           buf = (afs_int32 *) rstrm->in_finger;
+           rstrm->fbtbc -= len;
+           rstrm->in_finger += len;
+       }
+       break;
+    }
+    return (buf);
 }
 
 static void
-xdrrec_destroy(xdrs)
-       register XDR *xdrs;
+xdrrec_destroy(XDR * xdrs)
 {
-       register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
+    RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
 
-       osi_free(rstrm->out_base, rstrm->sendsize);
-       osi_free(rstrm->in_base, rstrm->recvsize);
-       osi_free((caddr_t)rstrm, sizeof(RECSTREAM));
+    osi_free(rstrm->out_base, rstrm->sendsize);
+    osi_free(rstrm->in_base, rstrm->recvsize);
+    osi_free((caddr_t) rstrm, sizeof(RECSTREAM));
 }
 
 
@@ -393,20 +379,19 @@ xdrrec_destroy(xdrs)
  * this procedure to guarantee proper record alignment.
  */
 bool_t
-xdrrec_skiprecord(xdrs)
-       XDR *xdrs;
+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);
+    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);
 }
 
 /*
@@ -415,21 +400,20 @@ xdrrec_skiprecord(xdrs)
  * after consuming the rest of the current record.
  */
 bool_t
-xdrrec_eof(xdrs)
-       XDR *xdrs;
+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);
+    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);
 }
 
 /*
@@ -439,25 +423,24 @@ xdrrec_eof(xdrs)
  * pipelined procedure calls.)  TRUE => immmediate flush to tcp connection.
  */
 bool_t
-xdrrec_endofrecord(xdrs, sendnow)
-       XDR *xdrs;
-       bool_t sendnow;
+xdrrec_endofrecord(XDR * xdrs, bool_t sendnow)
 {
-       register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
-       register afs_uint32 len;  /* fragment length */
-
-       if (sendnow || rstrm->frag_sent ||
-           ((afs_uint32)rstrm->out_finger + sizeof(afs_uint32) >=
-           (afs_uint32)rstrm->out_boundry)) {
-               rstrm->frag_sent = FALSE;
-               return (flush_out(rstrm, TRUE));
-       }
-       len = (afs_uint32)(rstrm->out_finger) - (afs_uint32)(rstrm->frag_header) -
-          sizeof(afs_uint32);
-       *(rstrm->frag_header) = htonl(len | LAST_FRAG);
-       rstrm->frag_header = (afs_uint32 *)rstrm->out_finger;
-       rstrm->out_finger += sizeof(afs_uint32);
-       return (TRUE);
+    RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+    afs_uint32 len;    /* fragment length */
+
+    if (sendnow || rstrm->frag_sent
+       || ((afs_uint32) (rstrm->out_finger + sizeof(afs_uint32)) >=
+           (afs_uint32) rstrm->out_boundry)) {
+       rstrm->frag_sent = FALSE;
+       return (flush_out(rstrm, TRUE));
+    }
+    len =
+       (afs_uint32) (rstrm->out_finger - (caddr_t)rstrm->frag_header) -
+       sizeof(afs_uint32);
+    *(rstrm->frag_header) = htonl(len | LAST_FRAG);
+    rstrm->frag_header = (afs_uint32 *) rstrm->out_finger;
+    rstrm->out_finger += sizeof(afs_uint32);
+    return (TRUE);
 }
 
 
@@ -465,112 +448,107 @@ xdrrec_endofrecord(xdrs, sendnow)
  * Internal useful routines
  */
 static bool_t
-flush_out(rstrm, eor)
-       register RECSTREAM *rstrm;
-       bool_t eor;
+flush_out(RECSTREAM * rstrm, bool_t eor)
 {
-       register afs_uint32 eormask = (eor == TRUE) ? LAST_FRAG : 0;
-       register afs_uint32 len = (afs_uint32)(rstrm->out_finger) - 
-           (afs_uint32)(rstrm->frag_header) - sizeof(afs_uint32);
-
-       *(rstrm->frag_header) = htonl(len | eormask);
-       len = (afs_uint32)(rstrm->out_finger) - (afs_uint32)(rstrm->out_base);
-       if ((*(rstrm->writeit))(rstrm->tcp_handle, rstrm->out_base, (int)len)
-           != (int)len)
-               return (FALSE);
-       rstrm->frag_header = (afs_uint32 *)rstrm->out_base;
-       rstrm->out_finger = (caddr_t)rstrm->out_base + sizeof(afs_uint32);
-       return (TRUE);
+    afs_uint32 eormask = (eor == TRUE) ? LAST_FRAG : 0;
+    afs_uint32 len =
+       (afs_uint32) (rstrm->out_finger - (caddr_t)rstrm->frag_header) -
+       sizeof(afs_uint32);
+
+    *(rstrm->frag_header) = htonl(len | eormask);
+    len = (afs_uint32) (rstrm->out_finger) - (afs_uint32) (rstrm->out_base);
+    if ((*(rstrm->writeit)) (rstrm->tcp_handle, rstrm->out_base, (int)len)
+       != (int)len)
+       return (FALSE);
+    rstrm->frag_header = (afs_uint32 *) rstrm->out_base;
+    rstrm->out_finger = (caddr_t) rstrm->out_base + sizeof(afs_uint32);
+    return (TRUE);
 }
 
-static bool_t  /* knows nothing about records!  Only about input buffers */
-fill_input_buf(rstrm)
-       register RECSTREAM *rstrm;
+static bool_t
+fill_input_buf(RECSTREAM * rstrm)
 {
-       register caddr_t where = rstrm->in_base;
-       register int len = rstrm->in_size;
-       u_int adjust = (u_int)rstrm->in_boundry % BYTES_PER_XDR_UNIT;
+    caddr_t where = rstrm->in_base;
+    int len = rstrm->in_size;
+    u_int adjust = (u_int) ((size_t)rstrm->in_boundry % BYTES_PER_XDR_UNIT);
 
-       /* Bump the current position out to the next alignment boundary*/
-       where += adjust;
-       len -= adjust;
+    /* Bump the current position out to the next alignment boundary */
+    where += adjust;
+    len -= adjust;
 
-       if ((len = (*(rstrm->readit))(rstrm->tcp_handle, where, len)) == -1)
-               return (FALSE);
-       rstrm->in_finger = where;
-       where += len;
-       rstrm->in_boundry = where;
-       return (TRUE);
+    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(rstrm, addr, len)
-       register RECSTREAM *rstrm;
-       register caddr_t addr;
-       register int len;
+static bool_t
+get_input_bytes(RECSTREAM * rstrm, caddr_t addr,
+               int len)
 {
-       register int current;
-
-       while (len > 0) {
-               current = (int)rstrm->in_boundry - (int)rstrm->in_finger;
-               if (current == 0) {
-                       if (! fill_input_buf(rstrm))
-                               return (FALSE);
-                       continue;
-               }
-               current = (len < current) ? len : current;
-               bcopy(rstrm->in_finger, addr, current);
-               rstrm->in_finger += current;
-               addr += current;
-               len -= current;
+    int current;
+
+    while (len > 0) {
+       current = (int)(rstrm->in_boundry - rstrm->in_finger);
+       if (current == 0) {
+           if (!fill_input_buf(rstrm))
+               return (FALSE);
+           continue;
        }
-       return (TRUE);
+       current = (len < current) ? len : current;
+       memcpy(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(rstrm)
-       register RECSTREAM *rstrm;
+/* next two bytes of the input stream are treated as a header */
+static bool_t
+set_input_fragment(RECSTREAM * rstrm)
 {
-       afs_uint32 header;
+    afs_uint32 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);
+    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  /* consumes input bytes; knows nothing about records! */
-skip_input_bytes(rstrm, cnt)
-       register RECSTREAM *rstrm;
-       int cnt;
+/* consumes input bytes; knows nothing about records! */
+static bool_t
+skip_input_bytes(RECSTREAM * rstrm, int cnt)
 {
-       register int current;
-
-       while (cnt > 0) {
-               current = (int)rstrm->in_boundry - (int)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;
+    int current;
+
+    while (cnt > 0) {
+       current = (int)(rstrm->in_boundry - rstrm->in_finger);
+       if (current == 0) {
+           if (!fill_input_buf(rstrm))
+               return (FALSE);
+           continue;
        }
-       return (TRUE);
+       current = (cnt < current) ? cnt : current;
+       rstrm->in_finger += current;
+       cnt -= current;
+    }
+    return (TRUE);
 }
 
 static u_int
-fix_buf_size(s)
-       register u_int s;
+fix_buf_size(u_int s)
 {
 
-       if (s < 100)
-           s = 4000;
-       return ((s + BYTES_PER_XDR_UNIT - 1) / BYTES_PER_XDR_UNIT)
-               * BYTES_PER_XDR_UNIT;
+    if (s < 100)
+       s = 4000;
+    return ((s + BYTES_PER_XDR_UNIT - 1) / BYTES_PER_XDR_UNIT)
+       * BYTES_PER_XDR_UNIT;
 
 }
+
 #endif /* NeXT */