Changeset dab2d6eb in rtems for cpukit/librpc/src/xdr


Ignore:
Timestamp:
Jan 8, 2005, 6:01:35 AM (16 years ago)
Author:
Ralf Corsepius <ralf.corsepius@…>
Branches:
4.10, 4.11, 4.8, 4.9, 5, master
Children:
21023ab8
Parents:
c9795bd
Message:

2005-01-07 Ralf Corsepius <ralf.corsepius@…>

  • librpc/include/rpc/auth_des.h, librpc/include/rpc/xdr.h, librpc/src/rpc/auth_des.c, librpc/src/rpc/auth_unix.c, librpc/src/rpc/rpc_prot.c, librpc/src/xdr/xdr.c: Misc. ansi-fications, misc. updates from FreeBSD.
File:
1 edited

Legend:

Unmodified
Added
Removed
  • cpukit/librpc/src/xdr/xdr.c

    rc9795bd rdab2d6eb  
    5151#include <rpc/xdr.h>
    5252
     53#if defined(__rtems__)
     54#define warnx(msg) fprintf(stderr, msg "\n");
     55#endif
     56
    5357/*
    5458 * constants specific to the xdr "protocol"
     
    6165 * for unit alignment
    6266 */
    63 static char xdr_zero[BYTES_PER_XDR_UNIT] = { 0, 0, 0, 0 };
     67static const char xdr_zero[BYTES_PER_XDR_UNIT] = { 0, 0, 0, 0 };
    6468
    6569/*
     
    117121                return (TRUE);
    118122        }
     123        /* NOTREACHED */
    119124        return (FALSE);
    120125}
     
    146151                return (TRUE);
    147152        }
     153        /* NOTREACHED */
    148154        return (FALSE);
    149155}
     
    156162bool_t
    157163xdr_long(xdrs, lp)
    158         register XDR *xdrs;
     164        XDR *xdrs;
    159165        long *lp;
    160166{
     
    167173                return (TRUE);
    168174        }
    169 
     175        /* NOTREACHED */
    170176        return (FALSE);
    171177}
     
    177183bool_t
    178184xdr_u_long(xdrs, ulp)
    179         register XDR *xdrs;
     185        XDR *xdrs;
    180186        u_long *ulp;
    181187{
     
    188194                return (TRUE);
    189195        }
     196        /* NOTREACHED */
    190197        return (FALSE);
    191198}
     
    198205bool_t
    199206xdr_int32_t(xdrs, int32_p)
    200         register XDR *xdrs;
     207        XDR *xdrs;
    201208        int32_t *int32_p;
    202209{
     
    219226                return (TRUE);
    220227        }
     228        /* NOTREACHED */
    221229        return (FALSE);
    222230}
     
    228236bool_t
    229237xdr_u_int32_t(xdrs, u_int32_p)
    230         register XDR *xdrs;
     238        XDR *xdrs;
    231239        u_int32_t *u_int32_p;
    232240{
     
    253261
    254262/*
    255  * XDR 64-bit integers
    256  */
    257 bool_t
    258 xdr_int64_t(xdrs, int64_p)
    259         register XDR *xdrs;
    260         int64_t *int64_p;
    261 {
    262         int64_t x;
    263 
    264         switch (xdrs->x_op) {
    265 
    266         case XDR_ENCODE:
    267                 return (xdr_opaque(xdrs, (caddr_t)int64_p, sizeof(int64_t)));
    268 
    269         case XDR_DECODE:
    270                 if (!xdr_opaque(xdrs, (caddr_t)&x, sizeof x)) {
    271                         return (FALSE);
    272                 }
    273                 *int64_p = x;
    274                 return (TRUE);
    275 
    276         case XDR_FREE:
    277                 return (TRUE);
    278         }
    279         return (FALSE);
    280 }
    281 
    282 /*
    283  * XDR unsigned 64-bit integers
    284  */
    285 bool_t
    286 xdr_u_int64_t(xdrs, uint64_p)
    287         register XDR *xdrs;
    288         u_int64_t *uint64_p;
    289 {
    290         u_int64_t x;
    291 
    292         switch (xdrs->x_op) {
    293 
    294         case XDR_ENCODE:
    295                 return (xdr_opaque(xdrs, (caddr_t)uint64_p, sizeof(u_int64_t)));
    296 
    297         case XDR_DECODE:
    298                 if (!xdr_opaque(xdrs, (caddr_t)&x, sizeof x)) {
    299                         return (FALSE);
    300                 }
    301                 *uint64_p = x;
    302                 return (TRUE);
    303 
    304         case XDR_FREE:
    305                 return (TRUE);
    306         }
    307         return (FALSE);
    308 }
    309 
    310 
    311 /*
    312263 * XDR short integers
    313264 */
    314265bool_t
    315266xdr_short(xdrs, sp)
    316         register XDR *xdrs;
     267        XDR *xdrs;
    317268        short *sp;
    318269{
     
    335286                return (TRUE);
    336287        }
     288        /* NOTREACHED */
    337289        return (FALSE);
    338290}
     
    343295bool_t
    344296xdr_u_short(xdrs, usp)
    345         register XDR *xdrs;
     297        XDR *xdrs;
    346298        u_short *usp;
    347299{
     
    364316                return (TRUE);
    365317        }
     318        /* NOTREACHED */
    366319        return (FALSE);
    367320}
     
    373326bool_t
    374327xdr_int16_t(xdrs, int16_p)
    375         register XDR *xdrs;
     328        XDR *xdrs;
    376329        int16_t *int16_p;
    377330{
     
    394347                return (TRUE);
    395348        }
     349        /* NOTREACHED */
    396350        return (FALSE);
    397351}
     
    402356bool_t
    403357xdr_u_int16_t(xdrs, u_int16_p)
    404         register XDR *xdrs;
     358        XDR *xdrs;
    405359        u_int16_t *u_int16_p;
    406360{
     
    423377                return (TRUE);
    424378        }
     379        /* NOTREACHED */
    425380        return (FALSE);
    426381}
     
    468423bool_t
    469424xdr_bool(xdrs, bp)
    470         register XDR *xdrs;
     425        XDR *xdrs;
    471426        bool_t *bp;
    472427{
     
    489444                return (TRUE);
    490445        }
     446        /* NOTREACHED */
    491447        return (FALSE);
    492448}
     
    529485bool_t
    530486xdr_opaque(xdrs, cp, cnt)
    531         register XDR *xdrs;
     487        XDR *xdrs;
    532488        caddr_t cp;
    533         register u_int cnt;
    534 {
    535         register u_int rndup;
     489        u_int cnt;
     490{
     491        u_int rndup;
    536492        static int crud[BYTES_PER_XDR_UNIT];
    537493
     
    581537bool_t
    582538xdr_bytes(xdrs, cpp, sizep, maxsize)
    583         register XDR *xdrs;
     539        XDR *xdrs;
    584540        char **cpp;
    585         register u_int *sizep;
     541        u_int *sizep;
    586542        u_int maxsize;
    587543{
    588         register char *sp = *cpp;  /* sp is the actual string pointer */
    589         register u_int nodesize;
     544        char *sp = *cpp;  /* sp is the actual string pointer */
     545        u_int nodesize;
    590546
    591547        /*
     
    610566                }
    611567                if (sp == NULL) {
    612                         *cpp = sp = (char *)mem_alloc(nodesize);
     568                        *cpp = sp = mem_alloc(nodesize);
    613569                }
    614570                if (sp == NULL) {
    615                         (void) fprintf(stderr, "xdr_bytes: out of memory\n");
    616                         return (FALSE);
    617                 }
    618                 /* fall into ... */
     571                        warnx("xdr_bytes: out of memory");
     572                        return (FALSE);
     573                }
     574                /* FALLTHROUGH */
    619575
    620576        case XDR_ENCODE:
     
    628584                return (TRUE);
    629585        }
     586        /* NOTREACHED */
    630587        return (FALSE);
    631588}
     
    656613bool_t
    657614xdr_union(xdrs, dscmp, unp, choices, dfault)
    658         register XDR *xdrs;
     615        XDR *xdrs;
    659616        enum_t *dscmp;          /* enum to decide which arm to work on */
    660617        char *unp;              /* the union itself */
    661         struct xdr_discrim *choices;    /* [value, xdr proc] for each arm */
     618        const struct xdr_discrim *choices;      /* [value, xdr proc] for each arm */
    662619        xdrproc_t dfault;       /* default xdr routine */
    663620{
    664         register enum_t dscm;
     621        enum_t dscm;
    665622
    666623        /*
     
    705662bool_t
    706663xdr_string(xdrs, cpp, maxsize)
    707         register XDR *xdrs;
     664        XDR *xdrs;
    708665        char **cpp;
    709666        u_int maxsize;
    710667{
    711         register char *sp = *cpp;  /* sp is the actual string pointer */
     668        char *sp = *cpp;  /* sp is the actual string pointer */
    712669        u_int size;
    713670        u_int nodesize;
     
    721678                        return(TRUE);   /* already free */
    722679                }
    723                 /* fall through... */
     680                /* FALLTHROUGH */
    724681        case XDR_ENCODE:
    725682                size = strlen(sp);
    726683                break;
    727         case XDR_DECODE:  /* to avoid warning */
     684        case XDR_DECODE:
    728685                break;
    729686        }
     
    746703                }
    747704                if (sp == NULL)
    748                         *cpp = sp = (char *)mem_alloc(nodesize);
     705                        *cpp = sp = mem_alloc(nodesize);
    749706                if (sp == NULL) {
    750                         (void) fprintf(stderr, "xdr_string: out of memory\n");
     707                        warnx("xdr_string: out of memory");
    751708                        return (FALSE);
    752709                }
    753710                sp[size] = 0;
    754                 /* fall into ... */
     711                /* FALLTHROUGH */
    755712
    756713        case XDR_ENCODE:
     
    762719                return (TRUE);
    763720        }
     721        /* NOTREACHED */
    764722        return (FALSE);
    765723}
     
    776734        return xdr_string(xdrs, cpp, LASTUNSIGNED);
    777735}
     736
     737/*
     738 * XDR 64-bit integers
     739 */
     740bool_t
     741xdr_int64_t(xdrs, int64_p)
     742        XDR *xdrs;
     743        int64_t *int64_p;
     744{
     745        int64_t x;
     746
     747        switch (xdrs->x_op) {
     748        case XDR_ENCODE:
     749                return (xdr_opaque(xdrs, (caddr_t)int64_p, sizeof(int64_t)));
     750        case XDR_DECODE:
     751                if (!xdr_opaque(xdrs, (caddr_t)&x, sizeof x)) {
     752                        return (FALSE);
     753                }
     754                *int64_p = x;
     755                return (TRUE);
     756        case XDR_FREE:
     757                return (TRUE);
     758        }
     759        /* NOTREACHED */
     760        return (FALSE);
     761}
     762
     763
     764/*
     765 * XDR unsigned 64-bit integers
     766 */
     767bool_t
     768xdr_u_int64_t(xdrs, uint64_p)
     769        XDR *xdrs;
     770        u_int64_t *uint64_p;
     771{
     772        u_int64_t x;
     773
     774        switch (xdrs->x_op) {
     775        case XDR_ENCODE:
     776                return (xdr_opaque(xdrs, (caddr_t)uint64_p, sizeof(u_int64_t)));
     777        case XDR_DECODE:
     778                if (!xdr_opaque(xdrs, (caddr_t)&x, sizeof x)) {
     779                        return (FALSE);
     780                }
     781                *uint64_p = x;
     782                return (TRUE);
     783        case XDR_FREE:
     784                return (TRUE);
     785        }
     786        /* NOTREACHED */
     787        return (FALSE);
     788}
     789
     790/* FIXME: RTEMS does not support u_longlong_t and longlong_t, yet */
     791#if !defined(__rtems__)
     792/*
     793 * XDR hypers
     794 */
     795bool_t
     796xdr_hyper(xdrs, llp)
     797        XDR *xdrs;
     798        longlong_t *llp;
     799{
     800
     801        /*
     802         * Don't bother open-coding this; it's a fair amount of code.  Just
     803         * call xdr_int64_t().
     804         */
     805        return (xdr_int64_t(xdrs, (int64_t *)llp));
     806}
     807
     808
     809/*
     810 * XDR unsigned hypers
     811 */
     812bool_t
     813xdr_u_hyper(xdrs, ullp)
     814        XDR *xdrs;
     815        u_longlong_t *ullp;
     816{
     817
     818        /*
     819         * Don't bother open-coding this; it's a fair amount of code.  Just
     820         * call xdr_u_int64_t().
     821         */
     822        return (xdr_u_int64_t(xdrs, (u_int64_t *)ullp));
     823}
     824
     825
     826/*
     827 * XDR longlong_t's
     828 */
     829bool_t
     830xdr_longlong_t(xdrs, llp)
     831        XDR *xdrs;
     832        longlong_t *llp;
     833{
     834
     835        /*
     836         * Don't bother open-coding this; it's a fair amount of code.  Just
     837         * call xdr_int64_t().
     838         */
     839        return (xdr_int64_t(xdrs, (int64_t *)llp));
     840}
     841
     842
     843/*
     844 * XDR u_longlong_t's
     845 */
     846bool_t
     847xdr_u_longlong_t(xdrs, ullp)
     848        XDR *xdrs;
     849        u_longlong_t *ullp;
     850{
     851
     852        /*
     853         * Don't bother open-coding this; it's a fair amount of code.  Just
     854         * call xdr_u_int64_t().
     855         */
     856        return (xdr_u_int64_t(xdrs, (u_int64_t *)ullp));
     857}
     858#endif
Note: See TracChangeset for help on using the changeset viewer.