libafs: allow bkg daemon requests without creds
[openafs.git] / tests / rpctestlib / rpc_test_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 #ifdef AFS_NT40_ENV
41 #include <windows.h>
42 #include <WINNT/afsevent.h>
43 #else
44 #include <sys/file.h>
45 #include <afs/venus.h>
46 #include <sys/time.h>
47 #endif
48 #include <afs/afsint.h>
49 #define FSINT_COMMON_XG 1
50 #include <afs/vice.h>
51 #include <afs/cmd.h>
52 #include <afs/auth.h>
53 #include <afs/cellconfig.h>
54
55 #include <afs/com_err.h>
56 #ifdef HAVE_DIRECT_H
57 #include <direct.h>
58 #endif
59 #include <afs/errors.h>
60 #include <afs/sys_prototypes.h>
61 #include <rx/rx_prototypes.h>
62 #ifdef AFS_PTHREAD_ENV
63 #include <assert.h>
64 #endif
65
66 extern const char *prog;
67 const int ctx_key = 1;
68
69 #if 1
70 #define RPC_TEST_GLOBAL_RX_INIT 1
71 #else
72 #undef RPC_TEST_GLOBAL_RX_INIT
73 #endif
74
75 const afs_uint32 fs_port = 7000;
76
77 typedef struct rpc_test_pkg_params {
78     pthread_mutex_t mtx;
79     pthread_mutexattr_t mtx_attrs;
80     afs_uint32 cb_next_port;
81     afs_uint32 next_cno;
82 } rpc_test_pkg_params;
83 static rpc_test_pkg_params rpc_test_params;
84
85 afs_int32 rpc_test_PkgInit(void)
86 {
87     afs_int32 code = 0;
88     static afs_uint32 rpc_test_initialized = 0; /* once */
89
90     if (!rpc_test_initialized) {
91         rpc_test_initialized = 1;
92     } else {
93         printf("%s: rpc_test_PkgInit: package already initialized\n", prog);
94         exit(1);
95     }
96
97 #ifndef AFS_NT40_ENV
98     code = pthread_mutexattr_init(&rpc_test_params.mtx_attrs);
99     if (code) {
100         printf("%s: rpc_test_PkgInit: pthread_mutexattr_init failed\n", prog);
101         exit(1);
102     }
103     code = pthread_mutex_init(&rpc_test_params.mtx, &rpc_test_params.mtx_attrs);
104     if (code) {
105         printf("%s: rpc_test_PkgInit: pthread_mutex_init failed\n", prog);
106         exit(1);
107     }
108 #endif
109
110     /* start connection sequence */
111     rpc_test_params.next_cno = 1;
112
113     /* set the starting port in sequence */
114     rpc_test_params.cb_next_port = 7105;
115
116 #if defined(RPC_TEST_GLOBAL_RX_INIT)
117     rx_Init(0);
118 #endif
119
120     return (code);
121
122 }        /* rpc_test_PkgInit */
123
124 static void *
125 init_callback_service_lwp(void *arg)
126 {
127     struct rx_securityClass *sc;
128     struct rx_service *svc;
129
130     rpc_test_request_ctx *ctx = (rpc_test_request_ctx *) arg;
131
132     printf("%s: init_callback_service_lwp: listen_addr: %s "
133            "(%d) cb_port: %d\n",
134            prog, ctx->cb_listen_addr_s, ctx->cb_listen_addr.addr_in[0],
135            ctx->cb_port);
136
137     sc = (struct rx_securityClass *) rxnull_NewServerSecurityObject();
138     if (!sc) {
139         fprintf(stderr,"rxnull_NewServerSecurityObject failed for callback "
140                 "service\n");
141         exit(1);
142     }
143
144 #if defined(RPC_TEST_GLOBAL_RX_INIT)
145     svc = rx_NewServiceHost(htonl(INADDR_ANY), htons(ctx->cb_port), 1,
146                             ctx->cb_svc_name, &sc, 1, RXAFSCB_ExecuteRequest);
147 #else
148     svc = rx_NewService(0, 1, ctx->cb_svc_name, &sc, 1, RXAFSCB_ExecuteRequest);
149 #endif
150     /* stash context */
151     rx_SetServiceSpecific(svc, ctx_key, ctx);
152
153     if (!svc) {
154         fprintf(stderr,"rx_NewServiceHost failed for callback service\n");
155         exit(1);
156     }
157
158     /* XXX stash service so we can hijack its rx_socket when inititiating
159      * RPC calls */
160     ctx->svc = svc;
161
162     /* release pkg mutex before entering rx processing loop */
163     pthread_mutex_unlock(&rpc_test_params.mtx);
164
165     rx_StartServer(1);
166
167     printf("%s: init_callback_service_lwp: finished", prog);
168
169     return (NULL);
170
171 }        /* callback_service_lwp */
172
173 afs_int32 init_callback_service(rpc_test_request_ctx *ctx)
174 {
175     pthread_t tid;
176     pthread_attr_t tattr;
177     afs_int32 code = 0;
178
179     afs_uuid_create(&(ctx->cb_listen_addr.uuid));
180
181 #if !defined(RPC_TEST_GLOBAL_RX_INIT)
182 #if 0
183     code = rx_InitHost(ctx->cb_listen_addr.addr_in[0],
184                        (int) htons(ctx->cb_port));
185 #else
186     code = rx_Init((int) htons(ctx->cb_port));
187 #endif
188 #endif /* RPC_TEST_GLOBAL_RX_INIT */
189
190     assert(pthread_attr_init(&tattr) == 0);
191     assert(pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED) == 0);
192     assert(pthread_create(&tid, &tattr, init_callback_service_lwp, ctx) == 0);
193
194     return (code);
195
196 }        /* init_callback_service */
197
198 afs_int32 init_fs_channel(rpc_test_request_ctx **octx, char *cb_if,
199                           char *listen_addr_s, char *prefix, char *fs_addr_s,
200                           afs_uint32 flags)
201 {
202     rpc_test_request_ctx *ctx;
203     afs_int32 code = 0;
204 #ifdef AFS_NT40_ENV
205     afs_int32 sslen = sizeof(struct sockaddr);
206 #endif
207
208     ctx = *octx = (rpc_test_request_ctx *) malloc(sizeof(rpc_test_request_ctx));
209     memset(ctx, 0, sizeof(rpc_test_request_ctx));
210
211     /* initialize a local mutex */
212     code = pthread_mutex_init(&ctx->mtx, &rpc_test_params.mtx_attrs);
213
214     /* lock package before rx setup--which has global deps, atm */
215     pthread_mutex_lock(&rpc_test_params.mtx);
216
217     ctx->cno = rpc_test_params.next_cno++;
218     ctx->flags = flags;
219
220     /* afscbint (server) */
221     sprintf(ctx->cb_svc_name, "cb_%d", ctx->cno);
222     sprintf(ctx->cb_if_s, "%s", cb_if);
223     sprintf(ctx->cb_listen_addr_s, "%s", listen_addr_s);
224     sprintf(ctx->cb_prefix_s, "%s", prefix);
225     sprintf(ctx->fs_addr_s, "%s", fs_addr_s);
226
227 #if defined(RPC_TEST_ADD_ADDRESSES)
228 #if defined(AFS_LINUX26_ENV)
229     sprintf(cmd, "ip addr add %s/%s dev %s label %s", listen_addr_s, prefix,
230             cb_if, cb_if);
231     code = system(cmd);
232 #endif
233 #endif /* RPC_TEST_ADD_ADDRESSES */
234
235     /* lock this */
236     pthread_mutex_lock(&ctx->mtx);
237
238     /* set up rx */
239     ctx->cb_port = rpc_test_params.cb_next_port++;
240     ctx->cb_listen_addr.numberOfInterfaces = 1;
241
242 #ifdef AFS_NT40_ENV
243     code = WSAStringToAddressA(listen_addr_s, AF_INET, NULL,
244               (struct sockaddr*) &(ctx->cb_listen_addr), &sslen);
245 #else
246     code = inet_pton(AF_INET, listen_addr_s,
247                      (void*) &(ctx->cb_listen_addr.addr_in[0]));
248 #endif
249
250     code = init_callback_service(ctx /* LOCKED, && rpc_test_params->mtx LOCKED */);
251
252     /* fsint (client) */
253
254 #ifdef AFS_NT40_ENV
255     code = WSAStringToAddressA(fs_addr_s, AF_INET, NULL,
256               (struct sockaddr*) &(ctx->fs_addr.addr_in[0]), &sslen);
257 #else
258     code = inet_pton(AF_INET, fs_addr_s, (void*) &(ctx->fs_addr.addr_in[0]));
259 #endif
260     ctx->sc = rxnull_NewClientSecurityObject();
261     ctx->sc_index = RX_SECIDX_NULL;
262     ctx->conn = rx_NewConnection(ctx->fs_addr.addr_in[0], (int) htons(fs_port),
263                                  1, ctx->sc, ctx->sc_index);
264
265     /* unlock this */
266     pthread_mutex_unlock(&ctx->mtx);
267
268     return (code);
269
270 }        /* init_fs_channel */
271
272 /* XXX use the pkg lock to protect the state of rx_socket for
273  * the duration of the call, switching it out for the stashed
274  * rx_socket created by rx_NewService for this channel */
275 #define RXCALL_WITH_SOCK(code, ctx, call) \
276     do { \
277         osi_socket prev_rx_socket; \
278         pthread_mutex_lock(&rpc_test_params.mtx); \
279         prev_rx_socket = rx_socket; \
280         rx_socket = ctx->svc->socket; \
281         code = call; \
282         rx_socket = prev_rx_socket; \
283         pthread_mutex_unlock(&rpc_test_params.mtx); \
284 } while(0);
285
286 afs_int32
287 rpc_test_afs_fetch_status(rpc_test_request_ctx *ctx, AFSFid *fid,
288                               AFSFetchStatus *outstatus)
289 {
290     struct AFSVolSync tsync;
291     struct AFSCallBack tcb;
292     afs_int32 code = 0;
293
294     RXCALL_WITH_SOCK(code, ctx,
295        (RXAFS_FetchStatus(ctx->conn, fid, outstatus, &tcb, &tsync)));
296
297     return (code);
298
299 }        /* rpc_test_afs_fetch_status */
300
301 afs_int32
302 rpc_test_afs_store_status(rpc_test_request_ctx *ctx, AFSFid *fid,
303                     AFSStoreStatus *instatus, AFSFetchStatus *outstatus)
304 {
305     struct AFSVolSync tsync;
306     afs_int32 code = 0;
307
308     RXCALL_WITH_SOCK(code, ctx,
309        (RXAFS_StoreStatus(ctx->conn, fid, instatus, outstatus, &tsync)));
310
311     return (code);
312
313 }        /* rpc_test_afs_fetch_status */
314
315 #if defined(AFS_BYTE_RANGE_FLOCKS)
316 afs_int32 rpc_test_afs_set_byterangelock(rpc_test_request_ctx *ctx,
317     AFSByteRangeLock * lock)
318 {
319     struct rx_call *tcall;
320     afs_int32 code = 0;
321
322     RXCALL_WITH_SOCK(code, ctx,
323        (RXAFS_SetByteRangeLock(ctx->conn, lock)));
324
325     return (code);
326
327 }        /* rpc_test_afs_set_byterangelock */
328
329 afs_int32 rpc_test_afs_release_byterangelock(rpc_test_request_ctx *ctx,
330     AFSByteRangeLock * lock)
331 {
332     struct rx_call *tcall;
333     afs_int32 code = 0;
334
335     RXCALL_WITH_SOCK(code, ctx,
336        (RXAFS_ReleaseByteRangeLock(ctx->conn, lock)));
337
338     return (code);
339
340 }        /* rpc_test_afs_release_byterangelock */
341
342 afs_int32 rpc_test_afs_upgrade_byterangelock(rpc_test_request_ctx *ctx,
343     AFSByteRangeLock * lock)
344 {
345     afs_int32 code = 0;
346
347     /* TODO:  implement */
348
349     return (code);
350
351 }        /* rpc_test_afs_upgrade_byterangelock */
352
353 afs_int32 rpc_test_afs_downgrade_byterangelock(rpc_test_request_ctx *ctx,
354     AFSByteRangeLock * Lock)
355 {
356     afs_int32 code = 0;
357
358     /* TODO:  implement */
359
360     return (code);
361
362 }        /* rpc_test_afs_downgrade_byterangelock */
363 #endif /* AFS_BYTE_RANGE_FLOCKS */
364
365 afs_int32
366 destroy_fs_channel(rpc_test_request_ctx *ctx)
367 {
368     afs_int32 code = 0;
369 #if defined(RPC_TEST_ADD_ADDRESSES)
370 #if defined(AFS_LINUX26_ENV)
371     sprintf(cmd, "ip addr del %s/%s dev %s label %s", ctx->cb_listen_addr_s,
372             ctx->cb_prefix_s, ctx->cb_if_s, ctx->cb_if_s);
373     code = system(cmd);
374 #endif
375 #endif /* RPC_TEST_ADD_ADDRESSES */
376     assert(ctx);
377     free(ctx);
378     return (code);
379
380 }        /* destroy_fs_channel */
381
382 void
383 rpc_test_PkgShutdown(void)
384 {
385 }        /* rpc_test_PkgShutdown */