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