cc1cbfeccb891077faa7ab579a2c5ba36f3c06fa
[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 #include <afs/param.h>
12
13
14 #ifdef KERNEL
15 #if defined(UKERNEL)
16 #include "afs/sysincludes.h"
17 #include "afsincludes.h"
18 #include "rx/xdr.h"
19 #else /* defined(UKERNEL) */
20 #if defined(AFS_NBSD50_ENV)
21 #include "afs/afs_osi.h"
22 #endif
23 #if defined(AFS_OSF_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
24 #include "afs/sysincludes.h"
25 #include "afsincludes.h"
26 #else
27 #include "h/types.h"
28 #include "rx/xdr.h"
29 #endif
30 #if !defined(AFS_ALPHA_ENV)
31 #ifndef XDR_GETINT32
32 #define XDR_GETINT32    XDR_GETLONG
33 #endif
34 #ifndef XDR_PUTINT32
35 #define XDR_PUTINT32    XDR_PUTLONG
36 #endif
37 #endif
38 #endif /* defined(UKERNEL) */
39 #include "afsint.h"
40 #else /* KERNEL */
41 # include <roken.h>
42 # include <rx/xdr.h>
43 # include "afsint.h"
44 #endif /* KERNEL */
45
46 #ifdef KERNEL
47 #define NVALLOC(a)      osi_Alloc(a)
48 #define NVFREE(a,b)     osi_Free(a,b)
49 #else /* KERNEL */
50 #define MAXBS   2048            /* try to avoid horrible allocs */
51 static afs_int32 bslosers = 0;
52 #define NVALLOC(a)      malloc(a)
53 #define NVFREE(a,b)     free(a)
54 #endif /* KERNEL */
55
56 /* these things are defined in R (but not RX's) library.  For now, we add them
57     only for the kernel system.  Later, when R is expunged, we'll remove the ifdef */
58 #ifdef KERNEL
59 #ifndef AFS_USR_DARWIN_ENV
60 /*
61  * Wrapper for xdr_string that can be called directly from
62  * routines like clnt_call; from user-mode xdr package.
63  */
64 #ifndef AFS_SUN5_ENV
65 #ifndef AFS_HPUX110_ENV
66 bool_t
67 xdr_wrapstring(XDR * xdrs, char **cpp)
68 {
69     if (xdr_string(xdrs, cpp, 1024)) {
70         return (TRUE);
71     }
72     return (FALSE);
73 }
74 #endif /* AFS_HPUX110_ENV */
75 #endif /* AFS_SUN5_ENV */
76
77 #endif
78 #endif /* KERNEL */
79
80 #ifndef KERNEL
81 bool_t
82 xdr_CBS(XDR * x, struct CBS * abbs)
83 {
84     afs_int32 len;
85     if (x->x_op == XDR_FREE) {
86         NVFREE(abbs->SeqBody, abbs->SeqLen);
87         return TRUE;
88     }
89
90     if (x->x_op == XDR_ENCODE) {
91         xdr_afs_int32(x, &abbs->SeqLen);
92         xdr_opaque(x, abbs->SeqBody, abbs->SeqLen);
93         return TRUE;
94     } else {
95         xdr_afs_int32(x, &len);
96         if (len < 0 || len > MAXBS) {
97             bslosers++;
98             return FALSE;
99         }
100         if (!abbs->SeqBody)
101             abbs->SeqBody = NVALLOC(len);
102         abbs->SeqLen = len;
103         xdr_opaque(x, abbs->SeqBody, len);
104         return TRUE;
105     }
106 }
107
108 bool_t
109 xdr_BBS(XDR * x, struct BBS * abbs)
110 {
111     afs_int32 maxLen, len;
112     if (x->x_op == XDR_FREE) {
113         NVFREE(abbs->SeqBody, abbs->MaxSeqLen);
114         return TRUE;
115     }
116
117     if (x->x_op == XDR_ENCODE) {
118         xdr_afs_int32(x, &abbs->MaxSeqLen);
119         xdr_afs_int32(x, &abbs->SeqLen);
120         xdr_opaque(x, abbs->SeqBody, abbs->SeqLen);
121         return TRUE;
122     } else {
123         xdr_afs_int32(x, &maxLen);
124         xdr_afs_int32(x, &len);
125         if (len < 0 || len > MAXBS || len > maxLen) {
126             bslosers++;
127             return FALSE;
128         }
129         if (!abbs->SeqBody)
130             abbs->SeqBody = NVALLOC(maxLen);
131         abbs->MaxSeqLen = maxLen;
132         abbs->SeqLen = len;
133         xdr_opaque(x, abbs->SeqBody, len);
134         return TRUE;
135     }
136 }
137
138 bool_t
139 xdr_AFSAccessList(XDR * x, AFSAccessList * 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 = NVALLOC(maxLen);
161         abbs->MaxSeqLen = maxLen;
162         abbs->SeqLen = len;
163         xdr_opaque(x, abbs->SeqBody, len);
164         return TRUE;
165     }
166 }
167 #endif /* KERNEL */