Use xdr_alloc and xdr_free within ptuser
[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
18 #ifdef KERNEL
19 #if defined(UKERNEL)
20 #include "afs/sysincludes.h"
21 #include "afsincludes.h"
22 #include "rx/xdr.h"
23 #else /* defined(UKERNEL) */
24 #if defined(AFS_OSF_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
25 #include "afs/sysincludes.h"
26 #include "afsincludes.h"
27 #else
28 #include "h/types.h"
29 #include "rpc/types.h"
30 #include "rx/xdr.h"
31 #endif
32 #if !defined(AFS_ALPHA_ENV)
33 #ifndef XDR_GETINT32
34 #define XDR_GETINT32    XDR_GETLONG
35 #endif
36 #ifndef XDR_PUTINT32
37 #define XDR_PUTINT32    XDR_PUTLONG
38 #endif
39 #endif
40 #endif /* defined(UKERNEL) */
41 #include "afsint.h"
42 #else /* KERNEL */
43 # include <rx/xdr.h>
44 # include "afsint.h"
45 #endif /* KERNEL */
46
47 #ifdef KERNEL
48 #define NVALLOC(a)      osi_Alloc(a)
49 #define NVFREE(a,b)     osi_Free(a,b)
50 #else /* KERNEL */
51 #define MAXBS   2048            /* try to avoid horrible allocs */
52 static afs_int32 bslosers = 0;
53 #define NVALLOC(a)      malloc(a)
54 #define NVFREE(a,b)     free(a)
55 #endif /* KERNEL */
56
57 /* these things are defined in R (but not RX's) library.  For now, we add them
58     only for the kernel system.  Later, when R is expunged, we'll remove the ifdef */
59 #ifdef KERNEL
60 #ifndef AFS_USR_DARWIN_ENV
61 #ifdef  AFS_AIXNFS11
62 #define AUTH_DES 1
63 #endif
64 /* 
65  * Wrapper for xdr_string that can be called directly from 
66  * routines like clnt_call; from user-mode xdr package.
67  */
68 #ifndef AFS_SUN5_ENV
69 #ifndef AFS_HPUX110_ENV
70 bool_t
71 xdr_wrapstring(XDR * xdrs, char **cpp)
72 {
73     if (xdr_string(xdrs, cpp, 1024)) {
74         return (TRUE);
75     }
76     return (FALSE);
77 }
78 #endif /* AFS_HPUX110_ENV */
79 #endif /* AFS_SUN5_ENV */
80
81 /*
82  * xdr_vector():
83  *
84  * XDR a fixed length array. Unlike variable-length arrays,
85  * the storage of fixed length arrays is static and unfreeable.
86  * > basep: base of the array
87  * > size: size of the array
88  * > elemsize: size of each element
89  * > xdr_elem: routine to XDR each element
90  */
91 bool_t
92 xdr_vector(register XDR * xdrs, register char *basep, register u_int nelem,
93            register u_int elemsize, register xdrproc_t xdr_elem)
94 {
95     register u_int i;
96     register char *elptr;
97
98     elptr = basep;
99     for (i = 0; i < nelem; i++) {
100         if (!(*xdr_elem) (xdrs, elptr, (u_int) (~0))) {
101             return (FALSE);
102         }
103         elptr += elemsize;
104     }
105     return (TRUE);
106 }
107 #endif
108 #endif /* KERNEL */
109
110 #ifndef KERNEL
111 bool_t
112 xdr_CBS(XDR * x, struct CBS * abbs)
113 {
114     afs_int32 len;
115     if (x->x_op == XDR_FREE) {
116         NVFREE(abbs->SeqBody, abbs->SeqLen);
117         return TRUE;
118     }
119
120     if (x->x_op == XDR_ENCODE) {
121         xdr_afs_int32(x, &abbs->SeqLen);
122         xdr_opaque(x, abbs->SeqBody, abbs->SeqLen);
123         return TRUE;
124     } else {
125         xdr_afs_int32(x, &len);
126         if (len < 0 || len > MAXBS) {
127             bslosers++;
128             return FALSE;
129         }
130         if (!abbs->SeqBody)
131             abbs->SeqBody = (char *)NVALLOC(len);
132         abbs->SeqLen = len;
133         xdr_opaque(x, abbs->SeqBody, len);
134         return TRUE;
135     }
136 }
137
138 bool_t
139 xdr_BBS(XDR * x, struct BBS * abbs)
140 {
141     afs_int32 maxLen, len;
142     if (x->x_op == XDR_FREE) {
143         NVFREE(abbs->SeqBody, abbs->MaxSeqLen);
144         return TRUE;
145     }
146
147     if (x->x_op == XDR_ENCODE) {
148         xdr_afs_int32(x, &abbs->MaxSeqLen);
149         xdr_afs_int32(x, &abbs->SeqLen);
150         xdr_opaque(x, abbs->SeqBody, abbs->SeqLen);
151         return TRUE;
152     } else {
153         xdr_afs_int32(x, &maxLen);
154         xdr_afs_int32(x, &len);
155         if (len < 0 || len > MAXBS || len > maxLen) {
156             bslosers++;
157             return FALSE;
158         }
159         if (!abbs->SeqBody)
160             abbs->SeqBody = (char *)NVALLOC(maxLen);
161         abbs->MaxSeqLen = maxLen;
162         abbs->SeqLen = len;
163         xdr_opaque(x, abbs->SeqBody, len);
164         return TRUE;
165     }
166 }
167
168 bool_t
169 xdr_AFSAccessList(XDR * x, AFSAccessList * abbs)
170 {
171     afs_int32 maxLen, len;
172     if (x->x_op == XDR_FREE) {
173         NVFREE(abbs->SeqBody, abbs->MaxSeqLen);
174         return TRUE;
175     }
176
177     if (x->x_op == XDR_ENCODE) {
178         xdr_afs_int32(x, &abbs->MaxSeqLen);
179         xdr_afs_int32(x, &abbs->SeqLen);
180         xdr_opaque(x, abbs->SeqBody, abbs->SeqLen);
181         return TRUE;
182     } else {
183         xdr_afs_int32(x, &maxLen);
184         xdr_afs_int32(x, &len);
185         if (len < 0 || len > MAXBS || len > maxLen) {
186             bslosers++;
187             return FALSE;
188         }
189         if (!abbs->SeqBody)
190             abbs->SeqBody = (char *)NVALLOC(maxLen);
191         abbs->MaxSeqLen = maxLen;
192         abbs->SeqLen = len;
193         xdr_opaque(x, abbs->SeqBody, len);
194         return TRUE;
195     }
196 }
197 #endif /* KERNEL */