tests: Explicitly include DES in superuser test
[openafs.git] / tests / rpctestlib / rpc_test_cb_procs.c
1 /*
2  * Copyright (c) 2010, Linux Box Corporation.
3  * All Rights Reserved.
4  *
5  * Portions Copyright (c) 2007, Hartmut Reuter,
6  * RZG, Max-Planck-Institut f. Plasmaphysik.
7  * All Rights Reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions are met:
11  *
12  *   1. Redistributions of source code must retain the above copyright
13  *      notice, this list of conditions and the following disclaimer.
14  *   2. Redistributions in binary form must reproduce the above copyright
15  *      notice, this list of conditions and the following disclaimer in
16  *      the documentation and/or other materials provided with the
17  *      distribution.
18  *
19  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
20  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
21  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
25  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
26  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
27  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include <afsconfig.h>
32 #include <afs/param.h>
33
34 #include <roken.h>
35
36 #include <afs/stds.h>
37
38 #include "rpc_test_procs.h"
39
40 #include <stdio.h>
41 #include <sys/types.h>
42 #include <string.h>
43 #include <sys/stat.h>
44 #include <errno.h>
45 #include <signal.h>
46 #include <afs/vice.h>
47 #include <afs/cmd.h>
48 #include <afs/auth.h>
49 #include <afs/cellconfig.h>
50
51 #include <afs/com_err.h>
52 #ifdef HAVE_DIRENT_H
53 #include <dirent.h>
54 #endif
55 #ifdef HAVE_DIRECT_H
56 #include <direct.h>
57 #endif
58 #ifdef AFS_DARWIN_ENV
59 #include <sys/malloc.h>
60 #else
61 #include <malloc.h>
62 #endif
63 #include <afs/errors.h>
64 #include <afs/sys_prototypes.h>
65 #include <rx/rx_prototypes.h>
66 #ifdef AFS_PTHREAD_ENV
67 #include <assert.h>
68 #endif
69
70 extern const char *prog;
71 extern pthread_key_t ctx_key;
72
73 #if defined(AFS_EXTENDED_CALLBACK)
74 #define RPC_TEST_EXTENDED_CALLBACK  1
75
76 afs_int32 SRXAFSCB_ExtendedCallBack(
77     /*IN */ struct rx_call *a_call,
78     /*IN */ HostIdentifier * Server,
79     /*IN */ AFSXCBInvocationSeq * Invocations_Array,
80     /*OUT*/ AFSExtendedCallBackRSeq * CallBack_Result_Array)
81 {
82     rpc_test_request_ctx *ctx;
83
84     ctx = CTX_FOR_RXCALL(a_call);
85
86     printf("%s: SRXAFSCB_ExtendedCallBack: enter (%s)\n", prog,
87         ctx->cb_svc_name);
88
89     return (0);
90 };
91 #endif /* AFS_EXTENDED_CALLBACK */
92
93 #if defined(AFS_BYTE_RANGE_FLOCKS)
94 afs_int32 SRXAFSCB_AsyncIssueByteRangeLock(
95         /*IN */ struct rx_call *a_call,
96         /*IN */ HostIdentifier * Server,
97         /*IN */ AFSByteRangeLockSeq Locks_Array)
98 {
99     rpc_test_request_ctx *ctx = CTX_FOR_RXCALL(a_call);
100
101     printf("%s: SRXAFSCB_AsyncIssueByteRangeLock: enter (%s)\n", prog,
102         ctx->cb_svc_name);
103
104     return (0);
105 }
106 #endif /* AFS_BYTE_RANGE_FLOCKS */
107
108 afs_int32
109 SRXAFSCB_CallBack(struct rx_call *a_call, AFSCBFids *Fids_Array,
110                   AFSCBs *CallBack_Array)
111 {
112     rpc_test_request_ctx *ctx = CTX_FOR_RXCALL(a_call);
113
114     printf("%s: SRXAFSCB_CallBack: enter (%s)\n", prog,
115         ctx->cb_svc_name);
116
117     return (0);
118 }
119
120
121 afs_int32
122 SRXAFSCB_InitCallBackState(struct rx_call *a_call)
123 {
124     return (0);
125 }
126
127
128 afs_int32
129 SRXAFSCB_Probe(struct rx_call *a_call)
130 {
131     return (0);
132 }
133
134
135 afs_int32
136 SRXAFSCB_GetCE(struct rx_call *a_call,
137                afs_int32 index,
138                AFSDBCacheEntry * ce)
139 {
140     return(0);
141 }
142
143
144 afs_int32
145 SRXAFSCB_GetLock(struct rx_call *a_call,
146                  afs_int32 index,
147                  AFSDBLock * lock)
148 {
149     return(0);
150 }
151
152
153 afs_int32
154 SRXAFSCB_XStatsVersion(struct rx_call *a_call,
155                        afs_int32 * versionNumberP)
156 {
157     return(0);
158 }
159
160
161 afs_int32
162 SRXAFSCB_GetXStats(struct rx_call *a_call,
163                    afs_int32 clientVersionNumber,
164                    afs_int32 collectionNumber,
165                    afs_int32 * srvVersionNumberP,
166                    afs_int32 * timeP,
167                    AFSCB_CollData * dataP)
168 {
169     return(0);
170 }
171
172 afs_int32
173 SRXAFSCB_ProbeUuid(struct rx_call *a_call, afsUUID *a_uuid)
174 {
175     rpc_test_request_ctx *ctx = CTX_FOR_RXCALL(a_call);
176     if ( !afs_uuid_equal(&ctx->cb_listen_addr.uuid, a_uuid) )
177         return (1);
178     else
179         return (0);
180 }
181
182
183 afs_int32
184 SRXAFSCB_WhoAreYou(struct rx_call *a_call, struct interfaceAddr *addr)
185 {
186     return SRXAFSCB_TellMeAboutYourself(a_call, addr, NULL);
187 }
188
189
190 afs_int32
191 SRXAFSCB_InitCallBackState2(struct rx_call *a_call, struct interfaceAddr *
192                             addr)
193 {
194     return RXGEN_OPCODE;
195 }
196
197
198 afs_int32
199 SRXAFSCB_InitCallBackState3(struct rx_call *a_call, afsUUID *a_uuid)
200 {
201     return (0);
202 }
203
204
205 afs_int32
206 SRXAFSCB_GetCacheConfig(struct rx_call *a_call, afs_uint32 callerVersion,
207                         afs_uint32 *serverVersion, afs_uint32 *configCount,
208                         cacheConfig *config)
209 {
210     return RXGEN_OPCODE;
211 }
212
213 afs_int32
214 SRXAFSCB_GetLocalCell(struct rx_call *a_call, char **a_name)
215 {
216     return RXGEN_OPCODE;
217 }
218
219
220 afs_int32
221 SRXAFSCB_GetCellServDB(struct rx_call *a_call, afs_int32 a_index,
222                        char **a_name, serverList *a_hosts)
223 {
224     return RXGEN_OPCODE;
225 }
226
227
228 afs_int32
229 SRXAFSCB_GetServerPrefs(struct rx_call *a_call, afs_int32 a_index,
230                         afs_int32 *a_srvr_addr, afs_int32 *a_srvr_rank)
231 {
232     return RXGEN_OPCODE;
233 }
234
235
236 afs_int32
237 SRXAFSCB_TellMeAboutYourself(struct rx_call *a_call, struct interfaceAddr *
238                              addr, Capabilities *capabilities)
239 {
240     afs_int32 code;
241     rpc_test_request_ctx *ctx = CTX_FOR_RXCALL(a_call);
242
243     printf("%s: SRXAFSCB_TellMeAboutYourself: enter (%s)\n", prog,
244         ctx->cb_svc_name);
245
246     addr->numberOfInterfaces = ctx->cb_listen_addr.numberOfInterfaces;
247     addr->uuid = ctx->cb_listen_addr.uuid;
248
249     if (capabilities) {
250         afs_uint32 *dataBuffP;
251         afs_int32 dataBytes;
252
253         dataBytes = 1 * sizeof(afs_uint32);
254         dataBuffP = (afs_uint32 *) xdr_alloc(dataBytes);
255         dataBuffP[0] = CLIENT_CAPABILITY_ERRORTRANS;
256 #if defined(AFS_EXTENDED_CALLBACK)
257         if (ctx->flags & RPC_TEST_REQ_CTX_FLAG_XCB)
258             dataBuffP[0] |= CLIENT_CAPABILITY_EXT_CALLBACK;
259 #endif /* AFS_EXTENDED_CALLBACK */
260         capabilities->Capabilities_len = dataBytes / sizeof(afs_uint32);
261         capabilities->Capabilities_val = dataBuffP;
262     }
263
264     return (0);
265
266 }        /* SRXAFSCB_TellMeAboutYourself */
267
268
269 afs_int32
270 SRXAFSCB_GetCellByNum(struct rx_call *a_call, afs_int32 a_cellnum,
271                       char **a_name, serverList *a_hosts)
272 {
273     return RXGEN_OPCODE;
274 }
275
276
277 afs_int32
278 SRXAFSCB_GetCE64(struct rx_call *a_call, afs_int32 a_index,
279                  struct AFSDBCacheEntry64 *a_result)
280 {
281     return RXGEN_OPCODE;
282 }