libc/xdr: Use standard types.
authorSascha Wildner <saw@online.de>
Sat, 9 Jun 2018 07:45:26 +0000 (09:45 +0200)
committerSascha Wildner <saw@online.de>
Sat, 9 Jun 2018 07:45:26 +0000 (09:45 +0200)
include/rpc/xdr.h
lib/libc/xdr/xdr.3
lib/libc/xdr/xdr.c
lib/libc/xdr/xdr_mem.c
lib/libc/xdr/xdr_rec.c
lib/libc/xdr/xdr_stdio.c

index 5a2eeeb..70edbdf 100644 (file)
@@ -255,13 +255,13 @@ struct xdr_discrim {
  * N.B. and frozen for all time: each data type here uses 4 bytes
  * of external representation.
  */
-#define IXDR_GET_INT32(buf)            ((int32_t)__ntohl((u_int32_t)*(buf)++))
-#define IXDR_PUT_INT32(buf, v)         (*(buf)++ =(int32_t)__htonl((u_int32_t)v))
-#define IXDR_GET_U_INT32(buf)          ((u_int32_t)IXDR_GET_INT32(buf))
+#define IXDR_GET_INT32(buf)            ((int32_t)__ntohl((uint32_t)*(buf)++))
+#define IXDR_PUT_INT32(buf, v)         (*(buf)++ =(int32_t)__htonl((uint32_t)v))
+#define IXDR_GET_U_INT32(buf)          ((uint32_t)IXDR_GET_INT32(buf))
 #define IXDR_PUT_U_INT32(buf, v)       IXDR_PUT_INT32((buf), ((int32_t)(v)))
 
-#define IXDR_GET_LONG(buf)             ((long)__ntohl((u_int32_t)*(buf)++))
-#define IXDR_PUT_LONG(buf, v)          (*(buf)++ =(int32_t)__htonl((u_int32_t)v))
+#define IXDR_GET_LONG(buf)             ((long)__ntohl((uint32_t)*(buf)++))
+#define IXDR_PUT_LONG(buf, v)          (*(buf)++ =(int32_t)__htonl((uint32_t)v))
 
 #define IXDR_GET_BOOL(buf)             ((bool_t)IXDR_GET_LONG(buf))
 #define IXDR_GET_ENUM(buf, t)          ((t)IXDR_GET_LONG(buf))
@@ -287,13 +287,13 @@ extern bool_t     xdr_u_long(XDR *, u_long *);
 extern bool_t  xdr_short(XDR *, short *);
 extern bool_t  xdr_u_short(XDR *, u_short *);
 extern bool_t  xdr_int16_t(XDR *, int16_t *);
-extern bool_t  xdr_u_int16_t(XDR *, u_int16_t *);
+extern bool_t  xdr_u_int16_t(XDR *, uint16_t *);
 extern bool_t  xdr_int32_t(XDR *, int32_t *);
-extern bool_t  xdr_u_int32_t(XDR *, u_int32_t *);
-extern bool_t  xdr_uint32_t(XDR *, u_int32_t *);
+extern bool_t  xdr_u_int32_t(XDR *, uint32_t *);
+extern bool_t  xdr_uint32_t(XDR *, uint32_t *);
 extern bool_t  xdr_int64_t(XDR *, int64_t *);
-extern bool_t  xdr_u_int64_t(XDR *, u_int64_t *);
-extern bool_t  xdr_uint64_t(XDR *, u_int64_t *);
+extern bool_t  xdr_u_int64_t(XDR *, uint64_t *);
+extern bool_t  xdr_uint64_t(XDR *, uint64_t *);
 extern bool_t  xdr_bool(XDR *, bool_t *);
 extern bool_t  xdr_enum(XDR *, enum_t *);
 extern bool_t  xdr_array(XDR *, char **, u_int *, u_int, u_int, xdrproc_t);
index 00f6484..9c06516 100644 (file)
@@ -710,10 +710,10 @@ This routine returns one if it succeeds, zero otherwise.
 .Ft int
 .Xc
 .It Xo
-.Fn xdr_u_int64_t "XDR *xdrs" "u_int64_t *llp"
+.Fn xdr_u_int64_t "XDR *xdrs" "uint64_t *llp"
 .Xc
 A filter primitive that translates between C
-.Vt u_int64_t
+.Vt uint64_t
 integers and their external representations.
 This routine returns one if it succeeds, zero otherwise.
 .Pp
index 6ebb724..b293c65 100644 (file)
@@ -221,21 +221,21 @@ xdr_int32_t(XDR *xdrs, int32_t *int32_p)
  * same as xdr_int32_t - open coded to save a proc call!
  */
 bool_t
-xdr_u_int32_t(XDR *xdrs, u_int32_t *u_int32_p)
+xdr_u_int32_t(XDR *xdrs, uint32_t *uint32_p)
 {
        u_long l;
 
        switch (xdrs->x_op) {
 
        case XDR_ENCODE:
-               l = (u_long) *u_int32_p;
+               l = (u_long) *uint32_p;
                return (XDR_PUTLONG(xdrs, (long *)&l));
 
        case XDR_DECODE:
                if (!XDR_GETLONG(xdrs, (long *)&l)) {
                        return (FALSE);
                }
-               *u_int32_p = (u_int32_t) l;
+               *uint32_p = (uint32_t) l;
                return (TRUE);
 
        case XDR_FREE:
@@ -250,21 +250,21 @@ xdr_u_int32_t(XDR *xdrs, u_int32_t *u_int32_p)
  * same as xdr_int32_t - open coded to save a proc call!
  */
 bool_t
-xdr_uint32_t(XDR *xdrs, uint32_t *u_int32_p)
+xdr_uint32_t(XDR *xdrs, uint32_t *uint32_p)
 {
        u_long l;
 
        switch (xdrs->x_op) {
 
        case XDR_ENCODE:
-               l = (u_long) *u_int32_p;
+               l = (u_long) *uint32_p;
                return (XDR_PUTLONG(xdrs, (long *)&l));
 
        case XDR_DECODE:
                if (!XDR_GETLONG(xdrs, (long *)&l)) {
                        return (FALSE);
                }
-               *u_int32_p = (u_int32_t) l;
+               *uint32_p = (uint32_t) l;
                return (TRUE);
 
        case XDR_FREE:
@@ -363,21 +363,21 @@ xdr_int16_t(XDR *xdrs, int16_t *int16_p)
  * XDR unsigned 16-bit integers
  */
 bool_t
-xdr_u_int16_t(XDR *xdrs, u_int16_t *u_int16_p)
+xdr_u_int16_t(XDR *xdrs, uint16_t *uint16_p)
 {
        u_long l;
 
        switch (xdrs->x_op) {
 
        case XDR_ENCODE:
-               l = (u_long) *u_int16_p;
+               l = (u_long) *uint16_p;
                return (XDR_PUTLONG(xdrs, (long *)&l));
 
        case XDR_DECODE:
                if (!XDR_GETLONG(xdrs, (long *)&l)) {
                        return (FALSE);
                }
-               *u_int16_p = (u_int16_t) l;
+               *uint16_p = (uint16_t) l;
                return (TRUE);
 
        case XDR_FREE:
@@ -732,8 +732,8 @@ xdr_int64_t(XDR *xdrs, int64_t *llp)
 
        switch (xdrs->x_op) {
        case XDR_ENCODE:
-               ul[0] = (u_long)((u_int64_t)*llp >> 32) & 0xffffffff;
-               ul[1] = (u_long)((u_int64_t)*llp) & 0xffffffff;
+               ul[0] = (u_long)((uint64_t)*llp >> 32) & 0xffffffff;
+               ul[1] = (u_long)((uint64_t)*llp) & 0xffffffff;
                if (XDR_PUTLONG(xdrs, (long *)&ul[0]) == FALSE)
                        return (FALSE);
                return (XDR_PUTLONG(xdrs, (long *)&ul[1]));
@@ -743,7 +743,7 @@ xdr_int64_t(XDR *xdrs, int64_t *llp)
                if (XDR_GETLONG(xdrs, (long *)&ul[1]) == FALSE)
                        return (FALSE);
                *llp = (int64_t)
-                   (((u_int64_t)ul[0] << 32) | ((u_int64_t)ul[1]));
+                   (((uint64_t)ul[0] << 32) | ((uint64_t)ul[1]));
                return (TRUE);
        case XDR_FREE:
                return (TRUE);
@@ -757,7 +757,7 @@ xdr_int64_t(XDR *xdrs, int64_t *llp)
  * XDR unsigned 64-bit integers
  */
 bool_t
-xdr_u_int64_t(XDR *xdrs, u_int64_t *ullp)
+xdr_u_int64_t(XDR *xdrs, uint64_t *ullp)
 {
        u_long ul[2];
 
@@ -773,8 +773,8 @@ xdr_u_int64_t(XDR *xdrs, u_int64_t *ullp)
                        return (FALSE);
                if (XDR_GETLONG(xdrs, (long *)&ul[1]) == FALSE)
                        return (FALSE);
-               *ullp = (u_int64_t)
-                   (((u_int64_t)ul[0] << 32) | ((u_int64_t)ul[1]));
+               *ullp = (uint64_t)
+                   (((uint64_t)ul[0] << 32) | ((uint64_t)ul[1]));
                return (TRUE);
        case XDR_FREE:
                return (TRUE);
@@ -840,7 +840,7 @@ xdr_u_hyper(XDR *xdrs, u_longlong_t *ullp)
         * Don't bother open-coding this; it's a fair amount of code.  Just
         * call xdr_u_int64_t().
         */
-       return (xdr_u_int64_t(xdrs, (u_int64_t *)ullp));
+       return (xdr_u_int64_t(xdrs, (uint64_t *)ullp));
 }
 
 
@@ -870,5 +870,5 @@ xdr_u_longlong_t(XDR *xdrs, u_longlong_t *ullp)
         * Don't bother open-coding this; it's a fair amount of code.  Just
         * call xdr_u_int64_t().
         */
-       return (xdr_u_int64_t(xdrs, (u_int64_t *)ullp));
+       return (xdr_u_int64_t(xdrs, (uint64_t *)ullp));
 }
index 35ad189..9e15f84 100644 (file)
@@ -120,7 +120,7 @@ xdrmem_getlong_aligned(XDR *xdrs, long *lp)
        if (xdrs->x_handy < sizeof(int32_t))
                return (FALSE);
        xdrs->x_handy -= sizeof(int32_t);
-       *lp = ntohl(*(u_int32_t *)xdrs->x_private);
+       *lp = ntohl(*(uint32_t *)xdrs->x_private);
        xdrs->x_private = (char *)xdrs->x_private + sizeof(int32_t);
        return (TRUE);
 }
@@ -132,7 +132,7 @@ xdrmem_putlong_aligned(XDR *xdrs, const long *lp)
        if (xdrs->x_handy < sizeof(int32_t))
                return (FALSE);
        xdrs->x_handy -= sizeof(int32_t);
-       *(u_int32_t *)xdrs->x_private = htonl((u_int32_t)*lp);
+       *(uint32_t *)xdrs->x_private = htonl((uint32_t)*lp);
        xdrs->x_private = (char *)xdrs->x_private + sizeof(int32_t);
        return (TRUE);
 }
@@ -140,7 +140,7 @@ xdrmem_putlong_aligned(XDR *xdrs, const long *lp)
 static bool_t
 xdrmem_getlong_unaligned(XDR *xdrs, long *lp)
 {
-       u_int32_t l;
+       uint32_t l;
 
        if (xdrs->x_handy < sizeof(int32_t))
                return (FALSE);
@@ -154,12 +154,12 @@ xdrmem_getlong_unaligned(XDR *xdrs, long *lp)
 static bool_t
 xdrmem_putlong_unaligned(XDR *xdrs, const long *lp)
 {
-       u_int32_t l;
+       uint32_t l;
 
        if (xdrs->x_handy < sizeof(int32_t))
                return (FALSE);
        xdrs->x_handy -= sizeof(int32_t);
-       l = htonl((u_int32_t)*lp);
+       l = htonl((uint32_t)*lp);
        memmove(xdrs->x_private, &l, sizeof(int32_t));
        xdrs->x_private = (char *)xdrs->x_private + sizeof(int32_t);
        return (TRUE);
index 1af279c..2f4c47d 100644 (file)
@@ -104,7 +104,7 @@ static const struct  xdr_ops xdrrec_ops = {
  * meet the needs of xdr and rpc based on tcp.
  */
 
-#define LAST_FRAG ((u_int32_t)(1 << 31))
+#define LAST_FRAG ((uint32_t)(1 << 31))
 
 typedef struct rec_strm {
        char *tcp_handle;
@@ -115,7 +115,7 @@ typedef struct rec_strm {
        char *out_base; /* output buffer (points to frag header) */
        char *out_finger;       /* next output position */
        char *out_boundry;      /* data cannot up to this address */
-       u_int32_t *frag_header; /* beginning of current fragment */
+       uint32_t *frag_header;  /* beginning of current fragment */
        bool_t frag_sent;       /* true if buffer sent in middle of record */
        /*
         * in-coming bits
@@ -132,7 +132,7 @@ typedef struct rec_strm {
 
        bool_t nonblock;
        bool_t in_haveheader;
-       u_int32_t in_header;
+       uint32_t in_header;
        char *in_hdrp;
        int in_hdrlen;
        int in_reclen;
@@ -200,8 +200,8 @@ xdrrec_create(XDR *xdrs, u_int sendsize, u_int recvsize, void *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->frag_header = (uint32_t *)(void *)rstrm->out_base;
+       rstrm->out_finger += sizeof(uint32_t);
        rstrm->out_boundry += sendsize;
        rstrm->frag_sent = FALSE;
        rstrm->in_size = recvsize;
@@ -233,14 +233,14 @@ xdrrec_getlong(XDR *xdrs, long *lp)
        /* 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));
+               *lp = (long)ntohl((uint32_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);
+               *lp = (long)ntohl((uint32_t)mylong);
        }
        return (TRUE);
 }
@@ -263,7 +263,7 @@ xdrrec_putlong(XDR *xdrs, const long *lp)
                dest_lp = ((int32_t *)(void *)(rstrm->out_finger));
                rstrm->out_finger += sizeof(int32_t);
        }
-       *dest_lp = (int32_t)htonl((u_int32_t)(*lp));
+       *dest_lp = (int32_t)htonl((uint32_t)(*lp));
        return (TRUE);
 }
 
@@ -490,16 +490,16 @@ xdrrec_endofrecord(XDR *xdrs, bool_t sendnow)
        u_long len;  /* fragment length */
 
        if (sendnow || rstrm->frag_sent ||
-               ((u_long)rstrm->out_finger + sizeof(u_int32_t) >=
+               ((u_long)rstrm->out_finger + sizeof(uint32_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);
+          sizeof(uint32_t);
+       *(rstrm->frag_header) = htonl((uint32_t)len | LAST_FRAG);
+       rstrm->frag_header = (uint32_t *)(void *)rstrm->out_finger;
+       rstrm->out_finger += sizeof(uint32_t);
        return (TRUE);
 }
 
@@ -605,18 +605,18 @@ __xdrrec_setnonblock(XDR *xdrs, int maxrec)
 static bool_t
 flush_out(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));
+       uint32_t eormask = (eor == TRUE) ? LAST_FRAG : 0;
+       uint32_t len = (uint32_t)((u_long)(rstrm->out_finger) -
+               (u_long)(rstrm->frag_header) - sizeof(uint32_t));
 
        *(rstrm->frag_header) = htonl(len | eormask);
-       len = (u_int32_t)((u_long)(rstrm->out_finger) -
+       len = (uint32_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);
+       rstrm->frag_header = (uint32_t *)(void *)rstrm->out_base;
+       rstrm->out_finger = (char *)rstrm->out_base + sizeof(uint32_t);
        return (TRUE);
 }
 
@@ -624,16 +624,16 @@ static bool_t  /* knows nothing about records!  Only about input buffers */
 fill_input_buf(RECSTREAM *rstrm)
 {
        char *where;
-       u_int32_t i;
+       uint32_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);
+       i = (uint32_t)((u_long)rstrm->in_boundry % BYTES_PER_XDR_UNIT);
        where += i;
-       len = (u_int32_t)(rstrm->in_size - i);
+       len = (uint32_t)(rstrm->in_size - i);
        if ((len = (*(rstrm->readit))(rstrm->tcp_handle, where, len)) == -1)
                return (FALSE);
        rstrm->in_finger = where;
@@ -675,7 +675,7 @@ get_input_bytes(RECSTREAM *rstrm, char *addr, int len)
 static bool_t  /* next two bytes of the input stream are treated as a header */
 set_input_fragment(RECSTREAM *rstrm)
 {
-       u_int32_t header;
+       uint32_t header;
 
        if (rstrm->nonblock)
                return FALSE;
@@ -700,7 +700,7 @@ set_input_fragment(RECSTREAM *rstrm)
 static bool_t  /* consumes input bytes; knows nothing about records! */
 skip_input_bytes(RECSTREAM *rstrm, long cnt)
 {
-       u_int32_t current;
+       uint32_t current;
 
        while (cnt > 0) {
                current = (size_t)((long)rstrm->in_boundry -
@@ -710,7 +710,7 @@ skip_input_bytes(RECSTREAM *rstrm, long cnt)
                                return (FALSE);
                        continue;
                }
-               current = (u_int32_t)((cnt < current) ? cnt : current);
+               current = (uint32_t)((cnt < current) ? cnt : current);
                rstrm->in_finger += current;
                cnt -= current;
        }
index f9f9c63..bfbc5d6 100644 (file)
@@ -104,7 +104,7 @@ xdrstdio_destroy(XDR *xdrs)
 static bool_t
 xdrstdio_getlong(XDR *xdrs, long *lp)
 {
-       u_int32_t temp;
+       uint32_t temp;
 
        if (fread(&temp, sizeof(int32_t), 1, (FILE *)xdrs->x_private) != 1)
                return (FALSE);
@@ -115,7 +115,7 @@ xdrstdio_getlong(XDR *xdrs, long *lp)
 static bool_t
 xdrstdio_putlong(XDR *xdrs, const long *lp)
 {
-       int32_t mycopy = htonl((u_int32_t)*lp);
+       int32_t mycopy = htonl((uint32_t)*lp);
 
        if (fwrite(&mycopy, sizeof(int32_t), 1, (FILE *)xdrs->x_private) != 1)
                return (FALSE);