1f6473b2732613927badc74af2e7fd56f81866fd
[openafs.git] / 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 */