src/fsprobe/fsprobe_callback.c

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