Changeset dab2d6eb in rtems for cpukit/librpc


Ignore:
Timestamp:
Jan 8, 2005, 6:01:35 AM (15 years ago)
Author:
Ralf Corsepius <ralf.corsepius@…>
Branches:
4.10, 4.11, 4.8, 4.9, 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.
Location:
cpukit/librpc
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • cpukit/librpc/include/rpc/auth_des.h

    rc9795bd rdab2d6eb  
    104104
    105105__BEGIN_DECLS
    106 extern int authdes_getucred __P(( struct authdes_cred *, uid_t *, gid_t *, int *, gid_t * ));
     106extern int authdes_getucred ( struct authdes_cred *, uid_t *, gid_t *, int *, gid_t * );
    107107__END_DECLS
    108108
  • cpukit/librpc/include/rpc/xdr.h

    rc9795bd rdab2d6eb  
     1/*      $NetBSD: xdr.h,v 1.19 2000/07/17 05:00:45 matt Exp $    */
     2
    13/*
    24 * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
     
    2931 *      from: @(#)xdr.h 1.19 87/04/22 SMI
    3032 *      from: @(#)xdr.h 2.2 88/07/29 4.0 RPCSRC
    31  * $FreeBSD: src/include/rpc/xdr.h,v 1.14 1999/12/29 05:00:44 peter Exp $
     33 * $FreeBSD: src/include/rpc/xdr.h,v 1.23 2003/03/07 13:19:40 nectar Exp $
    3234 */
    3335
     
    100102        struct xdr_ops {
    101103                /* get a long from underlying stream */
    102                 bool_t  (*x_getlong) (struct __rpc_xdr *, long *);
     104                bool_t  (*x_getlong)(struct __rpc_xdr *, long *);
    103105                /* put a long to underlying stream */
    104                 bool_t  (*x_putlong) (struct __rpc_xdr *, long *);
     106                bool_t  (*x_putlong)(struct __rpc_xdr *, const long *);
    105107                /* get some bytes from underlying stream */
    106                 bool_t  (*x_getbytes) (struct __rpc_xdr *, caddr_t, u_int);
     108                bool_t  (*x_getbytes)(struct __rpc_xdr *, char *, u_int);
    107109                /* put some bytes to underlying stream */
    108                 bool_t  (*x_putbytes) (struct __rpc_xdr *, caddr_t, u_int);
     110                bool_t  (*x_putbytes)(struct __rpc_xdr *, const char *, u_int);
    109111                /* returns bytes off from beginning */
    110                 u_int   (*x_getpostn) (struct __rpc_xdr *);
     112                u_int   (*x_getpostn)(struct __rpc_xdr *);
    111113                /* lets you reposition the stream */
    112                 bool_t  (*x_setpostn) (struct __rpc_xdr *, u_int);
     114                bool_t  (*x_setpostn)(struct __rpc_xdr *, u_int);
    113115                /* buf quick ptr to buffered data */
    114                 int32_t *(*x_inline) (struct __rpc_xdr *, u_int);
     116                int32_t *(*x_inline)(struct __rpc_xdr *, u_int);
    115117                /* free privates of this xdr_stream */
    116                 void    (*x_destroy) (struct __rpc_xdr *);
     118                void    (*x_destroy)(struct __rpc_xdr *);
    117119        } *x_ops;
    118         caddr_t         x_public;       /* users' data */
    119         caddr_t         x_private;      /* pointer to private data */
    120         caddr_t         x_base;         /* private used for position info */
    121         int             x_handy;        /* extra private word */
     120        char *          x_public;       /* users' data */
     121        void *          x_private;      /* pointer to private data */
     122        char *          x_base;         /* private used for position info */
     123        u_int           x_handy;        /* extra private word */
    122124} XDR;
    123125
     
    186188 * Support struct for discriminated unions.
    187189 * You create an array of xdrdiscrim structures, terminated with
    188  * a entry with a null procedure pointer.  The xdr_union routine gets
     190 * an entry with a null procedure pointer.  The xdr_union routine gets
    189191 * the discriminant value and then searches the array of structures
    190192 * for a matching value.  If a match is found the associated xdr routine
     
    233235 */
    234236__BEGIN_DECLS
    235 extern bool_t   xdr_void        (void);
    236 extern bool_t   xdr_int         (XDR *, int *);
    237 extern bool_t   xdr_u_int       (XDR *, u_int *);
    238 extern bool_t   xdr_long        (XDR *, long *);
    239 extern bool_t   xdr_u_long      (XDR *, u_long *);
    240 extern bool_t   xdr_short       (XDR *, short *);
    241 extern bool_t   xdr_u_short     (XDR *, u_short *);
    242 extern bool_t   xdr_int16_t     (XDR *, int16_t *);
    243 extern bool_t   xdr_u_int16_t   (XDR *, u_int16_t *);
    244 extern bool_t   xdr_int32_t     (XDR *, int32_t *);
    245 extern bool_t   xdr_u_int32_t   (XDR *, u_int32_t *);
    246 extern bool_t   xdr_int64_t     (XDR *, int64_t *);
    247 extern bool_t   xdr_u_int64_t   (XDR *, u_int64_t *);
    248 extern bool_t   xdr_bool        (XDR *, bool_t *);
    249 extern bool_t   xdr_enum        (XDR *, enum_t *);
    250 extern bool_t   xdr_array       (XDR *, char **, u_int *, u_int, u_int, xdrproc_t);
    251 extern bool_t   xdr_bytes       (XDR *, char **, u_int *, u_int);
    252 extern bool_t   xdr_opaque      (XDR *, caddr_t, u_int);
    253 extern bool_t   xdr_string      (XDR *, char **, u_int);
    254 extern bool_t   xdr_union       (XDR *, enum_t *, char *, struct xdr_discrim *, xdrproc_t);
     237extern bool_t   xdr_void(void);
     238extern bool_t   xdr_int(XDR *, int *);
     239extern bool_t   xdr_u_int(XDR *, u_int *);
     240extern bool_t   xdr_long(XDR *, long *);
     241extern bool_t   xdr_u_long(XDR *, u_long *);
     242extern bool_t   xdr_short(XDR *, short *);
     243extern bool_t   xdr_u_short(XDR *, u_short *);
     244extern bool_t   xdr_int16_t(XDR *, int16_t *);
     245extern bool_t   xdr_u_int16_t(XDR *, u_int16_t *);
     246extern bool_t   xdr_int32_t(XDR *, int32_t *);
     247extern bool_t   xdr_u_int32_t(XDR *, u_int32_t *);
     248extern bool_t   xdr_int64_t(XDR *, int64_t *);
     249extern bool_t   xdr_u_int64_t(XDR *, u_int64_t *);
     250extern bool_t   xdr_bool(XDR *, bool_t *);
     251extern bool_t   xdr_enum(XDR *, enum_t *);
     252extern bool_t   xdr_array(XDR *, char **, u_int *, u_int, u_int, xdrproc_t);
     253extern bool_t   xdr_bytes(XDR *, char **, u_int *, u_int);
     254extern bool_t   xdr_opaque(XDR *, caddr_t, u_int);
     255extern bool_t   xdr_string(XDR *, char **, u_int);
     256extern bool_t   xdr_union(XDR *, enum_t *, char *, const struct xdr_discrim *, xdrproc_t);
    255257extern unsigned long    xdr_sizeof (xdrproc_t, void *);
    256 extern bool_t   xdr_char        (XDR *, char *);
    257 extern bool_t   xdr_u_char      (XDR *, u_char *);
    258 extern bool_t   xdr_vector      (XDR *, char *, u_int, u_int, xdrproc_t);
    259 extern bool_t   xdr_float       (XDR *, float *);
    260 extern bool_t   xdr_double      (XDR *, double *);
    261 extern bool_t   xdr_reference   (XDR *, caddr_t *, u_int, xdrproc_t);
    262 extern bool_t   xdr_pointer     (XDR *, caddr_t *, u_int, xdrproc_t);
    263 extern bool_t   xdr_wrapstring  (XDR *, char **);
    264 extern void     xdr_free        (xdrproc_t, char *);
     258extern bool_t   xdr_char(XDR *, char *);
     259extern bool_t   xdr_u_char(XDR *, u_char *);
     260extern bool_t   xdr_vector(XDR *, char *, u_int, u_int, xdrproc_t);
     261extern bool_t   xdr_float(XDR *, float *);
     262extern bool_t   xdr_double(XDR *, double *);
     263extern bool_t   xdr_reference(XDR *, caddr_t *, u_int, xdrproc_t);
     264extern bool_t   xdr_pointer(XDR *, caddr_t *, u_int, xdrproc_t);
     265extern bool_t   xdr_wrapstring(XDR *, char **);
     266extern void     xdr_free(xdrproc_t, char *);
    265267__END_DECLS
    266268
     
    275277};
    276278typedef struct netobj netobj;
    277 extern bool_t   xdr_netobj (XDR *, struct netobj *);
     279extern bool_t   xdr_netobj(XDR *, struct netobj *);
    278280
    279281/*
     
    283285__BEGIN_DECLS
    284286/* XDR using memory buffers */
    285 extern void   xdrmem_create     (XDR *, char *, u_int, enum xdr_op);
    286 
     287extern void   xdrmem_create(XDR *, char *, u_int, enum xdr_op);
     288
     289/* XDR using stdio library */
    287290#ifdef _STDIO_H_
    288 /* XDR using stdio library */
    289 extern void   xdrstdio_create   (XDR *, FILE *, enum xdr_op);
     291extern void   xdrstdio_create(XDR *, FILE *, enum xdr_op);
    290292#endif
    291293
    292294/* XDR pseudo records for tcp */
    293 extern void   xdrrec_create     (XDR *, u_int, u_int, char *,
     295extern void   xdrrec_create(XDR *, u_int, u_int, char *,
    294296                                int (*) (caddr_t, caddr_t, int),
    295297                                int (*) (caddr_t, caddr_t, int));
    296298
    297299/* make end of xdr record */
    298 extern bool_t xdrrec_endofrecord (XDR *, bool_t);
     300extern bool_t xdrrec_endofrecord(XDR *, bool_t);
    299301
    300302/* move to beginning of next record */
    301 extern bool_t xdrrec_skiprecord (XDR *);
     303extern bool_t xdrrec_skiprecord(XDR *);
    302304
    303305/* true if no more input */
    304 extern bool_t xdrrec_eof        (XDR *);
     306extern bool_t xdrrec_eof(XDR *);
    305307__END_DECLS
    306308
  • cpukit/librpc/src/rpc/auth_des.c

    rc9795bd rdab2d6eb  
    5252#endif
    5353
    54 extern bool_t __rpc_get_time_offset __P(( struct timeval *, nis_server *,
    55                                                 char *, char **, struct sockaddr_in * ));
    56 extern int rtime __P(( struct sockaddr_in *, struct timeval *, struct timeval *));
    57 extern bool_t xdr_authdes_cred __P(( XDR *, struct authdes_cred * ));
    58 extern bool_t xdr_authdes_verf __P(( XDR *, struct authdes_verf * ));
    59 
    60 #define MILLION         1000000L
     54#define USEC_PER_SEC            1000000L
    6155#define RTIME_TIMEOUT 5         /* seconds to wait for sync */
    6256
     
    6660#define ATTEMPT(xdr_op)         if (!(xdr_op)) return (FALSE)
    6761
     62extern int rtime( struct sockaddr_in *, struct timeval *, struct timeval *);
     63extern bool_t xdr_authdes_cred(XDR *, struct authdes_cred *);
     64extern bool_t xdr_authdes_verf(XDR *, struct authdes_verf *);
     65
     66extern bool_t __rpc_get_time_offset( struct timeval *, nis_server *, char *,
     67        char **, struct sockaddr_in * );
    6868#define debug(msg)               /*printf("%s\n", msg) */
    6969
     
    7171 * DES authenticator operations vector
    7272 */
    73 static void     authdes_nextverf();
    74 static bool_t   authdes_marshal();
    75 static bool_t   authdes_validate();
    76 static bool_t   authdes_refresh();
    77 static void     authdes_destroy();
     73static void     authdes_nextverf(AUTH *);
     74static bool_t   authdes_marshal(AUTH *, XDR *);
     75static bool_t   authdes_validate(AUTH *, struct opaque_auth *);
     76static bool_t   authdes_refresh(AUTH *);
     77static void     authdes_destroy(AUTH *);
    7878static struct auth_ops authdes_ops = {
    7979        authdes_nextverf,
     
    314314/*ARGSUSED*/
    315315static void
    316 authdes_nextverf(auth)
    317         AUTH *auth;
     316authdes_nextverf(AUTH *auth)
    318317{
    319318        /* what the heck am I supposed to do??? */
     
    326325 */
    327326static bool_t
    328 authdes_marshal(auth, xdrs)
    329         AUTH *auth;
    330         XDR *xdrs;
     327authdes_marshal(AUTH *auth, XDR *xdrs)
    331328{
    332329        struct ad_private *ad = AUTH_PRIVATE(auth);
     
    346343        ad->ad_timestamp.tv_sec += ad->ad_timediff.tv_sec;
    347344        ad->ad_timestamp.tv_usec += ad->ad_timediff.tv_usec;
    348         if (ad->ad_timestamp.tv_usec >= MILLION) {
    349                 ad->ad_timestamp.tv_usec -= MILLION;
     345        if (ad->ad_timestamp.tv_usec >= USEC_PER_SEC) {
     346                ad->ad_timestamp.tv_usec -= USEC_PER_SEC;
    350347                ad->ad_timestamp.tv_sec += 1;
    351348        }
     
    417414 */
    418415static bool_t
    419 authdes_validate(auth, rverf)
    420         AUTH *auth;
    421         struct opaque_auth *rverf;
     416authdes_validate(AUTH *auth, struct opaque_auth *rverf)
    422417{
    423418        struct ad_private *ad = AUTH_PRIVATE(auth);
     
    473468 */
    474469static bool_t
    475 authdes_refresh(auth)
    476         AUTH *auth;
     470authdes_refresh(AUTH *auth)
    477471{
    478472        struct ad_private *ad = AUTH_PRIVATE(auth);
     
    513507 */
    514508static void
    515 authdes_destroy(auth)
    516         AUTH *auth;
     509authdes_destroy(AUTH *auth)
    517510{
    518511        struct ad_private *ad = AUTH_PRIVATE(auth);
     
    547540        if (mytime.tv_usec > timep->tv_usec) {
    548541                timep->tv_sec -= 1;
    549                 timep->tv_usec += MILLION;
     542                timep->tv_usec += USEC_PER_SEC;
    550543        }
    551544        timep->tv_usec -= mytime.tv_usec;
  • cpukit/librpc/src/rpc/auth_unix.c

    rc9795bd rdab2d6eb  
    6060 * Unix authenticator operations vector
    6161 */
    62 static void     authunix_nextverf();
    63 static bool_t   authunix_marshal();
    64 static bool_t   authunix_validate();
    65 static bool_t   authunix_refresh();
    66 static void     authunix_destroy();
     62static void     authunix_nextverf(AUTH*);
     63static bool_t   authunix_marshal(AUTH*, XDR*);
     64static bool_t   authunix_validate(AUTH*, struct opaque_auth *);
     65static bool_t   authunix_refresh(AUTH*);
     66static void     authunix_destroy(AUTH*);
    6767
    6868static struct auth_ops auth_unix_ops = {
     
    110110        int uid;
    111111        int gid;
    112         register int len;
     112        int len;
    113113        int *aup_gids;
    114114{
     
    219219
    220220static void
    221 authunix_nextverf(auth)
    222         AUTH *auth;
     221authunix_nextverf(AUTH *auth)
    223222{
    224223        /* no action necessary */
     
    226225
    227226static bool_t
    228 authunix_marshal(auth, xdrs)
    229         AUTH *auth;
    230         XDR *xdrs;
    231 {
    232         register struct audata *au = AUTH_PRIVATE(auth);
     227authunix_marshal(AUTH *auth, XDR *xdrs)
     228{
     229        struct audata *au = AUTH_PRIVATE(auth);
    233230
    234231        return (XDR_PUTBYTES(xdrs, au->au_marshed, au->au_mpos));
     
    236233
    237234static bool_t
    238 authunix_validate(auth, verf)
    239         register AUTH *auth;
    240         struct opaque_auth verf;
     235authunix_validate( AUTH *auth, struct opaque_auth *verf )
    241236{
    242237        register struct audata *au;
    243238        XDR xdrs;
    244239
    245         if (verf.oa_flavor == AUTH_SHORT) {
     240        if (verf->oa_flavor == AUTH_SHORT) {
    246241                au = AUTH_PRIVATE(auth);
    247                 xdrmem_create(&xdrs, verf.oa_base, verf.oa_length, XDR_DECODE);
     242                xdrmem_create(&xdrs, verf->oa_base, verf->oa_length, XDR_DECODE);
    248243
    249244                if (au->au_shcred.oa_base != NULL) {
     
    266261
    267262static bool_t
    268 authunix_refresh(auth)
    269         register AUTH *auth;
    270 {
    271         register struct audata *au = AUTH_PRIVATE(auth);
     263authunix_refresh(AUTH *auth)
     264{
     265        struct audata *au = AUTH_PRIVATE(auth);
    272266        struct authunix_parms aup;
    273267        struct timeval now;
    274268        XDR xdrs;
    275         register int stat;
     269        int stat;
    276270
    277271        if (auth->ah_cred.oa_base == au->au_origcred.oa_base) {
     
    309303
    310304static void
    311 authunix_destroy(auth)
    312         register AUTH *auth;
    313 {
    314         register struct audata *au = AUTH_PRIVATE(auth);
     305authunix_destroy(AUTH *auth)
     306{
     307        struct audata *au = AUTH_PRIVATE(auth);
    315308
    316309        mem_free(au->au_origcred.oa_base, au->au_origcred.oa_length);
     
    332325 */
    333326static void
    334 marshal_new_auth(auth)
    335         register AUTH *auth;
     327marshal_new_auth(AUTH *auth)
    336328{
    337329        XDR             xdr_stream;
    338         register XDR    *xdrs = &xdr_stream;
    339         register struct audata *au = AUTH_PRIVATE(auth);
     330        XDR     *xdrs = &xdr_stream;
     331        struct audata *au = AUTH_PRIVATE(auth);
    340332
    341333        xdrmem_create(xdrs, au->au_marshed, MAX_AUTH_BYTES, XDR_ENCODE);
  • cpukit/librpc/src/rpc/rpc_prot.c

    rc9795bd rdab2d6eb  
    5151#include <rpc/rpc.h>
    5252
     53static void accepted(enum accept_stat, struct rpc_err *);
     54static void rejected(enum reject_stat, struct rpc_err *);
     55
    5356/* * * * * * * * * * * * * * XDR Authentication * * * * * * * * * * * */
    5457
    55 struct opaque_auth _null_auth;
     58extern struct opaque_auth _null_auth;
    5659
    5760/*
     
    6164bool_t
    6265xdr_opaque_auth(xdrs, ap)
    63         register XDR *xdrs;
    64         register struct opaque_auth *ap;
     66        XDR *xdrs;
     67        struct opaque_auth *ap;
    6568{
    6669
     
    7679bool_t
    7780xdr_des_block(xdrs, blkp)
    78         register XDR *xdrs;
    79         register des_block *blkp;
     81        XDR *xdrs;
     82        des_block *blkp;
    8083{
    8184        return (xdr_opaque(xdrs, (caddr_t)blkp, sizeof(des_block)));
     
    8992bool_t
    9093xdr_accepted_reply(xdrs, ar)
    91         register XDR *xdrs;
    92         register struct accepted_reply *ar;
     94        XDR *xdrs;
     95        struct accepted_reply *ar;
    9396{
    9497
     
    107110                        return (FALSE);
    108111                return (xdr_u_int32_t(xdrs, &(ar->ar_vers.high)));
    109         default:
     112
     113        case GARBAGE_ARGS:
     114        case SYSTEM_ERR:
     115        case PROC_UNAVAIL:
     116        case PROG_UNAVAIL:
     117/*      default: */
    110118                break;
    111119        }
     
    118126bool_t
    119127xdr_rejected_reply(xdrs, rr)
    120         register XDR *xdrs;
    121         register struct rejected_reply *rr;
     128        XDR *xdrs;
     129        struct rejected_reply *rr;
    122130{
    123131
     
    138146}
    139147
    140 static struct xdr_discrim reply_dscrm[3] = {
    141         { (int)MSG_ACCEPTED, xdr_accepted_reply },
    142         { (int)MSG_DENIED, xdr_rejected_reply },
     148static const struct xdr_discrim reply_dscrm[3] = {
     149        { (int)MSG_ACCEPTED, (xdrproc_t)xdr_accepted_reply },
     150        { (int)MSG_DENIED, (xdrproc_t)xdr_rejected_reply },
    143151        { __dontcare__, NULL_xdrproc_t } };
    144152
     
    148156bool_t
    149157xdr_replymsg(xdrs, rmsg)
    150         register XDR *xdrs;
    151         register struct rpc_msg *rmsg;
     158        XDR *xdrs;
     159        struct rpc_msg *rmsg;
    152160{
    153161        if (
     
    168176bool_t
    169177xdr_callhdr(xdrs, cmsg)
    170         register XDR *xdrs;
    171         register struct rpc_msg *cmsg;
     178        XDR *xdrs;
     179        struct rpc_msg *cmsg;
    172180{
    173181
     
    188196static void
    189197accepted(acpt_stat, error)
    190         register enum accept_stat acpt_stat;
    191         register struct rpc_err *error;
     198        enum accept_stat acpt_stat;
     199        struct rpc_err *error;
    192200{
    193201
     
    226234static void
    227235rejected(rjct_stat, error)
    228         register enum reject_stat rjct_stat;
    229         register struct rpc_err *error;
     236        enum reject_stat rjct_stat;
     237        struct rpc_err *error;
    230238{
    231239
     
    253261void
    254262_seterr_reply(msg, error)
    255         register struct rpc_msg *msg;
    256         register struct rpc_err *error;
     263        struct rpc_msg *msg;
     264        struct rpc_err *error;
    257265{
    258266
     
    264272                        error->re_status = RPC_SUCCESS;
    265273                        return;
    266                 };
     274                }
    267275                accepted(msg->acpted_rply.ar_stat, error);
    268276                break;
     
    292300                error->re_vers.high = msg->acpted_rply.ar_vers.high;
    293301                break;
     302
     303        case RPC_FAILED:
     304        case RPC_SUCCESS:
     305        case RPC_PROGNOTREGISTERED:
     306        case RPC_PMAPFAILURE:
     307        case RPC_UNKNOWNPROTO:
     308        case RPC_UNKNOWNHOST:
     309        case RPC_SYSTEMERROR:
     310        case RPC_CANTDECODEARGS:
     311        case RPC_PROCUNAVAIL:
     312        case RPC_PROGUNAVAIL:
     313        case RPC_TIMEDOUT:
     314        case RPC_CANTRECV:
     315        case RPC_CANTSEND:
     316        case RPC_CANTDECODERES:
     317        case RPC_CANTENCODEARGS:
    294318        default:
    295319                break;
  • 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.