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