src/fsint/afsaux.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #include <afsconfig.h>
  11 #ifdef KERNEL
  12 #include "afs/param.h"
  13 #else
  14 #include <afs/param.h>
  15 #endif
  16
  17 RCSID("$Header$");
  18
  19 #ifdef KERNEL
  20 #if defined(UKERNEL)
  21 #include "afs/sysincludes.h"
  22 #include "afsincludes.h"
  23 #include "rx/xdr.h"
  24 #else /* defined(UKERNEL) */
  25 #if defined(AFS_ALPHA_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
  26 #include "afs/sysincludes.h"
  27 #include "afsincludes.h"
  28 #else
  29 #include "h/types.h"
  30 #include "rpc/types.h"
  31 #include "rx/xdr.h"
  32 #endif
  33 #if !defined(AFS_ALPHA_ENV)
  34 #ifndef XDR_GETINT32
  35 #define XDR_GETINT32    XDR_GETLONG
  36 #endif
  37 #ifndef XDR_PUTINT32
  38 #define XDR_PUTINT32    XDR_PUTLONG
  39 #endif
  40 #endif
  41 #endif /* defined(UKERNEL) */
  42 #include "afsint.h"
  43 #else /* KERNEL */
  44 # include <rx/xdr.h>
  45 # include "afsint.h"
  46 #endif /* KERNEL */
  47
  48 #ifdef KERNEL
  49 #define NVALLOC(a)      osi_Alloc(a)
  50 #define NVFREE(a,b)     osi_Free(a,b)
  51 #else /* KERNEL */
  52 #define MAXBS   2048            /* try to avoid horrible allocs */
  53 static afs_int32 bslosers = 0;
  54 #define NVALLOC(a)      malloc(a)
  55 #define NVFREE(a,b)     free(a)
  56 #endif /* KERNEL */
  57
  58 /* these things are defined in R (but not RX's) library.  For now, we add them
  59     only for the kernel system.  Later, when R is expunged, we'll remove the ifdef */
  60 #ifdef KERNEL
  61 #ifndef AFS_USR_DARWIN_ENV
  62 #ifdef  AFS_AIXNFS11
  63 #define AUTH_DES 1
  64 #endif
  65 #if (defined(AFS_AIX_ENV) && !defined(AUTH_DES)) || (!defined(AFS_SUN_ENV)) && !defined(AFS_SGI_ENV) && !defined(AFS_ALPHA_ENV) && !defined(AFS_SUN5_ENV)
  66 #ifndef AFS_AIX32_ENV
  67 #if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_XBSD_ENV)
  68 /*
  69  * XDR chars; from user mode xdr package.
  70  */
  71 bool_t xdr_char(register XDR *xdrs, char *sp)
  72 {
  73         afs_int32 l;
  74
  75         switch (xdrs->x_op) {
  76
  77         case XDR_ENCODE:
  78                 l = (afs_int32) *sp;
  79                 return (XDR_PUTINT32(xdrs, &l));
  80
  81         case XDR_DECODE:
  82                 if (!XDR_GETINT32(xdrs, &l)) {
  83                         return (FALSE);
  84                 }
  85                 *sp = (char) l;
  86                 return (TRUE);
  87
  88         case XDR_FREE:
  89                 return (TRUE);
  90         }
  91         return (FALSE);
  92 }
  93 #endif /* AFS_HPUX110_ENV && AFS_LINUX20_ENV */
  94 #endif
  95 #endif /* defined(AFS_AIX_ENV) && !defined(AUTH_DES) */
  96
  97
  98 /*
  99  * Wrapper for xdr_string that can be called directly from
 100  * routines like clnt_call; from user-mode xdr package.
 101  */
 102 #ifndef AFS_SUN5_ENV
 103 #ifndef AFS_HPUX110_ENV
 104 bool_t xdr_wrapstring(XDR *xdrs, char **cpp)
 105 {
 106         if (xdr_string(xdrs, cpp, 1024)) {
 107                 return(TRUE);
 108         }
 109         return(FALSE);
 110 }
 111 #endif /* AFS_HPUX110_ENV */
 112 #endif /* AFS_SUN5_ENV */
 113
 114 /*
 115  * xdr_vector():
 116  *
 117  * XDR a fixed length array. Unlike variable-length arrays,
 118  * the storage of fixed length arrays is static and unfreeable.
 119  * > basep: base of the array
 120  * > size: size of the array
 121  * > elemsize: size of each element
 122  * > xdr_elem: routine to XDR each element
 123  */
 124 bool_t xdr_vector(register XDR *xdrs, register char *basep,
 125         register u_int nelem, register u_int elemsize, register xdrproc_t xdr_elem)
 126 {
 127         register u_int i;
 128         register char *elptr;
 129
 130         elptr = basep;
 131         for (i = 0; i < nelem; i++) {
 132                 if (! (*xdr_elem)(xdrs, elptr, (u_int) (~0))) {
 133                         return(FALSE);
 134                 }
 135                 elptr += elemsize;
 136         }
 137         return(TRUE);
 138 }
 139 #endif
 140 #endif /* KERNEL */
 141
 142 #ifndef KERNEL
 143 bool_t xdr_CBS(XDR *x, struct CBS *abbs)
 144 {
 145     afs_int32 len;
 146     if (x->x_op == XDR_FREE) {
 147         NVFREE(abbs->SeqBody,abbs->SeqLen);
 148         return TRUE;
 149     }
 150
 151     if (x->x_op == XDR_ENCODE) {
 152         xdr_afs_int32(x, &abbs->SeqLen);
 153         xdr_opaque(x, abbs->SeqBody, abbs->SeqLen);
 154         return TRUE;
 155     }
 156     else {
 157         xdr_afs_int32(x, &len);
 158         if (len < 0 || len > MAXBS) {bslosers++; return FALSE;}
 159         if (!abbs->SeqBody) abbs->SeqBody = (char *) NVALLOC(len);
 160         abbs->SeqLen = len;
 161         xdr_opaque(x, abbs->SeqBody, len);
 162         return TRUE;
 163     }
 164 }
 165
 166 bool_t xdr_BBS(XDR *x, struct BBS *abbs)
 167 {
 168     afs_int32 maxLen, len;
 169     if (x->x_op == XDR_FREE) {
 170         NVFREE(abbs->SeqBody, abbs->MaxSeqLen);
 171         return TRUE;
 172     }
 173
 174     if (x->x_op == XDR_ENCODE) {
 175         xdr_afs_int32(x, &abbs->MaxSeqLen);
 176         xdr_afs_int32(x, &abbs->SeqLen);
 177         xdr_opaque(x, abbs->SeqBody, abbs->SeqLen);
 178         return TRUE;
 179     }
 180     else {
 181         xdr_afs_int32(x, &maxLen);
 182         xdr_afs_int32(x, &len);
 183         if (len < 0 || len > MAXBS || len > maxLen) {bslosers++; return FALSE;}
 184         if (!abbs->SeqBody) abbs->SeqBody = (char *) NVALLOC(maxLen);
 185         abbs->MaxSeqLen = maxLen;
 186         abbs->SeqLen = len;
 187         xdr_opaque(x, abbs->SeqBody, len);
 188         return TRUE;
 189     }
 190 }
 191
 192 bool_t xdr_AFSAccessList(XDR *x, AFSAccessList *abbs)
 193 {
 194     afs_int32 maxLen, len;
 195     if (x->x_op == XDR_FREE) {
 196         NVFREE(abbs->SeqBody, abbs->MaxSeqLen);
 197         return TRUE;
 198     }
 199
 200     if (x->x_op == XDR_ENCODE) {
 201         xdr_afs_int32(x, &abbs->MaxSeqLen);
 202         xdr_afs_int32(x, &abbs->SeqLen);
 203         xdr_opaque(x, abbs->SeqBody, abbs->SeqLen);
 204         return TRUE;
 205     }
 206     else {
 207         xdr_afs_int32(x, &maxLen);
 208         xdr_afs_int32(x, &len);
 209         if (len < 0 || len > MAXBS || len > maxLen) {bslosers++; return FALSE;}
 210         if (!abbs->SeqBody) abbs->SeqBody = (char *) NVALLOC(maxLen);
 211         abbs->MaxSeqLen = maxLen;
 212         abbs->SeqLen = len;
 213         xdr_opaque(x, abbs->SeqBody, len);
 214         return TRUE;
 215     }
 216 }
 217 #endif /* KERNEL */