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