src/xstat/xstat_fs_callback.c

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