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