HCoop / hcoop / debian / openafs.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
backport to buster
[hcoop/debian/openafs.git] / src / xstat / xstat_fs_callback.c
CommitLineData
805e021f
CE		 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/*
11 * Description:
12 * Implementation of the xstat_fs callback routines. These are the
13 * server-side functions that the File Server expects to invoke on
14 * the client machine via the afsint interface. In this case, the
15 * client process is acting as a callback listener, so it has to
16 * be prepared to answer these calls.
17 *
18 * Environment:
19 * The afsint server stubs expect the functions defined here to
20 * be provided. There is no .h file for this code, since the
21 * linker really does all the work for us, and these don't really
22 * need to be ``visible'' to anyone else.
23 *------------------------------------------------------------------------*/
24
25#include <afsconfig.h>
26#include <afs/param.h>
27
28#include <roken.h>
29
30#ifdef AFS_NT40_ENV
31#include <windows.h>
32#include <rpc.h>
33#endif
34
35#include <afs/afscbint.h> /*Callback interface defs */
36#include <afs/afsutil.h>
37
38int afs_cb_inited = 0;
39struct interfaceAddr afs_cb_interface;
40
41#define XSTAT_FS_CALLBACK_VERBOSE 0
42
43/*
44 * Initialize the callback interface structure
45 */
46static int
47init_afs_cb(void)
48{
49 int count;
50
51#ifdef AFS_NT40_ENV
52 UuidCreate((UUID *)&afs_cb_interface.uuid);
53#else
54 afs_uuid_create(&afs_cb_interface.uuid);
55#endif
56 count = rx_getAllAddr((afs_uint32 *)afs_cb_interface.addr_in, AFS_MAX_INTERFACE_ADDR);
57 if (count <= 0)
58 afs_cb_interface.numberOfInterfaces = 0;
59 else
60 afs_cb_interface.numberOfInterfaces = count;
61 afs_cb_inited = 1;
62 return 0;
63}
64
65#if XSTAT_FS_CALLBACK_VERBOSE
66static char mn[] = "xstat_fs_callback"; /*Module name */
67#endif
68
69/*------------------------------------------------------------------------
70 * SRXAFSCB_CallBack
71 *
72 * Description:
73 * Handle a set of callbacks from the File Server.
74 *
75 * Arguments:
76 * struct rx_call *rxcall : Ptr to the associated Rx call structure.
77 * AFSCBFids *Fids_Array : Ptr to the set of Fids.
78 * AFSCBs *CallBacks_Array : Ptr to the set of callbacks.
79 *
80 * Returns:
81 * 0 on success,
82 * Error value otherwise.
83 *
84 * Environment:
85 * Nothing interesting.
86 *
87 * Side Effects:
88 * As advertised.
89 *------------------------------------------------------------------------*/
90
91afs_int32
92SRXAFSCB_CallBack(struct rx_call *rxcall, AFSCBFids * Fids_Array,
93 AFSCBs * CallBack_Array)
94{ /*SRXAFSCB_CallBack */
95
96#if XSTAT_FS_CALLBACK_VERBOSE
97 static char rn[] = "SRXAFSCB_CallBack"; /*Routine name */
98 char hostName[256]; /*Host name buffer */
99 char *hostNameResult; /*Ptr to static */
100
101 fprintf(stderr, "[%s:%s] Called\n", mn, rn);
102
103 if (rxcall != (struct rx_call *)0) {
104 hostNameResult =
105 hostutil_GetNameByINet((afs_int32) (rxcall->conn->peer->host));
106 strcpy(hostName, hostNameResult);
107 fprintf(stderr, "[%s:%s] Called from host %s, port %d\n", mn, rn,
108 hostName, rxcall->conn->peer->port);
109 } /*Valid rxcall param */
110#endif /* XSTAT_FS_CALLBACK_VERBOSE */
111
112 /*
113 * Return successfully.
114 */
115 return (0);
116
117} /*SRXAFSCB_CallBack */
118
119/*------------------------------------------------------------------------
120 * SRXAFSCB_InitCallBackState
121 *
122 * Description:
123 * Initialize callback state on this ``Cache Manager''.
124 *
125 * Arguments:
126 * struct rx_call *rxcall : Ptr to the associated Rx call structure.
127 *
128 * Returns:
129 * 0 on success,
130 * Error value otherwise.
131 *
132 * Environment:
133 * This will definitely be called by the File Server (exactly once),
134 * since it will think we are another new ``Cache Manager''.
135 *
136 * Side Effects:
137 * As advertised.
138 *------------------------------------------------------------------------*/
139
140afs_int32
141SRXAFSCB_InitCallBackState(struct rx_call * rxcall)
142{ /*SRXAFSCB_InitCallBackState */
143
144#if XSTAT_FS_CALLBACK_VERBOSE
145 static char rn[] = "SRXAFSCB_InitCallBackState"; /*Routine name */
146 char hostName[256]; /*Host name buffer */
147 char *hostNameResult; /*Ptr to static */
148
149 fprintf(stderr, "[%s:%s] Called\n", mn, rn);
150
151 if (rxcall != (struct rx_call *)0) {
152 hostNameResult =
153 hostutil_GetNameByINet((afs_int32) (rxcall->conn->peer->host));
154 strcpy(hostName, hostNameResult);
155 fprintf(stderr, "[%s:%s] Called from host %s, port %d\n", mn, rn,
156 hostName, rxcall->conn->peer->port);
157 } /*Valid rxcall param */
158#endif /* XSTAT_FS_CALLBACK_VERBOSE */
159
160 /*
161 * Return successfully.
162 */
163 return (0);
164
165} /*SRXAFSCB_InitCallBackState */
166
167/*------------------------------------------------------------------------
168 * SRXAFSCB_Probe
169 *
170 * Description:
171 * Respond to a probe from the File Server. If a File Server
172 * doesn't hear from you every so often, it will send you a probe
173 * to make sure you're there, just like any other ``Cache Manager''
174 * it's keeping track of.
175 *
176 * Arguments:
177 * struct rx_call *rxcall : Ptr to the associated Rx call structure.
178 *
179 * Returns:
180 * 0 on success,
181 * Error value otherwise.
182 *
183 * Environment:
184 * This may be called by the File Server if we don't call it often
185 * enough.
186 *
187 * Side Effects:
188 * As advertised.
189 *------------------------------------------------------------------------*/
190
191afs_int32
192SRXAFSCB_Probe(struct rx_call * rxcall)
193{ /*SRXAFSCB_Probe */
194
195#if XSTAT_FS_CALLBACK_VERBOSE
196 static char rn[] = "SRXAFSCB_Probe"; /*Routine name */
197 char hostName[256]; /*Host name buffer */
198 char *hostNameResult; /*Ptr to static */
199
200 fprintf(stderr, "[%s:%s] Called\n", mn, rn);
201
202 if (rxcall != (struct rx_call *)0) {
203 hostNameResult =
204 hostutil_GetNameByINet((afs_int32) (rxcall->conn->peer->host));
205 strcpy(hostName, hostNameResult);
206 fprintf(stderr, "[%s:%s] Called from host %s, port %d\n", mn, rn,
207 hostName, rxcall->conn->peer->port);
208 } /*Valid rxcall param */
209#endif /* XSTAT_FS_CALLBACK_VERBOSE */
210
211 /*
212 * Return successfully.
213 */
214 return (0);
215
216} /*SRXAFSCB_Probe */
217
218
219/*------------------------------------------------------------------------
220 * SRXAFSCB_GetCE64
221 *
222 * Description:
223 * Respond minimally to a request for returning the contents of
224 * a cache entry, since someone out there thinks you're a Cache
225 * Manager.
226 *
227 * Arguments:
228 * struct rx_call *rxcall: Ptr to the associated Rx call structure.
229 *
230 * Returns:
231 * 0 (always)
232 *
233 * Environment:
234 * Nothing interesting.
235 *
236 * Side Effects:
237 * As advertised.
238 *------------------------------------------------------------------------*/
239
240afs_int32
241SRXAFSCB_GetCE64(struct rx_call * rxcall, afs_int32 index,
242 AFSDBCacheEntry64 * ce)
243{ /*SRXAFSCB_GetCE64 */
244
245#if XSTAT_FS_CALLBACK_VERBOSE
246 static char rn[] = "SRXAFSCB_GetCE64"; /*Routine name */
247 char hostName[256]; /*Host name buffer */
248 char *hostNameResult; /*Ptr to static */
249
250 if (rxcall != (struct rx_call *)0) {
251 hostNameResult =
252 hostutil_GetNameByINet((afs_int32) (rxcall->conn->peer->host));
253 strcpy(hostName, hostNameResult);
254 fprintf(stderr, "[%s:%s] Called from host %s, port %d\n", mn, rn,
255 hostName, rxcall->conn->peer->port);
256 } /*Valid rxcall param */
257#endif /* XSTAT_FS_CALLBACK_VERBOSE */
258
259 return (0);
260
261} /*SRXAFSCB_GetCE64 */
262
263afs_int32
264SRXAFSCB_GetCE(struct rx_call * rxcall, afs_int32 index, AFSDBCacheEntry * ce)
265{ /*SRXAFSCB_GetCE */
266
267#if XSTAT_FS_CALLBACK_VERBOSE
268 static char rn[] = "SRXAFSCB_GetCE"; /*Routine name */
269 char hostName[256]; /*Host name buffer */
270 char *hostNameResult; /*Ptr to static */
271
272 if (rxcall != (struct rx_call *)0) {
273 hostNameResult =
274 hostutil_GetNameByINet((afs_int32) (rxcall->conn->peer->host));
275 strcpy(hostName, hostNameResult);
276 fprintf(stderr, "[%s:%s] Called from host %s, port %d\n", mn, rn,
277 hostName, rxcall->conn->peer->port);
278 } /*Valid rxcall param */
279#endif /* XSTAT_FS_CALLBACK_VERBOSE */
280
281 return (0);
282
283} /*SRXAFSCB_GetCE */
284
285
286/*------------------------------------------------------------------------
287 * SRXAFSCB_GetLock
288 *
289 * Description:
290 * Respond minimally to a request for returning the contents of
291 * a cache lock, since someone out there thinks you're a Cache
292 * Manager.
293 *
294 * Arguments:
295 * struct rx_call *rxcall: Ptr to the associated Rx call structure.
296 *
297 * Returns:
298 * 0 (always)
299 *
300 * Environment:
301 * Nothing interesting.
302 *
303 * Side Effects:
304 * As advertised.
305 *------------------------------------------------------------------------*/
306
307afs_int32
308SRXAFSCB_GetLock(struct rx_call * rxcall, afs_int32 index, AFSDBLock * lock)
309{ /*SRXAFSCB_GetLock */
310
311#if XSTAT_FS_CALLBACK_VERBOSE
312 static char rn[] = "SRXAFSCB_GetLock"; /*Routine name */
313 char hostName[256]; /*Host name buffer */
314 char *hostNameResult; /*Ptr to static */
315
316 if (rxcall != (struct rx_call *)0) {
317 hostNameResult =
318 hostutil_GetNameByINet((afs_int32) (rxcall->conn->peer->host));
319 strcpy(hostName, hostNameResult);
320 fprintf(stderr, "[%s:%s] Called from host %s, port %d\n", mn, rn,
321 hostName, rxcall->conn->peer->port);
322 } /*Valid rxcall param */
323#endif /* XSTAT_FS_CALLBACK_VERBOSE */
324
325 return (0);
326
327} /*SRXAFSCB_GetLock */
328
329
330/*------------------------------------------------------------------------
331 * SRXAFSCB_XStatsVersion
332 *
333 * Description:
334 * Respond minimally to a request for fetching the version of
335 * extended Cache Manager statistics offered, since someone out
336 * there thinks you're a Cache Manager.
337 *
338 * Arguments:
339 * struct rx_call *rxcall: Ptr to the associated Rx call structure.
340 *
341 * Returns:
342 * 0 (always)
343 *
344 * Environment:
345 * Nothing interesting.
346 *
347 * Side Effects:
348 * As advertised.
349 *------------------------------------------------------------------------*/
350
351afs_int32
352SRXAFSCB_XStatsVersion(struct rx_call * rxcall, afs_int32 * versionNumberP)
353{ /*SRXAFSCB_XStatsVersion */
354
355#if XSTAT_FS_CALLBACK_VERBOSE
356 static char rn[] = "SRXAFSCB_XStatsVersion"; /*Routine name */
357 char hostName[256]; /*Host name buffer */
358 char *hostNameResult; /*Ptr to static */
359
360 if (rxcall != (struct rx_call *)0) {
361 hostNameResult =
362 hostutil_GetNameByINet((afs_int32) (rxcall->conn->peer->host));
363 strcpy(hostName, hostNameResult);
364 fprintf(stderr, "[%s:%s] Called from host %s, port %d\n", mn, rn,
365 hostName, rxcall->conn->peer->port);
366 } /*Valid rxcall param */
367#endif /* XSTAT_FS_CALLBACK_VERBOSE */
368
369 return (0);
370
371} /*SRXAFSCB_XStatsVersion */
372
373
374/*------------------------------------------------------------------------
375 * SRXAFSCB_GetXStats
376 *
377 * Description:
378 * Respond minimally to a request for returning extended
379 * statistics for a Cache Manager, since someone out there thinks
380 * you're a Cache Manager.
381 *
382 * Arguments:
383 * struct rx_call *rxcall: Ptr to the associated Rx call structure.
384 *
385 * Returns:
386 * 0 (always)
387 *
388 * Environment:
389 * Nothing interesting.
390 *
391 * Side Effects:
392 * As advertised.
393 *------------------------------------------------------------------------*/
394
395afs_int32
396SRXAFSCB_GetXStats(struct rx_call * rxcall, afs_int32 clientVersionNumber,
397 afs_int32 collectionNumber, afs_int32 * srvVersionNumberP,
398 afs_int32 * timeP, AFSCB_CollData * dataP)
399{ /*SRXAFSCB_GetXStats */
400
401#if XSTAT_FS_CALLBACK_VERBOSE
402 static char rn[] = "SRXAFSCB_GetXStats"; /*Routine name */
403 char hostName[256]; /*Host name buffer */
404 char *hostNameResult; /*Ptr to static */
405
406 if (rxcall != (struct rx_call *)0) {
407 hostNameResult =
408 hostutil_GetNameByINet((afs_int32) (rxcall->conn->peer->host));
409 strcpy(hostName, hostNameResult);
410 fprintf(stderr, "[%s:%s] Called from host %s, port %d\n", mn, rn,
411 hostName, rxcall->conn->peer->port);
412 } /*Valid rxcall param */
413#endif /* XSTAT_FS_CALLBACK_VERBOSE */
414
415 return (0);
416
417} /*SRXAFSCB_GetXStats */
418
419/*------------------------------------------------------------------------
420 * EXPORTED SRXAFSCB_InitCallBackState2
421 *
422 * Description:
423 * This routine was used in the AFS 3.5 beta release, but not anymore.
424 * It has since been replaced by SRXAFSCB_InitCallBackState3.
425 *
426 * Arguments:
427 * rxcall : Ptr to Rx call on which this request came in.
428 *
429 * Returns:
430 * RXGEN_OPCODE (always).
431 *
432 * Environment:
433 * Nothing interesting.
434 *
435 * Side Effects:
436 * None
437 *------------------------------------------------------------------------*/
438
439afs_int32
440SRXAFSCB_InitCallBackState2(struct rx_call * rxcall,
441 struct interfaceAddr * addr)
442{
443
444#if XSTAT_FS_CALLBACK_VERBOSE
445 static char rn[] = "SRXAFSCB_InitCallBackState2"; /*Routine name */
446 char hostName[256]; /*Host name buffer */
447 char *hostNameResult; /*Ptr to static */
448
449 if (rxcall != (struct rx_call *)0) {
450 hostNameResult =
451 hostutil_GetNameByINet((afs_int32) (rxcall->conn->peer->host));
452 strcpy(hostName, hostNameResult);
453 fprintf(stderr, "[%s:%s] Called from host %s, port %d\n", mn, rn,
454 hostName, rxcall->conn->peer->port);
455 } /*Valid rxcall param */
456#endif /* XSTAT_FS_CALLBACK_VERBOSE */
457 return RXGEN_OPCODE;
458}
459
460/*------------------------------------------------------------------------
461 * EXPORTED SRXAFSCB_WhoAreYou
462 *
463 * Description:
464 * Routine called by the server-side callback RPC interface to
465 * obtain a unique identifier for the client. The server uses
466 * this identifier to figure out whether or not two RX connections
467 * are from the same client, and to find out which addresses go
468 * with which clients.
469 *
470 * Arguments:
471 * rxcall : Ptr to Rx call on which this request came in.
472 * addr: Ptr to return the list of interfaces for this client.
473 *
474 * Returns:
475 * 0 (Always)
476 *
477 * Environment:
478 * Nothing interesting.
479 *
480 * Side Effects:
481 * As advertised.
482 *------------------------------------------------------------------------*/
483
484afs_int32
485SRXAFSCB_WhoAreYou(struct rx_call * rxcall, struct interfaceAddr * addr)
486{
487#if XSTAT_FS_CALLBACK_VERBOSE
488 static char rn[] = "SRXAFSCB_WhoAreYou"; /*Routine name */
489 char hostName[256]; /*Host name buffer */
490 char *hostNameResult; /*Ptr to static */
491
492 if (rxcall != (struct rx_call *)0) {
493 hostNameResult =
494 hostutil_GetNameByINet((afs_int32) (rxcall->conn->peer->host));
495 strcpy(hostName, hostNameResult);
496 fprintf(stderr, "[%s:%s] Called from host %s, port %d\n", mn, rn,
497 hostName, rxcall->conn->peer->port);
498 } /*Valid rxcall param */
499#endif /* XSTAT_FS_CALLBACK_VERBOSE */
500
501 if (rxcall && addr) {
502 if (!afs_cb_inited)
503 init_afs_cb();
504 *addr = afs_cb_interface;
505 }
506
507 /*
508 * Return successfully.
509 */
510 return (0);
511}
512
513
514/*------------------------------------------------------------------------
515 * EXPORTED SRXAFSCB_InitCallBackState3
516 *
517 * Description:
518 * Routine called by the server-side callback RPC interface to
519 * implement clearing all callbacks from this host.
520 *
521 * Arguments:
522 * rxcall : Ptr to Rx call on which this request came in.
523 *
524 * Returns:
525 * 0 (always).
526 *
527 * Environment:
528 * Nothing interesting.
529 *
530 * Side Effects:
531 * As advertised.
532 *------------------------------------------------------------------------*/
533
534afs_int32
535SRXAFSCB_InitCallBackState3(struct rx_call * rxcall, afsUUID * uuidp)
536{
537#if XSTAT_FS_CALLBACK_VERBOSE
538 static char rn[] = "SRXAFSCB_InitCallBackState3"; /*Routine name */
539 char hostName[256]; /*Host name buffer */
540 char *hostNameResult; /*Ptr to static */
541
542 if (rxcall != (struct rx_call *)0) {
543 hostNameResult =
544 hostutil_GetNameByINet((afs_int32) (rxcall->conn->peer->host));
545 strcpy(hostName, hostNameResult);
546 fprintf(stderr, "[%s:%s] Called from host %s, port %d\n", mn, rn,
547 hostName, rxcall->conn->peer->port);
548 } /*Valid rxcall param */
549#endif /* XSTAT_FS_CALLBACK_VERBOSE */
550
551 /*
552 * Return successfully.
553 */
554 return (0);
555}
556
557
558/*------------------------------------------------------------------------
559 * EXPORTED SRXAFSCB_ProbeUuid
560 *
561 * Description:
562 * Routine called by the server-side callback RPC interface to
563 * implement ``probing'' the Cache Manager, just making sure it's
564 * still there is still the same client it used to be.
565 *
566 * Arguments:
567 * rxcall : Ptr to Rx call on which this request came in.
568 * uuidp : Ptr to UUID that must match the client's UUID.
569 *
570 * Returns:
571 * 0 if uuidp matches the UUID for this client
572 * Non-zero otherwize
573 *
574 * Environment:
575 * Nothing interesting.
576 *
577 * Side Effects:
578 * As advertised.
579 *------------------------------------------------------------------------*/
580
581afs_int32
582SRXAFSCB_ProbeUuid(struct rx_call * rxcall, afsUUID * uuidp)
583{
584 int code = 0;
585
586#if XSTAT_FS_CALLBACK_VERBOSE
587 static char rn[] = "SRXAFSCB_ProbeUuid"; /*Routine name */
588 char hostName[256]; /*Host name buffer */
589 char *hostNameResult; /*Ptr to static */
590
591 if (rxcall != (struct rx_call *)0) {
592 hostNameResult =
593 hostutil_GetNameByINet((afs_int32) (rxcall->conn->peer->host));
594 strcpy(hostName, hostNameResult);
595 fprintf(stderr, "[%s:%s] Called from host %s, port %d\n", mn, rn,
596 hostName, rxcall->conn->peer->port);
597 } /*Valid rxcall param */
598#endif /* XSTAT_FS_CALLBACK_VERBOSE */
599
600 if (!afs_cb_inited)
601 init_afs_cb();
602 if (!afs_uuid_equal(uuidp, &afs_cb_interface.uuid))
603 code = 1; /* failure */
604 return code;
605}
606
607/*------------------------------------------------------------------------
608 * EXPORTED SRXAFSCB_GetServerPrefs
609 *
610 * Description:
611 * Routine to list server preferences used by this client.
612 *
613 * Arguments:
614 * a_call : Ptr to Rx call on which this request came in.
615 * a_index : Input server index
616 * a_srvr_addr : Output server address (0xffffffff on last server)
617 * a_srvr_rank : Output server rank
618 *
619 * Returns:
620 * RXGEN_OPCODE (always)
621 *
622 * Environment:
623 * Nothing interesting.
624 *
625 * Side Effects:
626 * As advertised.
627 *------------------------------------------------------------------------*/
628
629afs_int32
630SRXAFSCB_GetServerPrefs(struct rx_call * a_call, afs_int32 a_index,
631 afs_int32 * a_srvr_addr, afs_int32 * a_srvr_rank)
632{
633 return RXGEN_OPCODE;
634}
635
636/*------------------------------------------------------------------------
637 * EXPORTED SRXAFSCB_GetCellServDB
638 *
639 * Description:
640 * Routine to list cells configured for this client
641 *
642 * Arguments:
643 * a_call : Ptr to Rx call on which this request came in.
644 * a_index : Input cell index
645 * a_name : Output cell name ("" on last cell)
646 * a_hosts : Output cell database servers
647 *
648 * Returns:
649 * 0 on success
650 *
651 * Environment:
652 * Nothing interesting.
653 *
654 * Side Effects:
655 * As advertised.
656 *------------------------------------------------------------------------*/
657
658afs_int32
659SRXAFSCB_GetCellServDB(struct rx_call * a_call, afs_int32 a_index,
660 char **a_name, serverList * a_hosts)
661{
662 return RXGEN_OPCODE;
663}
664
665
666afs_int32
667SRXAFSCB_GetCellByNum(struct rx_call * a_call, afs_int32 a_cellnum,
668 char **a_name, serverList * a_hosts)
669{
670 return RXGEN_OPCODE;
671}
672
673
674/*------------------------------------------------------------------------
675 * EXPORTED SRXAFSCB_GetLocalCell
676 *
677 * Description:
678 * Routine to return name of client's local cell
679 *
680 * Arguments:
681 * a_call : Ptr to Rx call on which this request came in.
682 * a_name : Output cell name
683 *
684 * Returns:
685 * RXGEN_OPCODE (always)
686 *
687 * Environment:
688 * Nothing interesting.
689 *
690 * Side Effects:
691 * As advertised.
692 *------------------------------------------------------------------------*/
693
694afs_int32
695SRXAFSCB_GetLocalCell(struct rx_call * a_call, char **a_name)
696{
697 char *t_name;
698
699 t_name = malloc(AFSNAMEMAX);
700 if (!t_name)
701 return ENOMEM;
702 strcpy(t_name, "This is xstat_fs");
703 *a_name = t_name;
704 return 0;
705}
706
707
708/*------------------------------------------------------------------------
709 * EXPORTED SRXAFSCB_GetCacheConfig
710 *
711 * Description:
712 * Routine to return parameters used to initialize client cache.
713 * Client may request any format version. Server may not return
714 * format version greater than version requested by client.
715 *
716 * Arguments:
717 * a_call: Ptr to Rx call on which this request came in.
718 * callerVersion: Data format version desired by the client.
719 * serverVersion: Data format version of output data.
720 * configCount: Number bytes allocated for output data.
721 * config: Client cache configuration.
722 *
723 * Returns:
724 * RXGEN_OPCODE (always)
725 *
726 * Environment:
727 * Nothing interesting.
728 *
729 * Side Effects:
730 * As advertised.
731 *------------------------------------------------------------------------*/
732
733afs_int32
734SRXAFSCB_GetCacheConfig(struct rx_call * a_call, afs_uint32 callerVersion,
735 afs_uint32 * serverVersion, afs_uint32 * configCount,
736 cacheConfig * config)
737{
738 return RXGEN_OPCODE;
739}
740
741afs_int32
742SRXAFSCB_TellMeAboutYourself(struct rx_call * rxcall,
743 struct interfaceAddr * addr,
744 Capabilities * capabilites)
745{
746#if XSTAT_FS_CALLBACK_VERBOSE
747 static char rn[] = "SRXAFSCB_TellMeAboutYourself"; /*Routine name */
748 char hostName[256]; /*Host name buffer */
749 char *hostNameResult; /*Ptr to static */
750
751 if (rxcall != (struct rx_call *)0) {
752 hostNameResult =
753 hostutil_GetNameByINet((afs_int32) (rxcall->conn->peer->host));
754 strcpy(hostName, hostNameResult);
755 fprintf(stderr, "[%s:%s] Called from host %s, port %d\n", mn, rn,
756 hostName, rxcall->conn->peer->port);
757 } /*Valid rxcall param */
758#endif /* XSTAT_FS_CALLBACK_VERBOSE */
759
760 if (rxcall && addr) {
761 if (!afs_cb_inited)
762 init_afs_cb();
763 *addr = afs_cb_interface;
764 }
765
766 /*
767 * Return successfully.
768 */
769 return (0);
770}
771
772int SRXAFSCB_GetDE(struct rx_call *a_call, afs_int32 a_index, afs_int32 addr,
773 afs_int32 inode, afs_int32 flags, afs_int32 time,
774 char **fileName)
775{
776 return RXGEN_OPCODE;
777}
openafs packaging