b1d8f5e4060389fd561f3efa2d0aa36ede5dc6df
[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, index, ce)
241     struct rx_call *rxcall;
242     afs_int32 index;
243     AFSDBCacheEntry64 *ce;
244
245 { /*SRXAFSCB_GetCE64*/
246
247 #if XSTAT_FS_CALLBACK_VERBOSE
248     static char rn[] = "SRXAFSCB_GetCE64";              /*Routine name*/
249     char hostName[256];                         /*Host name buffer*/
250     char *hostNameResult;                       /*Ptr to static*/
251
252     if (rxcall != (struct rx_call *)0) {
253         hostNameResult =
254             hostutil_GetNameByINet((afs_int32)(rxcall->conn->peer->host));
255         strcpy(hostName, hostNameResult);
256         fprintf(stderr, "[%s:%s] Called from host %s, port %d\n",
257                 mn, rn, hostName, rxcall->conn->peer->port);
258     } /*Valid rxcall param*/
259 #endif /* XSTAT_FS_CALLBACK_VERBOSE */
260
261     return(0);
262
263 } /*SRXAFSCB_GetCE64*/
264
265 afs_int32 SRXAFSCB_GetCE(rxcall, index, ce)
266     struct rx_call *rxcall;
267     afs_int32 index;
268     AFSDBCacheEntry *ce;
269
270 { /*SRXAFSCB_GetCE*/
271
272 #if XSTAT_FS_CALLBACK_VERBOSE
273     static char rn[] = "SRXAFSCB_GetCE";        /*Routine name*/
274     char hostName[256];                         /*Host name buffer*/
275     char *hostNameResult;                       /*Ptr to static*/
276
277     if (rxcall != (struct rx_call *)0) {
278         hostNameResult =
279             hostutil_GetNameByINet((afs_int32)(rxcall->conn->peer->host));
280         strcpy(hostName, hostNameResult);
281         fprintf(stderr, "[%s:%s] Called from host %s, port %d\n",
282                 mn, rn, hostName, rxcall->conn->peer->port);
283     } /*Valid rxcall param*/
284 #endif /* XSTAT_FS_CALLBACK_VERBOSE */
285
286     return(0);
287
288 } /*SRXAFSCB_GetCE*/
289
290
291 /*------------------------------------------------------------------------
292  * SRXAFSCB_GetLock
293  *
294  * Description:
295  *      Respond minimally to a request for returning the contents of
296  *      a cache lock, since someone out there thinks you're a Cache
297  *      Manager.
298  *
299  * Arguments:
300  *      struct rx_call *rxcall: Ptr to the associated Rx call structure.
301  *
302  * Returns:
303  *      0 (always)
304  *
305  * Environment:
306  *      Nothing interesting.
307  *
308  * Side Effects:
309  *      As advertised.
310  *------------------------------------------------------------------------*/
311
312 afs_int32 SRXAFSCB_GetLock(rxcall, index, lock)
313     struct rx_call *rxcall;
314     afs_int32 index;
315     AFSDBLock *lock;
316
317 { /*SRXAFSCB_GetLock*/
318
319 #if XSTAT_FS_CALLBACK_VERBOSE
320     static char rn[] = "SRXAFSCB_GetLock";      /*Routine name*/
321     char hostName[256];                         /*Host name buffer*/
322     char *hostNameResult;                       /*Ptr to static*/
323
324     if (rxcall != (struct rx_call *)0) {
325         hostNameResult =
326             hostutil_GetNameByINet((afs_int32)(rxcall->conn->peer->host));
327         strcpy(hostName, hostNameResult);
328         fprintf(stderr, "[%s:%s] Called from host %s, port %d\n",
329                 mn, rn, hostName, rxcall->conn->peer->port);
330     } /*Valid rxcall param*/
331 #endif /* XSTAT_FS_CALLBACK_VERBOSE */
332
333     return(0);
334
335 } /*SRXAFSCB_GetLock*/
336
337
338 /*------------------------------------------------------------------------
339  * SRXAFSCB_XStatsVersion
340  *
341  * Description:
342  *      Respond minimally to a request for fetching the version of
343  *      extended Cache Manager statistics offered, since someone out
344  *      there thinks you're a Cache Manager.
345  *
346  * Arguments:
347  *      struct rx_call *rxcall: Ptr to the associated Rx call structure.
348  *
349  * Returns:
350  *      0 (always)
351  *
352  * Environment:
353  *      Nothing interesting.
354  *
355  * Side Effects:
356  *      As advertised.
357  *------------------------------------------------------------------------*/
358
359 afs_int32 SRXAFSCB_XStatsVersion(rxcall, versionNumberP)
360     struct rx_call *rxcall;
361     afs_int32 *versionNumberP;
362
363 { /*SRXAFSCB_XStatsVersion*/
364
365 #if XSTAT_FS_CALLBACK_VERBOSE
366     static char rn[] = "SRXAFSCB_XStatsVersion"; /*Routine name*/
367     char hostName[256];                          /*Host name buffer*/
368     char *hostNameResult;                        /*Ptr to static*/
369
370     if (rxcall != (struct rx_call *)0) {
371         hostNameResult =
372             hostutil_GetNameByINet((afs_int32)(rxcall->conn->peer->host));
373         strcpy(hostName, hostNameResult);
374         fprintf(stderr, "[%s:%s] Called from host %s, port %d\n",
375                 mn, rn, hostName, rxcall->conn->peer->port);
376     } /*Valid rxcall param*/
377 #endif /* XSTAT_FS_CALLBACK_VERBOSE */
378
379     return(0);
380
381 } /*SRXAFSCB_XStatsVersion*/
382
383
384 /*------------------------------------------------------------------------
385  * SRXAFSCB_GetXStats
386  *
387  * Description:
388  *      Respond minimally to a request for returning extended
389  *      statistics for a Cache Manager, since someone out there thinks
390  *      you're a Cache Manager.
391  *
392  * Arguments:
393  *      struct rx_call *rxcall: Ptr to the associated Rx call structure.
394  *
395  * Returns:
396  *      0 (always)
397  *
398  * Environment:
399  *      Nothing interesting.
400  *
401  * Side Effects:
402  *      As advertised.
403  *------------------------------------------------------------------------*/
404
405 afs_int32 SRXAFSCB_GetXStats(rxcall, clientVersionNumber, collectionNumber,
406                              srvVersionNumberP, timeP, dataP)
407     struct rx_call *rxcall;
408     afs_int32 clientVersionNumber;
409     afs_int32 collectionNumber;
410     afs_int32 *srvVersionNumberP;
411     afs_int32 *timeP;
412     AFSCB_CollData *dataP;
413
414 { /*SRXAFSCB_GetXStats*/
415
416 #if XSTAT_FS_CALLBACK_VERBOSE
417     static char rn[] = "SRXAFSCB_GetXStats";    /*Routine name*/
418     char hostName[256];                         /*Host name buffer*/
419     char *hostNameResult;                       /*Ptr to static*/
420
421     if (rxcall != (struct rx_call *)0) {
422         hostNameResult =
423             hostutil_GetNameByINet((afs_int32)(rxcall->conn->peer->host));
424         strcpy(hostName, hostNameResult);
425         fprintf(stderr, "[%s:%s] Called from host %s, port %d\n",
426                 mn, rn, hostName, rxcall->conn->peer->port);
427     } /*Valid rxcall param*/
428 #endif /* XSTAT_FS_CALLBACK_VERBOSE */
429
430     return(0);
431
432 } /*SRXAFSCB_GetXStats*/
433
434 /*------------------------------------------------------------------------
435  * EXPORTED SRXAFSCB_InitCallBackState2
436  *
437  * Description:
438  *      This routine was used in the AFS 3.5 beta release, but not anymore.
439  *      It has since been replaced by SRXAFSCB_InitCallBackState3.
440  *
441  * Arguments:
442  *      rxcall : Ptr to Rx call on which this request came in.
443  *
444  * Returns:
445  *      RXGEN_OPCODE (always). 
446  *
447  * Environment:
448  *      Nothing interesting.
449  *
450  * Side Effects:
451  *      None
452  *------------------------------------------------------------------------*/
453
454 int SRXAFSCB_InitCallBackState2(rxcall, addr)
455 struct rx_call *rxcall;
456 struct interfaceAddr * addr;
457 {
458
459 #if XSTAT_FS_CALLBACK_VERBOSE
460     static char rn[] = "SRXAFSCB_InitCallBackState2";   /*Routine name*/
461     char hostName[256];                                 /*Host name buffer*/
462     char *hostNameResult;                               /*Ptr to static*/
463
464     if (rxcall != (struct rx_call *)0) {
465       hostNameResult =
466           hostutil_GetNameByINet((afs_int32)(rxcall->conn->peer->host));
467       strcpy(hostName, hostNameResult);
468       fprintf(stderr, "[%s:%s] Called from host %s, port %d\n",
469               mn, rn, hostName, rxcall->conn->peer->port);
470     } /*Valid rxcall param*/
471 #endif /* XSTAT_FS_CALLBACK_VERBOSE */
472     return RXGEN_OPCODE;
473 }
474
475 /*------------------------------------------------------------------------
476  * EXPORTED SRXAFSCB_WhoAreYou
477  *
478  * Description:
479  *      Routine called by the server-side callback RPC interface to
480  *      obtain a unique identifier for the client. The server uses
481  *      this identifier to figure out whether or not two RX connections
482  *      are from the same client, and to find out which addresses go
483  *      with which clients.
484  *
485  * Arguments:
486  *      rxcall : Ptr to Rx call on which this request came in.
487  *      addr: Ptr to return the list of interfaces for this client.
488  *
489  * Returns:
490  *      0 (Always)
491  *
492  * Environment:
493  *      Nothing interesting.
494  *
495  * Side Effects:
496  *      As advertised.
497  *------------------------------------------------------------------------*/
498
499 int SRXAFSCB_WhoAreYou(rxcall, addr)
500 struct rx_call *rxcall;
501 struct interfaceAddr *addr;
502 {
503     int i;
504     int code = 0;
505     int         count;
506
507 #if XSTAT_FS_CALLBACK_VERBOSE
508     static char rn[] = "SRXAFSCB_WhoAreYou";            /*Routine name*/
509     char hostName[256];                                 /*Host name buffer*/
510     char *hostNameResult;                               /*Ptr to static*/
511
512     if (rxcall != (struct rx_call *)0) {
513       hostNameResult =
514           hostutil_GetNameByINet((afs_int32)(rxcall->conn->peer->host));
515       strcpy(hostName, hostNameResult);
516       fprintf(stderr, "[%s:%s] Called from host %s, port %d\n",
517               mn, rn, hostName, rxcall->conn->peer->port);
518     } /*Valid rxcall param*/
519 #endif /* XSTAT_FS_CALLBACK_VERBOSE */
520
521     if ( rxcall && addr )
522     {
523         if (!afs_cb_inited) init_afs_cb();
524         *addr = afs_cb_interface;
525     }
526
527     /*
528      * Return successfully.
529      */
530     return(0);
531 }
532
533
534 /*------------------------------------------------------------------------
535  * EXPORTED SRXAFSCB_InitCallBackState3
536  *
537  * Description:
538  *      Routine called by the server-side callback RPC interface to
539  *      implement clearing all callbacks from this host.
540  *
541  * Arguments:
542  *      rxcall : Ptr to Rx call on which this request came in.
543  *
544  * Returns:
545  *      0 (always).
546  *
547  * Environment:
548  *      Nothing interesting.
549  *
550  * Side Effects:
551  *      As advertised.
552  *------------------------------------------------------------------------*/
553
554 int SRXAFSCB_InitCallBackState3(rxcall, uuidp)
555 struct rx_call *rxcall;
556 afsUUID *uuidp;
557 {
558 #if XSTAT_FS_CALLBACK_VERBOSE
559     static char rn[] = "SRXAFSCB_InitCallBackState3";   /*Routine name*/
560     char hostName[256];                                 /*Host name buffer*/
561     char *hostNameResult;                               /*Ptr to static*/
562
563     if (rxcall != (struct rx_call *)0) {
564       hostNameResult =
565           hostutil_GetNameByINet((afs_int32)(rxcall->conn->peer->host));
566       strcpy(hostName, hostNameResult);
567       fprintf(stderr, "[%s:%s] Called from host %s, port %d\n",
568               mn, rn, hostName, rxcall->conn->peer->port);
569     } /*Valid rxcall param*/
570 #endif /* XSTAT_FS_CALLBACK_VERBOSE */
571
572     /*
573      * Return successfully.
574      */
575     return(0);
576 }
577  
578
579 /*------------------------------------------------------------------------
580  * EXPORTED SRXAFSCB_ProbeUuid
581  *
582  * Description:
583  *      Routine called by the server-side callback RPC interface to
584  *      implement ``probing'' the Cache Manager, just making sure it's
585  *      still there is still the same client it used to be.
586  *
587  * Arguments:
588  *      rxcall : Ptr to Rx call on which this request came in.
589  *      uuidp : Ptr to UUID that must match the client's UUID.
590  *
591  * Returns:
592  *      0 if uuidp matches the UUID for this client
593  *      Non-zero otherwize
594  *
595  * Environment:
596  *      Nothing interesting.
597  *
598  * Side Effects:
599  *      As advertised.
600  *------------------------------------------------------------------------*/
601
602 int SRXAFSCB_ProbeUuid(rxcall, uuidp)
603 struct rx_call *rxcall;
604 afsUUID *uuidp;
605 {
606     int code = 0;
607
608 #if XSTAT_FS_CALLBACK_VERBOSE
609     static char rn[] = "SRXAFSCB_ProbeUuid";            /*Routine name*/
610     char hostName[256];                                 /*Host name buffer*/
611     char *hostNameResult;                               /*Ptr to static*/
612
613     if (rxcall != (struct rx_call *)0) {
614       hostNameResult =
615           hostutil_GetNameByINet((afs_int32)(rxcall->conn->peer->host));
616       strcpy(hostName, hostNameResult);
617       fprintf(stderr, "[%s:%s] Called from host %s, port %d\n",
618               mn, rn, hostName, rxcall->conn->peer->port);
619     } /*Valid rxcall param*/
620 #endif /* XSTAT_FS_CALLBACK_VERBOSE */
621
622     if (!afs_cb_inited) init_afs_cb();
623     if (!afs_uuid_equal(uuidp, &afs_cb_interface.uuid))
624         code = 1; /* failure */
625     return code;
626 }
627
628 /*------------------------------------------------------------------------
629  * EXPORTED SRXAFSCB_GetServerPrefs
630  *
631  * Description:
632  *      Routine to list server preferences used by this client.
633  *
634  * Arguments:
635  *      a_call  : Ptr to Rx call on which this request came in.
636  *      a_index : Input server index
637  *      a_srvr_addr  : Output server address (0xffffffff on last server)
638  *      a_srvr_rank  : Output server rank
639  *
640  * Returns:
641  *      RXGEN_OPCODE   (always)
642  *
643  * Environment:
644  *      Nothing interesting.
645  *
646  * Side Effects:
647  *      As advertised.
648  *------------------------------------------------------------------------*/
649
650 int SRXAFSCB_GetServerPrefs(
651     struct rx_call *a_call,
652     afs_int32 a_index,
653     afs_int32 *a_srvr_addr,
654     afs_int32 *a_srvr_rank)
655 {
656     return RXGEN_OPCODE;
657 }
658
659 /*------------------------------------------------------------------------
660  * EXPORTED SRXAFSCB_GetCellServDB
661  *
662  * Description:
663  *      Routine to list cells configured for this client
664  *
665  * Arguments:
666  *      a_call  : Ptr to Rx call on which this request came in.
667  *      a_index : Input cell index
668  *      a_name  : Output cell name ("" on last cell)
669  *      a_hosts : Output cell database servers
670  *
671  * Returns:
672  *      0 on success
673  *
674  * Environment:
675  *      Nothing interesting.
676  *
677  * Side Effects:
678  *      As advertised.
679  *------------------------------------------------------------------------*/
680
681 int SRXAFSCB_GetCellServDB(
682     struct rx_call *a_call,
683     afs_int32 a_index,
684     char **a_name,
685     serverList *a_hosts)
686 {
687     return RXGEN_OPCODE;
688 }
689
690
691 /*------------------------------------------------------------------------
692  * EXPORTED SRXAFSCB_GetLocalCell
693  *
694  * Description:
695  *      Routine to return name of client's local cell
696  *
697  * Arguments:
698  *      a_call  : Ptr to Rx call on which this request came in.
699  *      a_name  : Output cell name
700  *
701  * Returns:
702  *      RXGEN_OPCODE   (always)
703  *
704  * Environment:
705  *      Nothing interesting.
706  *
707  * Side Effects:
708  *      As advertised.
709  *------------------------------------------------------------------------*/
710
711 int SRXAFSCB_GetLocalCell(
712     struct rx_call *a_call,
713     char **a_name)
714 {
715     char *t_name;
716
717     t_name = (char *)malloc(AFSNAMEMAX);
718     if (!t_name)
719         return ENOMEM;
720     strcpy(t_name, "This is xstat_fs");
721     *a_name = t_name;
722     return 0;
723 }
724
725
726 /*------------------------------------------------------------------------
727  * EXPORTED SRXAFSCB_GetCacheConfig
728  *
729  * Description:
730  *      Routine to return parameters used to initialize client cache.
731  *      Client may request any format version. Server may not return
732  *      format version greater than version requested by client.
733  *
734  * Arguments:
735  *      a_call:        Ptr to Rx call on which this request came in.
736  *      callerVersion: Data format version desired by the client.
737  *      serverVersion: Data format version of output data.
738  *      configCount:   Number bytes allocated for output data.
739  *      config:        Client cache configuration.
740  *
741  * Returns:
742  *      RXGEN_OPCODE   (always)
743  *
744  * Environment:
745  *      Nothing interesting.
746  *
747  * Side Effects:
748  *      As advertised.
749  *------------------------------------------------------------------------*/
750
751 int SRXAFSCB_GetCacheConfig(
752     struct rx_call *a_call,
753     afs_uint32 callerVersion,
754     afs_uint32 *serverVersion,
755     afs_uint32 *configCount,
756     cacheConfig *config)
757 {
758     return RXGEN_OPCODE;
759 }