src/libadmin/client/afs_clientAdmin.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 #include <afsconfig.h>
  11 #include <afs/param.h>
  12
  13
  14 #include <afs/stds.h>
  15 #include "afs_clientAdmin.h"
  16 #include "../adminutil/afs_AdminInternal.h"
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <sys/types.h>
  20 #include <afs/cellconfig.h>
  21 #ifdef AFS_NT40_ENV
  22 #include <afs/afssyscalls.h>
  23 #include <winsock2.h>
  24 #include <afs/fs_utils.h>
  25 #define close(x) closesocket(x)
  26 #else
  27 #include <sys/socket.h>
  28 #include <netinet/in.h>
  29 #include <arpa/inet.h>
  30 #include <netdb.h>
  31 #include <afs/venus.h>
  32 #include <errno.h>
  33 #include <strings.h>
  34 #include <unistd.h>
  35 #endif
  36 #include <string.h>
  37 #include <afs/kautils.h>
  38 #include <rx/rx.h>
  39 #include <rx/rxstat.h>
  40 #include <rx/rx_null.h>
  41 #include <rx/rxkad.h>
  42 #include <afs/dirpath.h>
  43 #include <afs/afs_AdminErrors.h>
  44 #include <afs/afs_vosAdmin.h>
  45 #include <afs/afs_utilAdmin.h>
  46 #include <afs/ptserver.h>
  47 #include <afs/vlserver.h>
  48 #include <afs/pthread_glock.h>
  49 #include <afs/sys_prototypes.h>
  50
  51 /*
  52  * AFS client administration functions.
  53  *
  54  * Admin functions that are normally associated with the client.
  55  *
  56  * All of the functions related to authentication are here, plus
  57  * some miscellaneous others.
  58  *
  59  */
  60
  61 static const unsigned long ADMIN_TICKET_LIFETIME = 24 * 3600;
  62
  63 static const unsigned long SERVER_TTL = 10 * 60;
  64
  65 /*
  66  * We need a way to track whether or not the client library has been
  67  * initialized.  We count on the fact that the other library initialization
  68  * functions are protected by their own once mechanism.  We only track
  69  * our own internal status
  70  */
  71
  72 static int client_init;
  73 static pthread_once_t client_init_once = PTHREAD_ONCE_INIT;
  74
  75 static void
  76 client_once(void)
  77 {
  78     client_init = 1;
  79 }
  80
  81 /*
  82  * IsTokenValid - validate a token handle
  83  *
  84  * PARAMETERS
  85  *
  86  * IN token - the token to be validated.
  87  *
  88  * LOCKS
  89  *
  90  * No locks are obtained or released by this function
  91  *
  92  * CAUTIONS
  93  *
  94  * None.
  95  *
  96  * RETURN CODES
  97  *
  98  * Returns != 0 upon successful completion.
  99  */
 100
 101 static int
 102 IsTokenValid(const afs_token_handle_p token, afs_status_p st)
 103 {
 104     int rc = 0;
 105     afs_status_t tst = 0;
 106
 107     if (token == NULL) {
 108         tst = ADMCLIENTTOKENHANDLENULL;
 109         goto fail_IsTokenValid;
 110     }
 111
 112     if (token->is_valid == 0) {
 113         tst = ADMCLIENTTOKENHANDLEINVALID;
 114         goto fail_IsTokenValid;
 115     }
 116
 117     if ((token->begin_magic != BEGIN_MAGIC)
 118         || (token->end_magic != END_MAGIC)) {
 119         tst = ADMCLIENTTOKENHANDLEBADMAGIC;
 120         goto fail_IsTokenValid;
 121     }
 122     rc = 1;
 123
 124   fail_IsTokenValid:
 125
 126     if (st != NULL) {
 127         *st = tst;
 128     }
 129     return rc;
 130 }
 131
 132 /*
 133  * afsclient_TokenGetExisting - get tokens that already exist and
 134  * are held by the cache manager.
 135  *
 136  * PARAMETERS
 137  *
 138  * IN cellName - the name of the cell where the token originated.
 139  *
 140  * OUT tokenHandle - a handle to the tokens if they were obtained
 141  * successfully.
 142  *
 143  * LOCKS
 144  *
 145  * No locks are obtained or released by this function
 146  *
 147  * CAUTIONS
 148  *
 149  * The tokenHandle returned by this function cannot be used for kas
 150  * related operations, since kas tokens aren't stored in the kernel.
 151  *
 152  * RETURN CODES
 153  *
 154  * Returns != 0 upon successful completion.
 155  */
 156
 157 int ADMINAPI
 158 afsclient_TokenGetExisting(const char *cellName, void **tokenHandle,
 159                            afs_status_p st)
 160 {
 161     int rc = 0;
 162     afs_status_t tst = 0;
 163     struct ktc_principal afs_server;
 164     afs_token_handle_p t_handle =
 165         (afs_token_handle_p) calloc(1, sizeof(afs_token_handle_t));
 166
 167     if (client_init == 0) {
 168         tst = ADMCLIENTNOINIT;
 169         goto fail_afsclient_TokenGetExisting;
 170     }
 171
 172     if (cellName == NULL) {
 173         tst = ADMCLIENTCELLNAMENULL;
 174         goto fail_afsclient_TokenGetExisting;
 175     }
 176
 177     if (tokenHandle == NULL) {
 178         tst = ADMCLIENTTOKENHANDLENULL;
 179         goto fail_afsclient_TokenGetExisting;
 180     }
 181
 182     if (t_handle == NULL) {
 183         tst = ADMNOMEM;
 184         goto fail_afsclient_TokenGetExisting;
 185     }
 186
 187     strcpy(afs_server.name, "afs");
 188     afs_server.instance[0] = 0;
 189     strcpy(afs_server.cell, cellName);
 190
 191     if (!
 192         (tst =
 193          ktc_GetToken(&afs_server, &t_handle->afs_token,
 194                       sizeof(t_handle->afs_token), &t_handle->client))) {
 195         /*
 196          * The token has been retrieved successfully, initialize
 197          * the rest of the token handle structure
 198          */
 199         strncpy(t_handle->cell, cellName, MAXCELLCHARS);
 200         t_handle->cell[MAXCELLCHARS - 1] = '\0';
 201         t_handle->afs_token_set = 1;
 202         t_handle->from_kernel = 1;
 203         t_handle->kas_token_set = 0;
 204         t_handle->sc_index = 2;
 205         t_handle->afs_sc[t_handle->sc_index] =
 206             rxkad_NewClientSecurityObject(rxkad_clear,
 207                                           &t_handle->afs_token.sessionKey,
 208                                           t_handle->afs_token.kvno,
 209                                           t_handle->afs_token.ticketLen,
 210                                           t_handle->afs_token.ticket);
 211         t_handle->afs_encrypt_sc[t_handle->sc_index] =
 212             rxkad_NewClientSecurityObject(rxkad_crypt,
 213                                           &t_handle->afs_token.sessionKey,
 214                                           t_handle->afs_token.kvno,
 215                                           t_handle->afs_token.ticketLen,
 216                                           t_handle->afs_token.ticket);
 217         if ((t_handle->afs_sc[t_handle->sc_index] == NULL)
 218             || (t_handle->afs_sc[t_handle->sc_index] == NULL)) {
 219             tst = ADMCLIENTTOKENHANDLENOSECURITY;
 220             goto fail_afsclient_TokenGetExisting;
 221         } else {
 222             t_handle->begin_magic = BEGIN_MAGIC;
 223             t_handle->is_valid = 1;
 224             t_handle->end_magic = END_MAGIC;
 225             *tokenHandle = (void *)t_handle;
 226         }
 227     } else {
 228         goto fail_afsclient_TokenGetExisting;
 229     }
 230     rc = 1;
 231
 232   fail_afsclient_TokenGetExisting:
 233
 234     if ((rc == 0) && (t_handle != NULL)) {
 235         free(t_handle);
 236     }
 237     if (st != NULL) {
 238         *st = tst;
 239     }
 240     return rc;
 241 }
 242
 243 /*
 244  * afsclient_TokenSet - set the tokens represented by tokenHandle to be
 245  * active in the kernel (aka ka_SetToken).
 246  *
 247  * PARAMETERS
 248  *
 249  * IN cellName - the name of the cell where the token originated.
 250  *
 251  * OUT tokenHandle - a handle to the tokens if they were obtained
 252  * successfully.
 253  *
 254  * LOCKS
 255  *
 256  * No locks are obtained or released by this function
 257  *
 258  * CAUTIONS
 259  *
 260  * The tokenHandle returned by this function cannot be used for kas
 261  * related operations, since kas tokens aren't stored in the kernel.
 262  *
 263  * RETURN CODES
 264  *
 265  * Returns != 0 upon successful completion.
 266  */
 267
 268 int ADMINAPI
 269 afsclient_TokenSet(const void *tokenHandle, afs_status_p st)
 270 {
 271     int rc = 0;
 272     afs_status_t tst = 0;
 273     struct ktc_principal afs_server;
 274     afs_token_handle_p t_handle = (afs_token_handle_p) tokenHandle;
 275
 276     if (!IsTokenValid(t_handle, &tst)) {
 277         goto fail_afsclient_TokenSet;
 278     }
 279
 280     strcpy(afs_server.name, "afs");
 281     afs_server.instance[0] = 0;
 282     strcpy(afs_server.cell, t_handle->cell);
 283
 284     tst =
 285         ktc_SetToken(&afs_server, &t_handle->afs_token, &t_handle->client, 0);
 286
 287     if (!tst) {
 288         rc = 1;
 289     }
 290
 291   fail_afsclient_TokenSet:
 292
 293     if (st != NULL) {
 294         *st = tst;
 295     }
 296     return rc;
 297 }
 298
 299 /*
 300  * GetKASToken - get a KAS token and store it in the tokenHandle.
 301  *
 302  * PARAMETERS
 303  *
 304  * IN cellName - the name of the cell where the token should be obtained.
 305  *
 306  * IN principal - the name of the user of the token.
 307  *
 308  * IN password - the password for the principal.
 309  *
 310  * OUT tokenHandle - a handle to the tokens if they were obtained
 311  * successfully.
 312  *
 313  * LOCKS
 314  *
 315  * No locks are obtained or released by this function
 316  *
 317  * CAUTIONS
 318  *
 319  * None.
 320  *
 321  * RETURN CODES
 322  *
 323  * Returns != 0 upon successful completion.
 324  */
 325
 326 static int
 327 GetKASToken(const char *cellName, const char *principal, const char *password,
 328             afs_token_handle_p tokenHandle, afs_status_p st)
 329 {
 330     int rc = 0;
 331     afs_status_t tst = 0;
 332     struct ubik_client *unauth_conn;
 333     afs_int32 expire;
 334     struct ktc_encryptionKey key;
 335     struct ktc_token *token;
 336     unsigned long now = time(0);
 337     char name[MAXKTCNAMELEN];
 338     char inst[MAXKTCNAMELEN];
 339     int have_server_conn = 0;
 340
 341     token = &tokenHandle->kas_token;
 342
 343     ka_StringToKey((char *)password, (char *)cellName, &key);
 344
 345     /*
 346      * Get an unauthenticated connection in the right cell to use for
 347      * retrieving the token.
 348      */
 349
 350     tst =
 351         ka_AuthServerConn((char *)cellName, KA_AUTHENTICATION_SERVICE, 0,
 352                           &unauth_conn);
 353     if (tst != 0) {
 354         goto fail_GetKASToken;
 355     }
 356     have_server_conn = 1;
 357
 358     tst = ka_ParseLoginName((char *)principal, name, inst, NULL);
 359     if (tst != 0) {
 360         goto fail_GetKASToken;
 361     }
 362
 363     tst =
 364         ka_Authenticate(name, inst, (char *)cellName, unauth_conn,
 365                         KA_MAINTENANCE_SERVICE, &key, now,
 366                         now + ADMIN_TICKET_LIFETIME, token, &expire);
 367     if (tst != 0) {
 368         goto fail_GetKASToken;
 369     }
 370     rc = 1;
 371
 372   fail_GetKASToken:
 373
 374     if (have_server_conn) {
 375         ubik_ClientDestroy(unauth_conn);
 376     }
 377
 378     if (st != NULL) {
 379         *st = tst;
 380     }
 381     return rc;
 382 }
 383
 384 /*
 385  * GetAFSToken - get a AFS token and store it in the tokenHandle.
 386  *
 387  * PARAMETERS
 388  *
 389  * IN cellName - the name of the cell where the token should be obtained.
 390  *
 391  * IN principal - the name of the user of the token.
 392  *
 393  * IN password - the password for the principal.
 394  *
 395  * OUT tokenHandle - a handle to the tokens if they were obtained
 396  * successfully.
 397  *
 398  * LOCKS
 399  *
 400  * No locks are obtained or released by this function
 401  *
 402  * CAUTIONS
 403  *
 404  * None.
 405  *
 406  * RETURN CODES
 407  *
 408  * Returns != 0 upon successful completion.
 409  */
 410
 411 static int
 412 GetAFSToken(const char *cellName, const char *principal, const char *password,
 413             afs_token_handle_p tokenHandle, afs_status_p st)
 414 {
 415     int rc = 0;
 416     afs_status_t tst = 0;
 417     struct ubik_client *unauth_conn = NULL, *auth_conn = NULL;
 418     afs_int32 expire;
 419     struct ktc_encryptionKey key;
 420     struct ktc_token auth_token;
 421     struct ktc_token *token;
 422     unsigned long now = time(0);
 423
 424     token = &tokenHandle->afs_token;
 425
 426     ka_StringToKey((char *)password, (char *)cellName, &key);
 427
 428     /*
 429      * Get an unauthenticated connection in the right cell to use for
 430      * retrieving the token.
 431      */
 432
 433     tst =
 434         ka_AuthServerConn((char *)cellName, KA_AUTHENTICATION_SERVICE, 0,
 435                           &unauth_conn);
 436     if (tst) {
 437         goto fail_GetAFSToken;
 438     }
 439
 440     tst =
 441         ka_ParseLoginName((char *)principal, tokenHandle->client.name,
 442                           tokenHandle->client.instance, NULL);
 443     if (tst) {
 444         goto fail_GetAFSToken;
 445     }
 446
 447     tst =
 448         ka_Authenticate(tokenHandle->client.name,
 449                         tokenHandle->client.instance, (char *)cellName,
 450                         unauth_conn, KA_TICKET_GRANTING_SERVICE, &key, now,
 451                         now + ADMIN_TICKET_LIFETIME, &auth_token, &expire);
 452     if (tst) {
 453         goto fail_GetAFSToken;
 454     }
 455
 456     tst =
 457         ka_AuthServerConn((char *)cellName, KA_TICKET_GRANTING_SERVICE, 0,
 458                           &auth_conn);
 459     if (tst) {
 460         goto fail_GetAFSToken;
 461     }
 462
 463     tst =
 464         ka_CellToRealm((char *)cellName, tokenHandle->client.cell, (int *)0);
 465     if (tst) {
 466         goto fail_GetAFSToken;
 467     }
 468
 469     tst =
 470         ka_GetToken("afs", "", (char *)cellName, tokenHandle->client.name,
 471                     tokenHandle->client.instance, auth_conn, now,
 472                     now + ADMIN_TICKET_LIFETIME, &auth_token,
 473                     tokenHandle->client.cell, token);
 474     if (tst) {
 475         goto fail_GetAFSToken;
 476     }
 477     rc = 1;
 478
 479   fail_GetAFSToken:
 480
 481     if (auth_conn) {
 482         ubik_ClientDestroy(auth_conn);
 483     }
 484
 485     if (unauth_conn) {
 486         ubik_ClientDestroy(unauth_conn);
 487     }
 488
 489     if (st != NULL) {
 490         *st = tst;
 491     }
 492     return rc;
 493 }
 494
 495
 496 /*
 497  * afsclient_TokenGetNew - get new tokens for a user and store them
 498  * in the tokenHandle.
 499  *
 500  * PARAMETERS
 501  *
 502  * IN cellName - the name of the cell where the tokens should be obtained.
 503  *
 504  * IN principal - the name of the user of the tokens.
 505  *
 506  * IN password - the password for the principal.
 507  *
 508  * OUT tokenHandle - a handle to the tokens if they were obtained
 509  * successfully.
 510  *
 511  * LOCKS
 512  *
 513  * No locks are obtained or released by this function
 514  *
 515  * CAUTIONS
 516  *
 517  * None.
 518  *
 519  * RETURN CODES
 520  *
 521  * Returns != 0 upon successful completion.
 522  */
 523
 524 int ADMINAPI
 525 afsclient_TokenGetNew(const char *cellName, const char *principal,
 526                       const char *password, void **tokenHandle,
 527                       afs_status_p st)
 528 {
 529     int rc = 0;
 530     afs_status_t tst = 0;
 531     afs_token_handle_p t_handle =
 532         (afs_token_handle_p) calloc(1, sizeof(afs_token_handle_t));
 533
 534     if (client_init == 0) {
 535         tst = ADMCLIENTNOINIT;
 536         goto fail_afsclient_TokenGetNew;
 537     }
 538
 539     if (t_handle == NULL) {
 540         tst = ADMNOMEM;
 541         goto fail_afsclient_TokenGetNew;
 542     }
 543
 544     /*
 545      * Check to see if the principal or password is missing.  If it is,
 546      * get unauthenticated tokens for the cell
 547      */
 548
 549     if ((principal == NULL) || (*principal == 0) || (password == NULL)
 550         || (*password == 0)) {
 551         t_handle->from_kernel = 0;
 552         t_handle->afs_token_set = 1;
 553         t_handle->kas_token_set = 1;
 554         t_handle->sc_index = 0;
 555         t_handle->afs_sc[t_handle->sc_index] =
 556             rxnull_NewClientSecurityObject();
 557         t_handle->afs_encrypt_sc[t_handle->sc_index] =
 558             rxnull_NewClientSecurityObject();
 559         t_handle->kas_sc[t_handle->sc_index] =
 560             rxnull_NewClientSecurityObject();
 561         t_handle->begin_magic = BEGIN_MAGIC;
 562         t_handle->is_valid = 1;
 563         t_handle->afs_token.endTime = 0;
 564         t_handle->end_magic = END_MAGIC;
 565         *tokenHandle = (void *)t_handle;
 566
 567     } else {
 568
 569         /*
 570          * create an authenticated token
 571          */
 572
 573         if ((GetAFSToken(cellName, principal, password, t_handle, &tst))
 574             && (GetKASToken(cellName, principal, password, t_handle, &tst))) {
 575             strncpy(t_handle->cell, cellName, MAXCELLCHARS);
 576             t_handle->cell[MAXCELLCHARS - 1] = '\0';
 577             t_handle->from_kernel = 0;
 578             t_handle->afs_token_set = 1;
 579             t_handle->kas_token_set = 1;
 580             t_handle->sc_index = 2;
 581             t_handle->afs_sc[t_handle->sc_index] =
 582                 rxkad_NewClientSecurityObject(rxkad_clear,
 583                                               &t_handle->afs_token.sessionKey,
 584                                               t_handle->afs_token.kvno,
 585                                               t_handle->afs_token.ticketLen,
 586                                               t_handle->afs_token.ticket);
 587             t_handle->afs_encrypt_sc[t_handle->sc_index] =
 588                 rxkad_NewClientSecurityObject(rxkad_crypt,
 589                                               &t_handle->afs_token.sessionKey,
 590                                               t_handle->afs_token.kvno,
 591                                               t_handle->afs_token.ticketLen,
 592                                               t_handle->afs_token.ticket);
 593             t_handle->kas_sc[t_handle->sc_index] =
 594                 rxkad_NewClientSecurityObject(rxkad_crypt,
 595                                               &t_handle->kas_token.sessionKey,
 596                                               t_handle->kas_token.kvno,
 597                                               t_handle->kas_token.ticketLen,
 598                                               t_handle->kas_token.ticket);
 599             if ((t_handle->afs_sc[t_handle->sc_index] != NULL)
 600                 && (t_handle->afs_encrypt_sc[t_handle->sc_index] != NULL)
 601                 && (t_handle->kas_sc[t_handle->sc_index] != NULL)) {
 602                 t_handle->begin_magic = BEGIN_MAGIC;
 603                 t_handle->is_valid = 1;
 604                 t_handle->end_magic = END_MAGIC;
 605                 *tokenHandle = (void *)t_handle;
 606             } else {
 607                 tst = ADMCLIENTTOKENHANDLENOSECURITY;
 608                 goto fail_afsclient_TokenGetNew;
 609             }
 610         } else {
 611             goto fail_afsclient_TokenGetNew;
 612         }
 613     }
 614     rc = 1;
 615
 616   fail_afsclient_TokenGetNew:
 617
 618     if ((rc == 0) && (t_handle != NULL)) {
 619         free(t_handle);
 620     }
 621
 622     if (st != NULL) {
 623         *st = tst;
 624     }
 625     return rc;
 626 }
 627
 628 /*
 629  * afsclient_TokenQuery - get the expiration time of the tokens.
 630  *
 631  * PARAMETERS
 632  *
 633  * IN tokenHandle - a previously obtained valid token.
 634  *
 635  * OUT expirationDateP - the time at which the tokens expire.
 636  *
 637  * OUT principal - the owning principal
 638  *
 639  * OUT instance - principal instance if it exists.
 640  *
 641  * OUT cell - the principal's cell
 642  *
 643  * OUT hasKasTokens - set to 1 if the token handle contains kas tokens.
 644  *
 645  * LOCKS
 646  *
 647  * No locks are obtained or released by this function
 648  *
 649  * CAUTIONS
 650  *
 651  * We only check the AFS tokens since we always get these.  The
 652  * KAS tokens may expirer later than the AFS tokens, but this
 653  * difference is minor and reporting an earlier time won't cause
 654  * the user problems.
 655  *
 656  * RETURN CODES
 657  *
 658  * Returns != 0 upon successful completion.
 659  */
 660
 661 int ADMINAPI
 662 afsclient_TokenQuery(void *tokenHandle, unsigned long *expirationDateP,
 663                      char *principal, char *instance, char *cell,
 664                      int *hasKasTokens, afs_status_p st)
 665 {
 666     int rc = 0;
 667     afs_status_t tst = 0;
 668     afs_token_handle_p t_handle = (afs_token_handle_p) tokenHandle;
 669
 670     if (client_init == 0) {
 671         tst = ADMCLIENTNOINIT;
 672         rc = 0;
 673         goto fail_afsclient_TokenQuery;
 674     }
 675
 676     if (IsTokenValid(t_handle, &tst)) {
 677         if (principal != NULL) {
 678             strcpy(principal, t_handle->client.name);
 679         }
 680         if (instance != NULL) {
 681             strcpy(instance, t_handle->client.instance);
 682         }
 683         if (cell != NULL) {
 684             strcpy(cell, t_handle->client.cell);
 685         }
 686         if (hasKasTokens != NULL) {
 687             *hasKasTokens = t_handle->kas_token_set;
 688         }
 689         if (expirationDateP != NULL) {
 690             *expirationDateP = t_handle->afs_token.endTime;
 691         }
 692         rc = 1;
 693     }
 694
 695   fail_afsclient_TokenQuery:
 696
 697     if (st != NULL) {
 698         *st = tst;
 699     }
 700     return rc;
 701 }
 702
 703 /*
 704  * afsclient_TokenClose - close an existing token.
 705  *
 706  * PARAMETERS
 707  *
 708  * IN token - the token to be closed.
 709  *
 710  * LOCKS
 711  *
 712  * No locks are obtained or released by this function
 713  *
 714  * CAUTIONS
 715  *
 716  * None.
 717  *
 718  * RETURN CODES
 719  *
 720  * Returns != 0 upon successful completion.
 721  */
 722
 723 int ADMINAPI
 724 afsclient_TokenClose(const void *tokenHandle, afs_status_p st)
 725 {
 726     int rc = 0;
 727     afs_status_t tst = 0;
 728     afs_token_handle_p t_handle = (afs_token_handle_p) tokenHandle;
 729
 730     if (client_init == 0) {
 731         tst = ADMCLIENTNOINIT;
 732         goto fail_afsclient_TokenClose;
 733     }
 734
 735     if (IsTokenValid(t_handle, &tst)) {
 736         t_handle->is_valid = 0;
 737         free(t_handle);
 738         rc = 1;
 739     }
 740
 741   fail_afsclient_TokenClose:
 742
 743     if (st != NULL) {
 744         *st = tst;
 745     }
 746     return rc;
 747 }
 748
 749 #define NUM_SERVER_TYPES 3
 750
 751 /* must match NUM_SERVER_TYPES */
 752 typedef enum { KAS, PTS, VOS } afs_server_list_t;
 753
 754 typedef struct afs_server {
 755     char *serv;
 756     int serviceId;
 757     struct ubik_client **ubik;
 758     struct rx_securityClass *sc;
 759     int *valid;
 760 } afs_server_t, *afs_server_p;
 761
 762 /*
 763  * afsclient_CellOpen - Open a particular cell for work as a particular
 764  * user.
 765  *
 766  * PARAMETERS
 767  *
 768  * IN cellName - the cell where future admin calls will be made.
 769  *
 770  * IN tokenHandle - the tokens work will be done under.
 771  *
 772  * OUT cellHandleP - an opaque pointer that is the first parameter to
 773  * almost all subsequent admin api calls.
 774  *
 775  * LOCKS
 776  *
 777  * No locks are obtained or released by this function
 778  *
 779  * CAUTIONS
 780  *
 781  * None.
 782  *
 783  * RETURN CODES
 784  *
 785  * Returns != 0 upon successful completion.
 786  */
 787
 788 int ADMINAPI
 789 afsclient_CellOpen(const char *cellName, const void *tokenHandle,
 790                    void **cellHandleP, afs_status_p st)
 791 {
 792     int rc = 0;
 793     afs_status_t tst = 0;
 794     afs_token_handle_p t_handle = (afs_token_handle_p) tokenHandle;
 795     afs_cell_handle_p c_handle = (afs_cell_handle_p)
 796         calloc(1, sizeof(afs_cell_handle_t));
 797     struct afsconf_dir *tdir = NULL;
 798     struct afsconf_cell info;
 799     struct rx_connection *serverconns[MAXSERVERS];
 800     int i, j;
 801     struct rx_securityClass *sc[3];
 802     int scIndex;
 803     char copyCell[MAXCELLCHARS];
 804
 805     afs_server_t servers[NUM_SERVER_TYPES]
 806       = { {AFSCONF_KAUTHSERVICE, KA_MAINTENANCE_SERVICE, 0, 0, 0},
 807           {AFSCONF_PROTSERVICE, PRSRV, 0, 0, 0},
 808           {AFSCONF_VLDBSERVICE, USER_SERVICE_ID, 0, 0, 0}
 809       };
 810
 811     if (client_init == 0) {
 812         tst = ADMCLIENTNOINIT;
 813         goto fail_afsclient_CellOpen;
 814     }
 815
 816     if (c_handle == NULL) {
 817         tst = ADMNOMEM;
 818         goto fail_afsclient_CellOpen;
 819     }
 820
 821     if (t_handle == NULL) {
 822         tst = ADMCLIENTTOKENHANDLENULL;
 823         goto fail_afsclient_CellOpen;
 824     }
 825
 826     if ((cellName == NULL) || (*cellName == 0)) {
 827         tst = ADMCLIENTCELLNAMENULL;
 828         goto fail_afsclient_CellOpen;
 829     }
 830
 831     if (cellHandleP == NULL) {
 832         tst = ADMCLIENTCELLHANDLEPNULL;
 833         goto fail_afsclient_CellOpen;
 834     }
 835
 836     /*
 837      * Check that the token handle contains valid data and the calloc
 838      * succeeded
 839      */
 840     if (!t_handle->afs_token_set) {
 841         tst = ADMCLIENTCELLOPENBADTOKEN;
 842         goto fail_afsclient_CellOpen;
 843     }
 844
 845     /*
 846      * Use a table to initialize the cell handle structure, since
 847      * most of the steps are the same for all the servers.
 848      *
 849      * Start by creating rx_securityClass objects for each of the
 850      * servers.  A potential optimization is to do this in
 851      * afsclient_TokenGetNew and just keep the expiration time of
 852      * the tokens around.
 853      * Also, initialize the ubik client pointers in the table
 854      */
 855     servers[KAS].sc = t_handle->kas_sc[t_handle->sc_index];
 856     servers[PTS].sc = t_handle->afs_sc[t_handle->sc_index];
 857     servers[VOS].sc = servers[PTS].sc;
 858     servers[KAS].ubik = &c_handle->kas;
 859     servers[PTS].ubik = &c_handle->pts;
 860     servers[VOS].ubik = &c_handle->vos;
 861     servers[KAS].valid = &c_handle->kas_valid;
 862     servers[PTS].valid = &c_handle->pts_valid;
 863     servers[VOS].valid = &c_handle->vos_valid;
 864     c_handle->vos_new = 1;
 865
 866     if ((servers[PTS].sc == NULL) || (servers[VOS].sc == NULL)) {
 867         tst = ADMCLIENTBADTOKENHANDLE;
 868         goto fail_afsclient_CellOpen;
 869     }
 870
 871     /*
 872      * If the initialization has succeeded so far, get the address
 873      * information for each server in the cell
 874      */
 875
 876     strncpy(c_handle->working_cell, cellName, MAXCELLCHARS);
 877     c_handle->working_cell[MAXCELLCHARS - 1] = '\0';
 878     if (!(tdir = afsconf_Open(AFSDIR_CLIENT_ETC_DIRPATH))) {
 879         tst = ADMCLIENTBADCLIENTCONFIG;
 880         goto fail_afsclient_CellOpen;
 881     }
 882
 883     /*
 884      * We must copy the cellName here because afsconf_GetCellInfo
 885      * actually writes over the cell name it is passed.
 886      */
 887     strncpy(copyCell, cellName, MAXCELLCHARS);
 888     copyCell[MAXCELLCHARS - 1] ='\0';
 889     for (i = 0; (i < NUM_SERVER_TYPES); i++) {
 890         if (i == KAS) {
 891             tst =
 892                 ka_AuthServerConn((char *)cellName, servers[i].serviceId,
 893                                   ((t_handle->sc_index == 0)
 894                                    || (!t_handle->
 895                                        kas_token_set)) ? 0 : &t_handle->
 896                                   kas_token, servers[i].ubik);
 897             if (tst) {
 898                 goto fail_afsclient_CellOpen;
 899             }
 900         } else {
 901             tst = afsconf_GetCellInfo(tdir, copyCell, servers[i].serv, &info);
 902             if (!tst) {
 903                 /* create ubik client handles for each server */
 904                 scIndex = t_handle->sc_index;
 905                 sc[scIndex] = servers[i].sc;
 906                 for (j = 0; (j < info.numServers); j++) {
 907                     serverconns[j] =
 908                         rx_GetCachedConnection(info.hostAddr[j].sin_addr.
 909                                                s_addr,
 910                                                info.hostAddr[j].sin_port,
 911                                                servers[i].serviceId,
 912                                                sc[scIndex], scIndex);
 913                 }
 914                 serverconns[j] = 0;
 915                 tst = ubik_ClientInit(serverconns, servers[i].ubik);
 916                 if (tst) {
 917                     goto fail_afsclient_CellOpen;
 918                 }
 919             } else {
 920                 goto fail_afsclient_CellOpen;
 921             }
 922         }
 923         /* initialization complete, mark handle valid */
 924         *servers[i].valid = 1;
 925     }
 926     c_handle->tokens = t_handle;
 927     rc = 1;
 928
 929   fail_afsclient_CellOpen:
 930
 931     if (tdir) {
 932         afsconf_Close(tdir);
 933     }
 934
 935     /*
 936      * Upon error, free any obtained resources.
 937      */
 938     if (rc == 0) {
 939         if (c_handle != NULL) {
 940             if (c_handle->kas_valid)
 941                 ubik_ClientDestroy(c_handle->kas);
 942             if (c_handle->pts_valid)
 943                 ubik_ClientDestroy(c_handle->pts);
 944             if (c_handle->vos_valid)
 945                 ubik_ClientDestroy(c_handle->vos);
 946             free(c_handle);
 947         }
 948     } else {
 949         c_handle->begin_magic = BEGIN_MAGIC;
 950         c_handle->is_valid = 1;
 951         c_handle->is_null = 0;
 952         c_handle->server_list = NULL;
 953         c_handle->server_ttl = 0;
 954         c_handle->end_magic = END_MAGIC;
 955         *cellHandleP = (void *)c_handle;
 956     }
 957
 958     if (st != NULL) {
 959         *st = tst;
 960     }
 961     return rc;
 962 }
 963
 964 /*
 965  * afsclient_NullCellOpen - open a null cell handle for access.
 966  *
 967  * PARAMETERS
 968  *
 969  * OUT cellHandleP - an opaque pointer that is the first parameter to
 970  * almost all subsequent admin api calls.
 971  *
 972  * LOCKS
 973  *
 974  * No locks are obtained or released by this function
 975  *
 976  * CAUTIONS
 977  *
 978  * None.
 979  *
 980  * RETURN CODES
 981  *
 982  * Returns != 0 upon successful completion.
 983  */
 984
 985 int ADMINAPI
 986 afsclient_NullCellOpen(void **cellHandleP, afs_status_p st)
 987 {
 988     int rc = 0;
 989     afs_status_t tst = 0;
 990     afs_cell_handle_p c_handle = (afs_cell_handle_p)
 991         calloc(1, sizeof(afs_cell_handle_t));
 992
 993
 994     /*
 995      * Validate parameters
 996      */
 997
 998     if (cellHandleP == NULL) {
 999         tst = ADMCLIENTCELLHANDLEPNULL;
1000         goto fail_afsclient_NullCellOpen;
1001     }
1002
1003     if (client_init == 0) {
1004         tst = ADMCLIENTNOINIT;
1005         goto fail_afsclient_NullCellOpen;
1006     }
1007
1008     if (c_handle == NULL) {
1009         tst = ADMNOMEM;
1010         goto fail_afsclient_NullCellOpen;
1011     }
1012
1013     /*
1014      * Get unauthenticated tokens for any cell
1015      */
1016
1017     if (!afsclient_TokenGetNew(0, 0, 0, (void *)&c_handle->tokens, &tst)) {
1018         goto fail_afsclient_NullCellOpen;
1019     }
1020
1021     c_handle->begin_magic = BEGIN_MAGIC;
1022     c_handle->is_valid = 1;
1023     c_handle->is_null = 1;
1024     c_handle->end_magic = END_MAGIC;
1025     c_handle->kas_valid = 0;
1026     c_handle->pts_valid = 0;
1027     c_handle->vos_valid = 0;
1028     c_handle->kas = NULL;
1029     c_handle->pts = NULL;
1030     c_handle->vos = NULL;
1031     c_handle->server_list = NULL;
1032     c_handle->server_ttl = 0;
1033     *cellHandleP = (void *)c_handle;
1034     rc = 1;
1035
1036   fail_afsclient_NullCellOpen:
1037
1038     if (st != NULL) {
1039         *st = tst;
1040     }
1041     return rc;
1042 }
1043
1044 /*
1045  * afsclient_CellClose - close a previously opened cellHandle.
1046  *
1047  * PARAMETERS
1048  *
1049  * IN cellHandle - a cellHandle created by afsclient_CellOpen.
1050  *
1051  * LOCKS
1052  *
1053  * No locks are obtained or released by this function
1054  *
1055  * CAUTIONS
1056  *
1057  * None.
1058  *
1059  * RETURN CODES
1060  *
1061  * Returns != 0 upon successful completion.
1062  */
1063
1064 int ADMINAPI
1065 afsclient_CellClose(const void *cellHandle, afs_status_p st)
1066 {
1067     int rc = 0;
1068     afs_status_t tst = 0;
1069     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
1070
1071     if (client_init == 0) {
1072         tst = ADMCLIENTNOINIT;
1073         goto fail_afsclient_CellClose;
1074     }
1075
1076     if (c_handle == NULL) {
1077         tst = ADMCLIENTCELLHANDLENULL;
1078         goto fail_afsclient_CellClose;
1079     }
1080
1081     if (c_handle->server_list)
1082         free(c_handle->server_list);
1083     if (c_handle->kas_valid)
1084         ubik_ClientDestroy(c_handle->kas);
1085     if (c_handle->pts_valid)
1086         ubik_ClientDestroy(c_handle->pts);
1087     if (c_handle->vos_valid)
1088         ubik_ClientDestroy(c_handle->vos);
1089     if (c_handle->is_null)
1090         afsclient_TokenClose(c_handle->tokens, 0);
1091     c_handle->kas_valid = 0;
1092     c_handle->pts_valid = 0;
1093     c_handle->vos_valid = 0;
1094     c_handle->is_valid = 0;
1095     free(c_handle);
1096     rc = 1;
1097
1098   fail_afsclient_CellClose:
1099
1100     if (st != NULL) {
1101         *st = tst;
1102     }
1103     return rc;
1104 }
1105
1106
1107 /*
1108  * afsclient_CellNameGet() -- get a pointer to the cell name in a cell handle
1109  *
1110  * PARAMETERS
1111  *
1112  * IN  cellHandle - a valid cell handle
1113  * OUT cellNameP  - a pointer to the cell name in the cell handle.
1114  *
1115  * LOCKS
1116  *
1117  * No locks are obtained or released by this function
1118  *
1119  * CAUTIONS
1120  *
1121  * If cellHandle is closed then the pointer returned by this function
1122  * is no longer valid.
1123  *
1124  * RETURN CODES
1125  *
1126  * Returns != 0 upon successful completion.
1127  */
1128 int ADMINAPI
1129 afsclient_CellNameGet(const void *cellHandle, const char **cellNameP,
1130                       afs_status_p st)
1131 {
1132     int rc = 0;
1133     afs_status_t tst = 0;
1134     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
1135
1136     if (!CellHandleIsValid(cellHandle, &tst)) {
1137         goto fail_afsclient_CellNameGet;
1138     }
1139
1140     *cellNameP = c_handle->working_cell;
1141     rc = 1;
1142
1143   fail_afsclient_CellNameGet:
1144
1145     if (st != NULL) {
1146         *st = tst;
1147     }
1148     return rc;
1149 }
1150
1151
1152 /*
1153  * afsclient_LocalCellGet - get the name of the cell the machine
1154  * belongs to where this process is running.
1155  *
1156  * PARAMETERS
1157  *
1158  * OUT cellName - an array of characters that must be MAXCELLCHARS
1159  * long.
1160  *
1161  * LOCKS
1162  *
1163  * No locks are obtained or released by this function
1164  *
1165  * CAUTIONS
1166  *
1167  * If cellName is smaller than MAXCELLCHARS chars, this function won't
1168  * detect it.
1169  *
1170  * RETURN CODES
1171  *
1172  * Returns != 0 upon successful completion.
1173  */
1174
1175 int ADMINAPI
1176 afsclient_LocalCellGet(char *cellName, afs_status_p st)
1177 {
1178     int rc = 0;
1179     afs_status_t tst = 0;
1180     struct afsconf_dir *tdir = NULL;
1181
1182     if (client_init == 0) {
1183         tst = ADMCLIENTNOINIT;
1184         goto fail_afsclient_LocalCellGet;
1185     }
1186
1187     if (cellName == NULL) {
1188         tst = ADMCLIENTCELLNAMENULL;
1189         goto fail_afsclient_LocalCellGet;
1190     }
1191
1192     tdir = afsconf_Open(AFSDIR_CLIENT_ETC_DIRPATH);
1193
1194     if (!tdir) {
1195         tst = ADMCLIENTBADCLIENTCONFIG;
1196         goto fail_afsclient_LocalCellGet;
1197     }
1198
1199     if ((tst = afsconf_GetLocalCell(tdir, cellName, MAXCELLCHARS))) {
1200         goto fail_afsclient_LocalCellGet;
1201     }
1202
1203     rc = 1;
1204
1205   fail_afsclient_LocalCellGet:
1206
1207     if (tdir != NULL) {
1208         afsconf_Close(tdir);
1209     }
1210
1211     if (st != NULL) {
1212         *st = tst;
1213     }
1214     return rc;
1215 }
1216
1217
1218 #ifdef AFS_NT40_ENV
1219
1220 static int
1221 client_ExtractDriveLetter(char *path)
1222 {
1223     int rc = 0;
1224
1225     if (path[0] != 0 && path[1] == ':') {
1226         path[2] = 0;
1227         rc = 1;
1228     }
1229
1230     return rc;
1231 }
1232
1233 /*
1234  * Determine the parent directory of a give directory
1235  */
1236
1237 static int
1238 Parent(char *directory, char *parentDirectory)
1239 {
1240     register char *tp;
1241     int rc = 0;
1242
1243     strcpy(parentDirectory, directory);
1244     tp = strrchr(parentDirectory, '\\');
1245     if (tp) {
1246         /* lv trailing slash so Parent("k:\foo") is "k:\" not "k :" */
1247         *(tp + 1) = 0;
1248         rc = 1;
1249     } else {
1250         if (client_ExtractDriveLetter(parentDirectory)) {
1251             strcat(parentDirectory, ".");
1252             rc = 1;
1253         }
1254     }
1255
1256     return rc;
1257 }
1258
1259 #else
1260 /*
1261  * Determine the parent directory of a give directory
1262  */
1263 static int
1264 Parent(const char *directory, char *parentDirectory)
1265 {
1266     char *tp;
1267     int rc = 0;
1268
1269     strcpy(parentDirectory, directory);
1270     tp = strrchr(parentDirectory, '/');
1271     if (tp) {
1272         *tp = 0;
1273         rc = 1;
1274     } else {
1275         strcpy(parentDirectory, ".");
1276         rc = 1;
1277     }
1278
1279     return rc;
1280 }
1281 #endif
1282
1283 /*
1284  * afsclient_MountPointCreate - create a mount point for a volume.
1285  *
1286  * PARAMETERS
1287  *
1288  * IN cellHandle - a handle to the cell where volumeName resides.
1289  *
1290  * IN directory - the directory where the mountpoint should be created.
1291  *
1292  * IN volumeName - the name of the volume to mount.
1293  *
1294  * IN volType - the type of mount point to create.
1295  *
1296  * IN volCheck - indicates whether or not to check the VLDB to see if
1297  * volumeName exists.
1298  *
1299  * LOCKS
1300  *
1301  * No locks are obtained or released by this function
1302  *
1303  * RETURN CODES
1304  *
1305  * Returns != 0 upon successful completion.
1306  */
1307
1308 #define TMP_DATA_SIZE 2048
1309
1310 int ADMINAPI
1311 afsclient_MountPointCreate(const void *cellHandle, const char *directory,
1312                            const char *volumeName, vol_type_t volType,
1313                            vol_check_t volCheck, afs_status_p st)
1314 {
1315     int rc = 0;
1316     afs_status_t tst = 0;
1317     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
1318     char parent_dir[TMP_DATA_SIZE];
1319     char space[TMP_DATA_SIZE];
1320     char directoryCell[MAXCELLCHARS];
1321     struct ViceIoctl idata;
1322     int i;
1323     vos_vldbEntry_t vldbEntry;
1324
1325     /*
1326      * Validate arguments
1327      */
1328
1329     if (client_init == 0) {
1330         tst = ADMCLIENTNOINIT;
1331         goto fail_afsclient_MountPointCreate;
1332     }
1333
1334     if ((directory == NULL) || (*directory == 0)) {
1335         tst = ADMCLIENTDIRECTORYNULL;
1336         goto fail_afsclient_MountPointCreate;
1337     }
1338
1339     if ((volumeName == NULL) || (*volumeName == 0)) {
1340         tst = ADMCLIENTVOLUMENAME;
1341         goto fail_afsclient_MountPointCreate;
1342     }
1343
1344     /*
1345      * Extract the parent directory and make sure it is in AFS.
1346      */
1347
1348     if (!Parent(directory, parent_dir)) {
1349         tst = ADMCLIENTBADDIRECTORY;
1350         goto fail_afsclient_MountPointCreate;
1351     }
1352
1353     idata.in_size = 0;
1354     idata.out_size = TMP_DATA_SIZE;
1355     idata.out = space;
1356     i = pioctl(parent_dir, VIOC_FILE_CELL_NAME, &idata, 1);
1357     if (i) {
1358         if ((errno == EINVAL) || (errno == ENOENT)) {
1359             tst = ADMCLIENTNOAFSDIRECTORY;
1360             goto fail_afsclient_MountPointCreate;
1361         }
1362     }
1363     strcpy(directoryCell, space);
1364
1365     /*
1366      * If the user requested, check that the volume exists
1367      */
1368
1369     if (volCheck == CHECK_VOLUME) {
1370         if (!vos_VLDBGet(cellHandle, 0, 0, (char *)volumeName, &vldbEntry,
1371                          &tst)) {
1372             goto fail_afsclient_MountPointCreate;
1373         }
1374     }
1375
1376     /*
1377      * Begin constructing the pioctl buffer
1378      */
1379
1380     if (volType == READ_WRITE) {
1381         strcpy(space, "%");
1382     } else {
1383         strcpy(space, "#");
1384     }
1385
1386     /*
1387      * Append the cell to the mount point if the volume is in a different
1388      * cell than the directory
1389      */
1390
1391     if (strcmp(c_handle->working_cell, directoryCell)) {
1392         strcat(space, c_handle->working_cell);
1393         strcat(space, ":");
1394     }
1395     strcat(space, volumeName);
1396     strcat(space, ".");
1397
1398
1399 #ifdef AFS_NT40_ENV
1400     idata.out_size = 0;
1401     idata.out = NULL;
1402     idata.in_size = 1 + strlen(space);
1403     idata.in = space;
1404     if (tst = pioctl(directory, VIOC_AFS_CREATE_MT_PT, &idata, 0)) {
1405         goto fail_afsclient_MountPointCreate;
1406     }
1407 #else
1408     if ((tst = symlink(space, directory))) {
1409         goto fail_afsclient_MountPointCreate;
1410     }
1411 #endif
1412
1413     rc = 1;
1414
1415   fail_afsclient_MountPointCreate:
1416
1417     if (st != NULL) {
1418         *st = tst;
1419     }
1420     return rc;
1421 }
1422
1423 typedef struct Acl {
1424     int dfs;
1425     char cell[1025];
1426     int nplus;
1427     int nminus;
1428 } Acl_t, *Acl_p;
1429
1430 int ADMINAPI
1431 afsclient_ACLEntryAdd(const char *directory, const char *user,
1432                       const acl_p acl, afs_status_p st)
1433 {
1434     int rc = 0;
1435     afs_status_t tst = 0;
1436     struct ViceIoctl idata;
1437     char old_acl_string[2048];
1438     char new_acl_string[2048];
1439     int newacl = 0;
1440     char *ptr;
1441     Acl_t cur_acl;
1442     char cur_user[64];
1443     int cur_user_acl = 0;
1444     int i;
1445     char tmp[64 + 35];
1446     int is_dfs;
1447
1448     if (client_init == 0) {
1449         tst = ADMCLIENTNOINIT;
1450         goto fail_afsclient_ACLEntryAdd;
1451     }
1452
1453     if ((directory == NULL) || (*directory == 0)) {
1454         tst = ADMMISCDIRECTORYNULL;
1455         goto fail_afsclient_ACLEntryAdd;
1456     }
1457
1458     if ((user == NULL) || (*user == 0)) {
1459         tst = ADMMISCUSERNULL;
1460         goto fail_afsclient_ACLEntryAdd;
1461     }
1462
1463     if (acl == NULL) {
1464         tst = ADMMISCACLNULL;
1465         goto fail_afsclient_ACLEntryAdd;
1466     }
1467
1468     if (acl->read == READ) {
1469         newacl |= 0x01;
1470     }
1471
1472     if (acl->write == WRITE) {
1473         newacl |= 0x02;
1474     }
1475
1476     if (acl->insert == INSERT) {
1477         newacl |= 0x04;
1478     }
1479
1480     if (acl->lookup == LOOKUP) {
1481         newacl |= 0x08;
1482     }
1483
1484     if (acl->del == DELETE) {
1485         newacl |= 0x10;
1486     }
1487
1488     if (acl->lock == LOCK) {
1489         newacl |= 0x20;
1490     }
1491
1492     if (acl->admin == ADMIN) {
1493         newacl |= 0x40;
1494     }
1495
1496     /*
1497      * Get the current acl for the directory
1498      */
1499
1500     idata.out_size = 2048;
1501     idata.in_size = 0;
1502     idata.in = idata.out = old_acl_string;
1503     tst = pioctl((char *)directory, VIOCGETAL, &idata, 1);
1504
1505     if (tst != 0) {
1506         goto fail_afsclient_ACLEntryAdd;
1507     }
1508
1509     /*
1510      * The acl is presented to us in string format.  The format of the
1511      * string is:
1512      *
1513      * A header which contains the number of positive and negative entries
1514      * and a string indicating whether or not this is a dfs acl:
1515      *
1516      * num_pos "\n" dfs_string "\n" num_neg
1517      *
1518      * An entry for each acl that's of the form:
1519      *
1520      * name rights "\n"
1521      *
1522      * There are no blanks in the string between fields, but I use them here
1523      * to make the reading easier.
1524      *
1525      * Since we are only going to add another entry to the acl, our approach
1526      * is simple.  Get the num_pos dfs_string and num_neg from the current acl,
1527      * increment num_pos by one and create a new string.  Concatenate the new
1528      * user and rights to the new string, and then concatenate the remaining
1529      * contents of the old acl to the new string.
1530      *
1531      * Unfortunately, this approach doesn't work since the format the kernel
1532      * hands the acl back to us in, is NOT WHAT IT WANTS BACK!!!!
1533      * So instead we need to parse the entire freaking acl and put a space
1534      * between each user and their acl.
1535      *
1536      * This is really ugly.
1537      */
1538
1539     /*
1540      * Parse the first few fields of the acl and see if this is a DFS
1541      * file.
1542      */
1543
1544     is_dfs =
1545         sscanf(old_acl_string, "%d dfs:%d %s", &cur_acl.nplus, &cur_acl.dfs,
1546                cur_acl.cell);
1547     ptr = strchr(old_acl_string, '\n');
1548     ptr++;
1549     sscanf(ptr, "%d", &cur_acl.nminus);
1550     ptr = strchr(ptr, '\n');
1551     ptr++;
1552     if (is_dfs == 3) {
1553         tst = ADMMISCNODFSACL;
1554         goto fail_afsclient_ACLEntryAdd;
1555     } else {
1556         /*
1557          * It isn't a DFS file, so create the beginning of the string
1558          * we will hand back to the kernel
1559          */
1560         sprintf(new_acl_string, "%d\n%d\n%s %d\n", (cur_acl.nplus + 1),
1561                 cur_acl.nminus, user, newacl);
1562     }
1563
1564     /*
1565      * Finish scanning the old acl, parsing each user/acl pair and
1566      * adding a space in the new acl.
1567      */
1568
1569     for (i = 0; i < (cur_acl.nplus + cur_acl.nminus); i++) {
1570         sscanf(ptr, "%s%d\n", cur_user, &cur_user_acl);
1571         /*
1572          * Skip the entry for the user we are replacing/adding
1573          */
1574
1575         if (strcmp(cur_user, user)) {
1576             ptr = strchr(ptr, '\n');
1577             ptr++;
1578             sprintf(tmp, "%s %d\n", cur_user, cur_user_acl);
1579             strcat(new_acl_string, tmp);
1580         }
1581     }
1582
1583     strcat(new_acl_string, ptr);
1584
1585     /*
1586      * Set the acl
1587      */
1588
1589     idata.out_size = 0;
1590     idata.in_size = strlen(new_acl_string) + 1;
1591     idata.in = idata.out = new_acl_string;
1592     tst = pioctl((char *) directory, VIOCSETAL, &idata, 1);
1593
1594     if (tst != 0) {
1595         goto fail_afsclient_ACLEntryAdd;
1596     }
1597     rc = 1;
1598
1599   fail_afsclient_ACLEntryAdd:
1600
1601     if (st != NULL) {
1602         *st = tst;
1603     }
1604     return rc;
1605 }
1606
1607 /*
1608  * afsclient_Init - initialize AFS components before use.
1609  *
1610  * PARAMETERS
1611  *
1612  * LOCKS
1613  *
1614  * No locks are obtained or released by this function
1615  *
1616  * CAUTIONS
1617  *
1618  * None.
1619  *
1620  * RETURN CODES
1621  *
1622  * Returns != 0 upon successful completion.
1623  */
1624
1625 int ADMINAPI
1626 afsclient_Init(afs_status_p st)
1627 {
1628     int rc = 0;
1629     afs_status_t tst = 0;
1630
1631     if (!client_init)
1632         pthread_once(&client_init_once, client_once);
1633
1634 #ifdef AFS_NT40_ENV
1635     if (afs_winsockInit() < 0) {
1636         tst = ADMCLIENTCANTINITWINSOCK;
1637         goto fail_afsclient_Init;
1638     }
1639 #endif
1640
1641     if (!(initAFSDirPath() & AFSDIR_CLIENT_PATHS_OK)) {
1642         tst = ADMCLIENTCANTINITAFSLOCATION;
1643         goto fail_afsclient_Init;
1644     }
1645
1646     if (rx_Init(0) < 0) {
1647         tst = ADMCLIENTCANTINITRX;
1648         goto fail_afsclient_Init;
1649     }
1650
1651     if ((tst = ka_CellConfig((char *)AFSDIR_CLIENT_ETC_DIRPATH))) {
1652         goto fail_afsclient_Init;
1653     }
1654
1655     rc = 1;
1656
1657   fail_afsclient_Init:
1658
1659     if (st != NULL) {
1660         *st = tst;
1661     }
1662     return rc;
1663 }
1664
1665 /*
1666  * afsclient_AFSServerGet - determine what kind of server serverName
1667  * is and fill in serverEntryP accordingly.
1668  *
1669  * PARAMETERS
1670  *
1671  * IN cellHandle - a cellHandle previously returned by afsclient_CellOpen.
1672  *
1673  * IN serverName - the hostname of the server of interest.
1674  *
1675  * OUT serverEntryP - upon successful completion contains a description of
1676  * the server.
1677  *
1678  * LOCKS
1679  *
1680  * No locks are obtained or released by this function
1681  *
1682  * CAUTIONS
1683  *
1684  * None.
1685  *
1686  * RETURN CODES
1687  *
1688  * Returns != 0 upon successful completion.
1689  */
1690
1691 int ADMINAPI
1692 afsclient_AFSServerGet(const void *cellHandle, const char *serverName,
1693                        afs_serverEntry_p serverEntryP, afs_status_p st)
1694 {
1695     int rc = 0;
1696     afs_status_t tst = 0;
1697     void *iter;
1698     int found_match = 0;
1699
1700     if ((serverName == NULL) || (*serverName == 0)) {
1701         tst = ADMUTILSERVERNAMENULL;
1702         goto fail_afsclient_AFSServerGet;
1703     }
1704
1705     if (serverEntryP == NULL) {
1706         tst = ADMUTILSERVERENTRYPNULL;
1707         goto fail_afsclient_AFSServerGet;
1708     }
1709
1710     /*
1711      * Iterate over server entries and try to find a match for serverName
1712      */
1713
1714     if (!afsclient_AFSServerGetBegin(cellHandle, &iter, &tst)) {
1715         goto fail_afsclient_AFSServerGet;
1716     }
1717
1718     while (afsclient_AFSServerGetNext(iter, serverEntryP, &tst)) {
1719         if (!strcmp(serverName, serverEntryP->serverName)) {
1720             found_match = 1;
1721             break;
1722         }
1723     }
1724
1725     /*
1726      * If we didn't find a match, the iterator should have terminated
1727      * normally.  If it didn't, return the error
1728      */
1729
1730     if (!found_match) {
1731         if (tst != ADMITERATORDONE) {
1732             afsclient_AFSServerGetDone(iter, 0);
1733         } else {
1734             afsclient_AFSServerGetDone(iter, &tst);
1735         }
1736         tst = ADMCLIENTNOMATCHINGSERVER;
1737         goto fail_afsclient_AFSServerGet;
1738     } else {
1739         if (!afsclient_AFSServerGetDone(iter, &tst)) {
1740             goto fail_afsclient_AFSServerGet;
1741         }
1742     }
1743     rc = 1;
1744
1745   fail_afsclient_AFSServerGet:
1746
1747     if (st != NULL) {
1748         *st = tst;
1749     }
1750     return rc;
1751 }
1752
1753 /*
1754  * The iterator functions and data for the server retrieval functions
1755  */
1756
1757 typedef struct server_get {
1758     int total;
1759     int index;
1760     afs_serverEntry_t server[MAXHOSTSPERCELL + BADSERVERID];
1761     afs_serverEntry_t cache[CACHED_ITEMS];
1762 } server_get_t, *server_get_p;
1763
1764 static int
1765 GetServerRPC(void *rpc_specific, int slot, int *last_item,
1766              int *last_item_contains_data, afs_status_p st)
1767 {
1768     int rc = 0;
1769     afs_status_t tst = 0;
1770     server_get_p serv = (server_get_p) rpc_specific;
1771
1772     memcpy(&serv->cache[slot], &serv->server[serv->index],
1773            sizeof(afs_serverEntry_t));
1774
1775     serv->index++;
1776     if (serv->index == serv->total) {
1777         *last_item = 1;
1778         *last_item_contains_data = 1;
1779     }
1780     rc = 1;
1781
1782     if (st != NULL) {
1783         *st = tst;
1784     }
1785     return rc;
1786 }
1787
1788 static int
1789 GetServerFromCache(void *rpc_specific, int slot, void *dest, afs_status_p st)
1790 {
1791     int rc = 0;
1792     afs_status_t tst = 0;
1793     server_get_p serv = (server_get_p) rpc_specific;
1794
1795     memcpy(dest, (const void *)&serv->cache[slot], sizeof(afs_serverEntry_t));
1796     rc = 1;
1797
1798     if (st != NULL) {
1799         *st = tst;
1800     }
1801     return rc;
1802 }
1803
1804 /*
1805  * afsclient_AFSServerGetBegin - start the process of iterating over
1806  * every server in the cell.
1807  *
1808  * PARAMETERS
1809  *
1810  * IN cellHandle - a cellHandle previously returned by afsclient_CellOpen.
1811  *
1812  * OUT iterationIdP - - upon successful completion contains an iterator
1813  * that can be passed to afsclient_AFSServerGetNext.
1814  *
1815  * LOCKS
1816  *
1817  * No locks are obtained or released by this function
1818  *
1819  * CAUTIONS
1820  *
1821  * None.
1822  *
1823  * RETURN CODES
1824  *
1825  * Returns != 0 upon successful completion.
1826  */
1827
1828 int ADMINAPI
1829 afsclient_AFSServerGetBegin(const void *cellHandle, void **iterationIdP,
1830                             afs_status_p st)
1831 {
1832     int rc = 0;
1833     afs_status_t tst = 0;
1834     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
1835     afs_admin_iterator_p iter =
1836         (afs_admin_iterator_p) malloc(sizeof(afs_admin_iterator_t));
1837     server_get_p serv = (server_get_p) calloc(1, sizeof(server_get_t));
1838     server_get_p serv_cache = NULL;
1839     const char *cellName = NULL;
1840     void *database_iter;
1841     util_databaseServerEntry_t database_entry;
1842     void *fileserver_iter;
1843     vos_fileServerEntry_t fileserver_entry;
1844     int iserv, iservaddr, ientryaddr, is_dup;
1845     struct hostent *host;
1846
1847     if (!CellHandleIsValid(c_handle, &tst)) {
1848         goto fail_afsclient_AFSServerGetBegin;
1849     }
1850
1851     if (iterationIdP == NULL) {
1852         tst = ADMITERATIONIDPNULL;
1853         goto fail_afsclient_AFSServerGetBegin;
1854     }
1855
1856     if ((serv == NULL) || (iter == NULL)) {
1857         tst = ADMNOMEM;
1858         goto fail_afsclient_AFSServerGetBegin;
1859     }
1860
1861   restart:
1862     LOCK_GLOBAL_MUTEX;
1863     if (c_handle->server_list != NULL && c_handle->server_ttl < time(NULL)) {
1864         serv_cache = c_handle->server_list;
1865         c_handle->server_list = NULL;
1866     }
1867     UNLOCK_GLOBAL_MUTEX;
1868
1869     if (c_handle->server_list == NULL) {
1870         if (serv_cache == NULL) {
1871             serv_cache = (server_get_p) calloc(1, sizeof(server_get_t));
1872
1873             if (serv_cache == NULL) {
1874                 tst = ADMNOMEM;
1875                 goto fail_afsclient_AFSServerGetBegin;
1876             }
1877         }
1878
1879         /*
1880          * Retrieve the list of database servers for this cell.
1881          */
1882
1883         if (!afsclient_CellNameGet(c_handle, &cellName, &tst)) {
1884             goto fail_afsclient_AFSServerGetBegin;
1885         }
1886
1887         if (!util_DatabaseServerGetBegin(cellName, &database_iter, &tst)) {
1888             goto fail_afsclient_AFSServerGetBegin;
1889         }
1890
1891         while (util_DatabaseServerGetNext(database_iter, &database_entry, &tst)) {
1892             serv->server[serv->total].serverAddress[0] =
1893                 database_entry.serverAddress;
1894             serv->server[serv->total].serverType = DATABASE_SERVER;
1895             serv->total++;
1896         }
1897
1898         if (tst != ADMITERATORDONE) {
1899             util_DatabaseServerGetDone(database_iter, 0);
1900             goto fail_afsclient_AFSServerGetBegin;
1901         }
1902
1903         if (!util_DatabaseServerGetDone(database_iter, &tst)) {
1904             goto fail_afsclient_AFSServerGetBegin;
1905         }
1906
1907         /*
1908          * Retrieve the list of file servers for this cell.
1909          */
1910
1911         if (!vos_FileServerGetBegin(c_handle, 0, &fileserver_iter, &tst)) {
1912             goto fail_afsclient_AFSServerGetBegin;
1913         }
1914
1915         while (vos_FileServerGetNext(fileserver_iter, &fileserver_entry, &tst)) {
1916             /*
1917              * See if any of the addresses returned in this fileserver_entry
1918              * structure already exist in the list of servers we're building.
1919              * If not, create a new record for this server.
1920              */
1921             is_dup = 0;
1922             for (iserv = 0; iserv < serv->total; iserv++) {
1923                 for (ientryaddr = 0; ientryaddr < fileserver_entry.count; ientryaddr++) {
1924                     for (iservaddr = 0; iservaddr < AFS_MAX_SERVER_ADDRESS; iservaddr++) {
1925                         if (serv->server[iserv].serverAddress[iservaddr] ==
1926                              fileserver_entry.serverAddress[ientryaddr]) {
1927                             is_dup = 1;
1928                             break;
1929                         }
1930                     }
1931                     if (is_dup) {
1932                         break;
1933                     }
1934                 }
1935                 if (is_dup) {
1936                     break;
1937                 }
1938             }
1939
1940             if (is_dup) {
1941                 serv->server[iserv].serverType |= FILE_SERVER;
1942             } else {
1943                 iserv = serv->total++;
1944                 serv->server[iserv].serverType = FILE_SERVER;
1945             }
1946
1947             /*
1948              * Add the addresses from the vldb list to the serv->server[iserv]
1949              * record.  Remember that VLDB's list-of-addrs is not guaranteed
1950              * to be unique in a particular entry, or to return only one entry
1951              * per machine--so when we add addresses, always check for
1952              * duplicate entries.
1953              */
1954
1955             for (ientryaddr = 0; ientryaddr < fileserver_entry.count; ientryaddr++) {
1956                 for (iservaddr = 0; iservaddr < AFS_MAX_SERVER_ADDRESS; iservaddr++) {
1957                     if (serv->server[iserv].serverAddress[iservaddr] ==
1958                          fileserver_entry.serverAddress[ientryaddr]) {
1959                         break;
1960                     }
1961                 }
1962                 if (iservaddr == AFS_MAX_SERVER_ADDRESS) {
1963                     for (iservaddr = 0; iservaddr < AFS_MAX_SERVER_ADDRESS;
1964                           iservaddr++) {
1965                         if (!serv->server[iserv].serverAddress[iservaddr]) {
1966                             serv->server[iserv].serverAddress[iservaddr] =
1967                                 fileserver_entry.serverAddress[ientryaddr];
1968                             break;
1969                         }
1970                     }
1971                 }
1972             }
1973         }
1974
1975         if (tst != ADMITERATORDONE) {
1976             vos_FileServerGetDone(fileserver_iter, 0);
1977             goto fail_afsclient_AFSServerGetBegin;
1978         }
1979
1980         if (!vos_FileServerGetDone(fileserver_iter, &tst)) {
1981             goto fail_afsclient_AFSServerGetBegin;
1982         }
1983
1984         /*
1985          * Iterate over the list and fill in the hostname of each of the servers
1986          */
1987
1988         for (iserv = 0; iserv < serv->total; iserv++) {
1989             int addr = htonl(serv->server[iserv].serverAddress[0]);
1990             LOCK_GLOBAL_MUTEX;
1991             host = gethostbyaddr((const char *)&addr, sizeof(int), AF_INET);
1992             if (host != NULL) {
1993                 strncpy(serv->server[iserv].serverName, host->h_name,
1994                          AFS_MAX_SERVER_NAME_LEN);
1995                 serv->server[iserv].serverName[AFS_MAX_SERVER_NAME_LEN - 1] = '\0';
1996             }
1997             UNLOCK_GLOBAL_MUTEX;
1998         }
1999
2000         memcpy(serv_cache, serv, sizeof(server_get_t));
2001     } else {
2002         int race = 0;
2003         LOCK_GLOBAL_MUTEX;
2004         if (c_handle->server_list == NULL)
2005             race = 1;
2006         else
2007             memcpy(serv, c_handle->server_list, sizeof(server_get_t));
2008         UNLOCK_GLOBAL_MUTEX;
2009         if (race)
2010             goto restart;
2011     }
2012
2013     if (IteratorInit
2014             (iter, (void *)serv, GetServerRPC, GetServerFromCache, NULL, NULL,
2015              &tst)) {
2016         *iterationIdP = (void *)iter;
2017         rc = 1;
2018     }
2019
2020   fail_afsclient_AFSServerGetBegin:
2021
2022     if (rc == 0) {
2023         if (iter != NULL)
2024             free(iter);
2025         if (serv != NULL)
2026             free(serv);
2027         if (serv_cache != NULL)
2028             free(serv_cache);
2029     } else {
2030         if (serv_cache) {
2031             LOCK_GLOBAL_MUTEX;
2032             /* in case there was a race and we constructed the list twice */
2033             if (c_handle->server_list)
2034                 free(c_handle->server_list);
2035
2036             c_handle->server_list = serv_cache;
2037             c_handle->server_ttl = time(NULL) + SERVER_TTL;
2038             UNLOCK_GLOBAL_MUTEX;
2039         }
2040     }
2041
2042     if (st != NULL)
2043         *st = tst;
2044
2045     return rc;
2046 }
2047
2048 /*
2049  * afsclient_AFSServerGetNext - retrieve the next server in the cell.
2050  *
2051  * PARAMETERS
2052  *
2053  * IN iterationId - an iterator previously returned by
2054  * afsclient_AFSServerGetBegin.
2055  *
2056  * OUT serverEntryP - upon successful completion contains the next server.
2057  *
2058  * LOCKS
2059  *
2060  * No locks are obtained or released by this function
2061  *
2062  * CAUTIONS
2063  *
2064  * None.
2065  *
2066  * RETURN CODES
2067  *
2068  * Returns != 0 upon successful completion.
2069  */
2070
2071 int ADMINAPI
2072 afsclient_AFSServerGetNext(void *iterationId, afs_serverEntry_p serverEntryP,
2073                            afs_status_p st)
2074 {
2075     int rc = 0;
2076     afs_status_t tst = 0;
2077     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
2078
2079     if (iterationId == NULL) {
2080         tst = ADMITERATORNULL;
2081         goto fail_afsclient_AFSServerGetNext;
2082     }
2083
2084     if (serverEntryP == NULL) {
2085         tst = ADMUTILSERVERENTRYPNULL;
2086         goto fail_afsclient_AFSServerGetNext;
2087     }
2088
2089     rc = IteratorNext(iter, (void *)serverEntryP, &tst);
2090
2091   fail_afsclient_AFSServerGetNext:
2092
2093     if (st != NULL) {
2094         *st = tst;
2095     }
2096     return rc;
2097 }
2098
2099 /*
2100  * afsclient_AFSServerGetDone - finish using a server iterator.
2101  *
2102  * PARAMETERS
2103  *
2104  * IN iterationId - an iterator previously returned by
2105  * afsclient_AFSServerGetBegin.
2106  *
2107  * LOCKS
2108  *
2109  * No locks are obtained or released by this function
2110  *
2111  * CAUTIONS
2112  *
2113  * None.
2114  *
2115  * RETURN CODES
2116  *
2117  * Returns != 0 upon successful completion.
2118  */
2119
2120 int ADMINAPI
2121 afsclient_AFSServerGetDone(void *iterationId, afs_status_p st)
2122 {
2123     int rc = 0;
2124     afs_status_t tst = 0;
2125     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
2126
2127     if (iterationId == NULL) {
2128         tst = ADMITERATORNULL;
2129         goto fail_afsclient_AFSServerGetDone;
2130     }
2131
2132     rc = IteratorDone(iter, &tst);
2133
2134   fail_afsclient_AFSServerGetDone:
2135
2136     if (st != NULL) {
2137         *st = tst;
2138     }
2139     return rc;
2140 }
2141
2142 /*
2143  * afsclient_RPCStatOpen - open an rx connection to a server to retrieve
2144  * statistics.
2145  *
2146  * PARAMETERS
2147  *
2148  * IN cellHandle - a cellHandle created by afsclient_CellOpen.
2149  *
2150  * IN serverName - the host name where the server resides.
2151  *
2152  * IN type - what type of process to query
2153  *
2154  * OUT rpcStatHandleP - contains an rx connection to the server of interest
2155  *
2156  * LOCKS
2157  *
2158  * No locks are obtained or released by this function
2159  *
2160  * CAUTIONS
2161  *
2162  * None.
2163  *
2164  * RETURN CODES
2165  *
2166  * Returns != 0 upon successful completion.
2167  */
2168
2169 int ADMINAPI
2170 afsclient_RPCStatOpen(const void *cellHandle, const char *serverName,
2171                       afs_stat_source_t type,
2172                       struct rx_connection **rpcStatHandleP, afs_status_p st)
2173 {
2174     int rc = 0;
2175     afs_status_t tst = 0;
2176     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
2177     int servAddr = 0;
2178     int servPort;
2179     struct rx_securityClass *sc;
2180
2181     if (!CellHandleIsValid(cellHandle, &tst)) {
2182         goto fail_afsclient_RPCStatOpen;
2183     }
2184
2185     if (!util_AdminServerAddressGetFromName(serverName, &servAddr, &tst)) {
2186         goto fail_afsclient_RPCStatOpen;
2187     }
2188
2189     if (rpcStatHandleP == NULL) {
2190         tst = ADMCLIENTRPCSTATHANDLEPNULL;
2191         goto fail_afsclient_RPCStatOpen;
2192     }
2193
2194     switch (type) {
2195
2196     case AFS_BOSSERVER:
2197         servPort = AFSCONF_NANNYPORT;
2198         break;
2199
2200     case AFS_FILESERVER:
2201         servPort = AFSCONF_FILEPORT;
2202         break;
2203
2204     case AFS_KASERVER:
2205         servPort = AFSCONF_KAUTHPORT;
2206         break;
2207
2208     case AFS_PTSERVER:
2209         servPort = AFSCONF_PROTPORT;
2210         break;
2211
2212     case AFS_VOLSERVER:
2213         servPort = AFSCONF_VOLUMEPORT;
2214         break;
2215
2216     case AFS_VLSERVER:
2217         servPort = AFSCONF_VLDBPORT;
2218         break;
2219
2220     case AFS_CLIENT:
2221         servPort = AFSCONF_CALLBACKPORT;
2222         break;
2223
2224     default:
2225         tst = ADMTYPEINVALID;
2226         goto fail_afsclient_RPCStatOpen;
2227     }
2228
2229     /*
2230      * special processing of tokens by server type
2231      */
2232
2233     if (type == AFS_KASERVER) {
2234         if (!c_handle->tokens->kas_token_set) {
2235             tst = ADMCLIENTNOKASTOKENS;
2236             goto fail_afsclient_RPCStatOpen;
2237         }
2238         sc = c_handle->tokens->kas_sc[c_handle->tokens->sc_index];
2239     } else {
2240         sc = c_handle->tokens->afs_sc[c_handle->tokens->sc_index];
2241     }
2242
2243     *rpcStatHandleP =
2244         rx_GetCachedConnection(htonl(servAddr), htons(servPort),
2245                                RX_STATS_SERVICE_ID, sc,
2246                                c_handle->tokens->sc_index);
2247
2248     if (*rpcStatHandleP == NULL) {
2249         tst = ADMCLIENTRPCSTATNOCONNECTION;
2250         goto fail_afsclient_RPCStatOpen;
2251     }
2252     rc = 1;
2253
2254   fail_afsclient_RPCStatOpen:
2255
2256     if (st != NULL) {
2257         *st = tst;
2258     }
2259     return rc;
2260 }
2261
2262 /*
2263  * afsclient_RPCStatOpenPort - open an rx connection to a server to retrieve
2264  * statistics.
2265  *
2266  * PARAMETERS
2267  *
2268  * IN cellHandle - a cellHandle created by afsclient_CellOpen.
2269  *
2270  * IN serverName - the host name where the server resides.
2271  *
2272  * IN port - the UDP port number where the server resides.
2273  *
2274  * OUT rpcStatHandleP - contains an rx connection to the server of interest
2275  *
2276  * LOCKS
2277  *
2278  * No locks are obtained or released by this function
2279  *
2280  * CAUTIONS
2281  *
2282  * None.
2283  *
2284  * RETURN CODES
2285  *
2286  * Returns != 0 upon successful completion.
2287  */
2288
2289 int ADMINAPI
2290 afsclient_RPCStatOpenPort(const void *cellHandle, const char *serverName,
2291                           const int serverPort,
2292                           struct rx_connection **rpcStatHandleP,
2293                           afs_status_p st)
2294 {
2295     int rc = 0;
2296     afs_status_t tst = 0;
2297     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
2298     int servAddr = 0;
2299     struct rx_securityClass *sc;
2300
2301     if (!CellHandleIsValid(cellHandle, &tst)) {
2302         goto fail_afsclient_RPCStatOpenPort;
2303     }
2304
2305     if (!util_AdminServerAddressGetFromName(serverName, &servAddr, &tst)) {
2306         goto fail_afsclient_RPCStatOpenPort;
2307     }
2308
2309     if (rpcStatHandleP == NULL) {
2310         tst = ADMCLIENTRPCSTATHANDLEPNULL;
2311         goto fail_afsclient_RPCStatOpenPort;
2312     }
2313
2314     /*
2315      * special processing of tokens by server type
2316      */
2317
2318     if (serverPort == AFSCONF_KAUTHPORT) {
2319         if (!c_handle->tokens->kas_token_set) {
2320             tst = ADMCLIENTNOKASTOKENS;
2321             goto fail_afsclient_RPCStatOpenPort;
2322         }
2323         sc = c_handle->tokens->kas_sc[c_handle->tokens->sc_index];
2324     } else {
2325         sc = c_handle->tokens->afs_sc[c_handle->tokens->sc_index];
2326     }
2327
2328     *rpcStatHandleP =
2329         rx_GetCachedConnection(htonl(servAddr), htons(serverPort),
2330                                RX_STATS_SERVICE_ID, sc,
2331                                c_handle->tokens->sc_index);
2332
2333     if (*rpcStatHandleP == NULL) {
2334         tst = ADMCLIENTRPCSTATNOCONNECTION;
2335         goto fail_afsclient_RPCStatOpenPort;
2336     }
2337     rc = 1;
2338
2339   fail_afsclient_RPCStatOpenPort:
2340
2341     if (st != NULL) {
2342         *st = tst;
2343     }
2344     return rc;
2345 }
2346
2347 /*
2348  * afsclient_RPCStatClose - close a previously opened rx connection.
2349  *
2350  * PARAMETERS
2351  *
2352  * IN rpcStatHandle - an rx connection returned by afsclient_RPCStatOpen
2353  *
2354  * LOCKS
2355  *
2356  * No locks are obtained or released by this function
2357  *
2358  * CAUTIONS
2359  *
2360  * None.
2361  *
2362  * RETURN CODES
2363  *
2364  * Returns != 0 upon successful completion.
2365  */
2366
2367 int ADMINAPI
2368 afsclient_RPCStatClose(struct rx_connection *rpcStatHandle, afs_status_p st)
2369 {
2370     int rc = 0;
2371     afs_status_t tst = 0;
2372
2373     if (rpcStatHandle == NULL) {
2374         tst = ADMCLIENTRPCSTATHANDLEPNULL;
2375         goto fail_afsclient_RPCStatClose;
2376     }
2377
2378     rx_ReleaseCachedConnection(rpcStatHandle);
2379     rc = 1;
2380   fail_afsclient_RPCStatClose:
2381
2382     if (st != NULL) {
2383         *st = tst;
2384     }
2385     return rc;
2386 }
2387
2388 /*
2389  * afsclient_CMStatOpen - open an rx connection to a server to retrieve
2390  * statistics.
2391  *
2392  * PARAMETERS
2393  *
2394  * IN cellHandle - a cellHandle created by afsclient_CellOpen.
2395  *
2396  * IN serverName - the host name where the server resides.
2397  *
2398  * OUT cmStatHandleP - contains an rx connection to the server of interest
2399  *
2400  * LOCKS
2401  *
2402  * No locks are obtained or released by this function
2403  *
2404  * CAUTIONS
2405  *
2406  * None.
2407  *
2408  * RETURN CODES
2409  *
2410  * Returns != 0 upon successful completion.
2411  */
2412
2413 int ADMINAPI
2414 afsclient_CMStatOpen(const void *cellHandle, const char *serverName,
2415                      struct rx_connection **cmStatHandleP, afs_status_p st)
2416 {
2417     int rc = 0;
2418     afs_status_t tst = 0;
2419     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
2420     int servAddr = 0;
2421     struct rx_securityClass *sc;
2422
2423     if (!CellHandleIsValid(cellHandle, &tst)) {
2424         goto fail_afsclient_CMStatOpen;
2425     }
2426
2427     if (!util_AdminServerAddressGetFromName(serverName, &servAddr, &tst)) {
2428         goto fail_afsclient_CMStatOpen;
2429     }
2430
2431     if (cmStatHandleP == NULL) {
2432         tst = ADMCLIENTCMSTATHANDLEPNULL;
2433         goto fail_afsclient_CMStatOpen;
2434     }
2435
2436     sc = c_handle->tokens->afs_sc[c_handle->tokens->sc_index];
2437
2438     *cmStatHandleP =
2439         rx_GetCachedConnection(htonl(servAddr), htons(AFSCONF_CALLBACKPORT),
2440                                1, sc, c_handle->tokens->sc_index);
2441
2442     if (*cmStatHandleP == NULL) {
2443         tst = ADMCLIENTCMSTATNOCONNECTION;
2444         goto fail_afsclient_CMStatOpen;
2445     }
2446     rc = 1;
2447
2448   fail_afsclient_CMStatOpen:
2449
2450     if (st != NULL) {
2451         *st = tst;
2452     }
2453     return rc;
2454 }
2455
2456 /*
2457  * afsclient_CMStatOpenPort - open an rx connection to a server to retrieve
2458  * statistics.
2459  *
2460  * PARAMETERS
2461  *
2462  * IN cellHandle - a cellHandle created by afsclient_CellOpen.
2463  *
2464  * IN serverName - the host name where the server resides.
2465  *
2466  * IN port - the UDP port number where the server resides.
2467  *
2468  * OUT cmStatHandleP - contains an rx connection to the server of interest
2469  *
2470  * LOCKS
2471  *
2472  * No locks are obtained or released by this function
2473  *
2474  * CAUTIONS
2475  *
2476  * None.
2477  *
2478  * RETURN CODES
2479  *
2480  * Returns != 0 upon successful completion.
2481  */
2482
2483 int ADMINAPI
2484 afsclient_CMStatOpenPort(const void *cellHandle, const char *serverName,
2485                          const int serverPort,
2486                          struct rx_connection **cmStatHandleP,
2487                          afs_status_p st)
2488 {
2489     int rc = 0;
2490     afs_status_t tst = 0;
2491     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
2492     int servAddr = 0;
2493     struct rx_securityClass *sc;
2494
2495     if (!CellHandleIsValid(cellHandle, &tst)) {
2496         goto fail_afsclient_CMStatOpenPort;
2497     }
2498
2499     if (!util_AdminServerAddressGetFromName(serverName, &servAddr, &tst)) {
2500         goto fail_afsclient_CMStatOpenPort;
2501     }
2502
2503     if (cmStatHandleP == NULL) {
2504         tst = ADMCLIENTCMSTATHANDLEPNULL;
2505         goto fail_afsclient_CMStatOpenPort;
2506     }
2507
2508     sc = c_handle->tokens->afs_sc[c_handle->tokens->sc_index];
2509
2510     *cmStatHandleP =
2511         rx_GetCachedConnection(htonl(servAddr), htons(serverPort), 1, sc,
2512                                c_handle->tokens->sc_index);
2513
2514     if (*cmStatHandleP == NULL) {
2515         tst = ADMCLIENTCMSTATNOCONNECTION;
2516         goto fail_afsclient_CMStatOpenPort;
2517     }
2518     rc = 1;
2519
2520   fail_afsclient_CMStatOpenPort:
2521
2522     if (st != NULL) {
2523         *st = tst;
2524     }
2525     return rc;
2526 }
2527
2528 /*
2529  * afsclient_CMStatClose - close a previously opened rx connection.
2530  *
2531  * PARAMETERS
2532  *
2533  * IN cmStatHandle - an rx connection returned by afsclient_CMStatOpen
2534  *
2535  * LOCKS
2536  *
2537  * No locks are obtained or released by this function
2538  *
2539  * CAUTIONS
2540  *
2541  * None.
2542  *
2543  * RETURN CODES
2544  *
2545  * Returns != 0 upon successful completion.
2546  */
2547
2548 int ADMINAPI
2549 afsclient_CMStatClose(struct rx_connection *cmStatHandle, afs_status_p st)
2550 {
2551     int rc = 0;
2552     afs_status_t tst = 0;
2553
2554     if (cmStatHandle == NULL) {
2555         tst = ADMCLIENTCMSTATHANDLEPNULL;
2556         goto fail_afsclient_CMStatClose;
2557     }
2558
2559     rx_ReleaseCachedConnection(cmStatHandle);
2560     rc = 1;
2561   fail_afsclient_CMStatClose:
2562
2563     if (st != NULL) {
2564         *st = tst;
2565     }
2566     return rc;
2567 }
2568
2569 /*
2570  * afsclient_RXDebugOpen - open an rxdebug handle to a server.
2571  *
2572  * PARAMETERS
2573  *
2574  * IN serverName - the host name where the server resides.
2575  *
2576  * IN type - what type of process to query
2577  *
2578  * OUT rxdebugHandle_p - contains an rxdebug handle for the server of interest
2579  *
2580  * LOCKS
2581  *
2582  * No locks are obtained or released by this function
2583  *
2584  * CAUTIONS
2585  *
2586  * None.
2587  *
2588  * RETURN CODES
2589  *
2590  * Returns != 0 upon successful completion.
2591  */
2592
2593 int ADMINAPI
2594 afsclient_RXDebugOpen(const char *serverName, afs_stat_source_t type,
2595                       rxdebugHandle_p * rxdebugHandleP, afs_status_p st)
2596 {
2597     int rc = 0;
2598     afs_status_t tst = 0;
2599     int code;
2600     rxdebugHandle_p handle;
2601     rxdebugSocket_t sock;
2602     struct sockaddr_in taddr;
2603     int serverPort;
2604     int serverAddr;
2605
2606     if (rxdebugHandleP == NULL) {
2607         tst = ADMCLIENTRXDEBUGHANDLEPNULL;
2608         goto fail_afsclient_RXDebugOpen;
2609     }
2610
2611     switch (type) {
2612
2613     case AFS_BOSSERVER:
2614         serverPort = AFSCONF_NANNYPORT;
2615         break;
2616
2617     case AFS_FILESERVER:
2618         serverPort = AFSCONF_FILEPORT;
2619         break;
2620
2621     case AFS_KASERVER:
2622         serverPort = AFSCONF_KAUTHPORT;
2623         break;
2624
2625     case AFS_PTSERVER:
2626         serverPort = AFSCONF_PROTPORT;
2627         break;
2628
2629     case AFS_VOLSERVER:
2630         serverPort = AFSCONF_VOLUMEPORT;
2631         break;
2632
2633     case AFS_VLSERVER:
2634         serverPort = AFSCONF_VLDBPORT;
2635         break;
2636
2637     case AFS_CLIENT:
2638         serverPort = AFSCONF_CALLBACKPORT;
2639         break;
2640
2641     default:
2642         tst = ADMTYPEINVALID;
2643         goto fail_afsclient_RXDebugOpen;
2644     }
2645
2646     if (!util_AdminServerAddressGetFromName(serverName, &serverAddr, &tst)) {
2647         goto fail_afsclient_RXDebugOpen;
2648     }
2649
2650     sock = (rxdebugSocket_t) socket(AF_INET, SOCK_DGRAM, 0);
2651     if (sock == INVALID_RXDEBUG_SOCKET) {
2652         tst = ADMSOCKFAIL;
2653         goto fail_afsclient_RXDebugOpen;
2654     }
2655
2656     memset(&taddr, 0, sizeof(taddr));
2657     taddr.sin_family = AF_INET;
2658     taddr.sin_port = 0;
2659     taddr.sin_addr.s_addr = INADDR_ANY;
2660     code = bind(sock, (struct sockaddr *)&taddr, sizeof(taddr));
2661     if (code) {
2662         close(sock);
2663         tst = ADMSOCKFAIL;
2664         goto fail_afsclient_RXDebugOpen;
2665     }
2666
2667     handle = (rxdebugHandle_p) malloc(sizeof(rxdebugHandle_t));
2668     if (!handle) {
2669         close(sock);
2670         tst = ADMNOMEM;
2671         goto fail_afsclient_RXDebugOpen;
2672     }
2673
2674     handle->sock = sock;
2675     handle->ipAddr = serverAddr;
2676     handle->udpPort = serverPort;
2677     handle->firstFlag = 1;
2678     handle->supportedStats = 0;
2679     *rxdebugHandleP = handle;
2680     rc = 1;
2681
2682   fail_afsclient_RXDebugOpen:
2683
2684     if (st != NULL) {
2685         *st = tst;
2686     }
2687     return rc;
2688 }
2689
2690 /*
2691  * afsclient_RXDebugOpenPort - open an rxdebug handle to a server.
2692  *
2693  * PARAMETERS
2694  *
2695  * IN serverName - the host name where the server resides.
2696  *
2697  * IN port - the UDP port number where the server resides.
2698  *
2699  * OUT rxdebugHandle_p - contains an rxdebug handle for the server of interest
2700  *
2701  * LOCKS
2702  *
2703  * No locks are obtained or released by this function
2704  *
2705  * CAUTIONS
2706  *
2707  * None.
2708  *
2709  * RETURN CODES
2710  *
2711  * Returns != 0 upon successful completion.
2712  */
2713
2714 int ADMINAPI
2715 afsclient_RXDebugOpenPort(const char *serverName, int serverPort,
2716                           rxdebugHandle_p * rxdebugHandleP, afs_status_p st)
2717 {
2718     int rc = 0;
2719     afs_status_t tst = 0;
2720     int code;
2721     rxdebugHandle_p handle;
2722     rxdebugSocket_t sock;
2723     struct sockaddr_in taddr;
2724     int serverAddr;
2725
2726     if (rxdebugHandleP == NULL) {
2727         tst = ADMCLIENTRXDEBUGHANDLEPNULL;
2728         goto fail_afsclient_RXDebugOpenPort;
2729     }
2730
2731     if (!util_AdminServerAddressGetFromName(serverName, &serverAddr, &tst)) {
2732         goto fail_afsclient_RXDebugOpenPort;
2733     }
2734
2735     sock = (rxdebugSocket_t) socket(AF_INET, SOCK_DGRAM, 0);
2736     if (sock == INVALID_RXDEBUG_SOCKET) {
2737         tst = ADMSOCKFAIL;
2738         goto fail_afsclient_RXDebugOpenPort;
2739     }
2740
2741     memset(&taddr, 0, sizeof(taddr));
2742     taddr.sin_family = AF_INET;
2743     taddr.sin_port = 0;
2744     taddr.sin_addr.s_addr = INADDR_ANY;
2745     code = bind(sock, (struct sockaddr *)&taddr, sizeof(taddr));
2746     if (code) {
2747         close(sock);
2748         tst = ADMSOCKFAIL;
2749         goto fail_afsclient_RXDebugOpenPort;
2750     }
2751
2752     handle = (rxdebugHandle_p) malloc(sizeof(rxdebugHandle_t));
2753     if (!handle) {
2754         close(sock);
2755         tst = ADMNOMEM;
2756         goto fail_afsclient_RXDebugOpenPort;
2757     }
2758
2759     handle->sock = sock;
2760     handle->ipAddr = serverAddr;
2761     handle->udpPort = serverPort;
2762     handle->firstFlag = 1;
2763     handle->supportedStats = 0;
2764     *rxdebugHandleP = handle;
2765     rc = 1;
2766
2767   fail_afsclient_RXDebugOpenPort:
2768
2769     if (st != NULL) {
2770         *st = tst;
2771     }
2772     return rc;
2773 }
2774
2775 /*
2776  * afsclient_RXDebugClose - close a previously opened rxdebug handle.
2777  *
2778  * PARAMETERS
2779  *
2780  * IN rxdebugHandle - an rxdebug handle returned by afsclient_RXDebugOpen
2781  *
2782  * LOCKS
2783  *
2784  * No locks are obtained or released by this function
2785  *
2786  * CAUTIONS
2787  *
2788  * None.
2789  *
2790  * RETURN CODES
2791  *
2792  * Returns != 0 upon successful completion.
2793  */
2794
2795 int ADMINAPI
2796 afsclient_RXDebugClose(rxdebugHandle_p rxdebugHandle, afs_status_p st)
2797 {
2798     int rc = 0;
2799     afs_status_t tst = 0;
2800
2801     if (rxdebugHandle == NULL) {
2802         tst = ADMCLIENTRXDEBUGHANDLEPNULL;
2803         goto fail_afsclient_RXDebugClose;
2804     }
2805
2806     close(rxdebugHandle->sock);
2807     free(rxdebugHandle);
2808     rc = 1;
2809   fail_afsclient_RXDebugClose:
2810
2811     if (st != NULL) {
2812         *st = tst;
2813     }
2814     return rc;
2815 }