src/libadmin/kas/afs_kasAdmin.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 RCSID
  14     ("$Header$");
  15
  16 #include <stdio.h>
  17
  18 #ifdef HAVE_STRING_H
  19 #include <string.h>
  20 #else
  21 #ifdef HAVE_STRINGS_H
  22 #include <strings.h>
  23 #endif
  24 #endif
  25
  26 #include <afs/stds.h>
  27 #include "afs_kasAdmin.h"
  28 #include "../adminutil/afs_AdminInternal.h"
  29 #include <afs/afs_AdminErrors.h>
  30 #include <afs/afs_utilAdmin.h>
  31 #include <afs/kauth.h>
  32 #include <afs/kautils.h>
  33 #include <afs/kaport.h>
  34 #include <pthread.h>
  35
  36 #undef ENCRYPT
  37
  38 extern int ubik_Call();
  39 extern int ubik_Call_New();
  40 extern int ubik_CallIter();
  41
  42 typedef struct {
  43     int begin_magic;
  44     int is_valid;
  45     struct ubik_client *servers;
  46     char *cell;
  47     int end_magic;
  48 } kas_server_t, *kas_server_p;
  49
  50 /*
  51  * IsValidServerHandle - verify the validity of a kas_server_t handle.
  52  *
  53  * PARAMETERS
  54  *
  55  * IN serverHandle - the handle to be verified.
  56  *
  57  * LOCKS
  58  *
  59  * No locks are obtained or released by this function
  60  *
  61  * RETURN CODES
  62  *
  63  * Returns != 0 upon successful completion.
  64  */
  65
  66 static int
  67 IsValidServerHandle(const kas_server_p serverHandle, afs_status_p st)
  68 {
  69     int rc = 0;
  70     afs_status_t tst = 0;
  71
  72     /*
  73      * Validate input parameters
  74      */
  75
  76     if (serverHandle == NULL) {
  77         tst = ADMKASSERVERHANDLENULL;
  78         goto fail_IsValidServerHandle;
  79     }
  80
  81     if ((serverHandle->begin_magic != BEGIN_MAGIC)
  82         || (serverHandle->end_magic != END_MAGIC)) {
  83         tst = ADMKASSERVERHANDLEBADMAGIC;
  84         goto fail_IsValidServerHandle;
  85     }
  86
  87     if (!serverHandle->is_valid) {
  88         tst = ADMKASSERVERHANDLENOTVALID;
  89         goto fail_IsValidServerHandle;
  90     }
  91
  92     if (serverHandle->servers == NULL) {
  93         tst = ADMKASSERVERHANDLENOSERVERS;
  94         goto fail_IsValidServerHandle;
  95     }
  96     rc = 1;
  97
  98   fail_IsValidServerHandle:
  99
 100     if (st != NULL) {
 101         *st = tst;
 102     }
 103     return rc;
 104 }
 105
 106 /*
 107  * IsValidCellHandle - verify the validity of a afs_cell_handle_t handle
 108  * for doing kas related functions.
 109  *
 110  * PARAMETERS
 111  *
 112  * IN cellHandle - the handle to be verified.
 113  *
 114  * LOCKS
 115  *
 116  * No locks are obtained or released by this function
 117  *
 118  * RETURN CODES
 119  *
 120  * Returns != 0 upon successful completion.
 121  */
 122
 123 static int
 124 IsValidCellHandle(const afs_cell_handle_p cellHandle, afs_status_p st)
 125 {
 126     int rc = 0;
 127     afs_status_t tst = 0;
 128
 129     /*
 130      * Validate input parameters
 131      */
 132
 133     if (!CellHandleIsValid((void *)cellHandle, &tst)) {
 134         goto fail_IsValidCellHandle;
 135     }
 136
 137     if (!cellHandle->kas_valid) {
 138         tst = ADMCLIENTCELLKASINVALID;
 139         goto fail_IsValidCellHandle;
 140     }
 141
 142     if (cellHandle->kas == NULL) {
 143         tst = ADMCLIENTCELLKASNULL;
 144         goto fail_IsValidCellHandle;
 145     }
 146     rc = 1;
 147
 148   fail_IsValidCellHandle:
 149
 150     if (st != NULL) {
 151         *st = tst;
 152     }
 153     return rc;
 154 }
 155
 156 /*
 157  * For all kas admin functions that take a cellHandle and a serverHandle,
 158  * the intention is that is the cellHandle is not NULL, we should use
 159  * it.  Otherwise, we use the serverHandle.  It is an error for both
 160  * of these parameters to be non-NULL.
 161  */
 162
 163 /*
 164  * ChooseValidServer - given a serverHandle and a cellHandle, choose the
 165  * one that is non-NULL, validate it, and return a ubik_client structure
 166  * that contains it.
 167  *
 168  * PARAMETERS
 169  *
 170  * IN cellHandle - the cell where kas calls are to be made
 171  *
 172  * IN serverHandle - the group of server(s) that should be used to satisfy
 173  * kas calls.
 174  *
 175  * LOCKS
 176  *
 177  * No locks are obtained or released by this function
 178  *
 179  * RETURN CODES
 180  *
 181  * Returns != 0 upon successful completion.
 182  */
 183
 184 static int
 185 ChooseValidServer(const afs_cell_handle_p cellHandle,
 186                   const kas_server_p serverHandle, kas_server_p kasHandle,
 187                   afs_status_p st)
 188 {
 189     int rc = 0;
 190     afs_status_t tst = 0;
 191
 192     /*
 193      * Validate input parameters
 194      */
 195
 196     if (kasHandle == NULL) {
 197         tst = ADMKASKASHANDLENULL;
 198         goto fail_ChooseValidServer;
 199     }
 200
 201     /*
 202      * Only one of the input handle parameters to this function should
 203      * not be NULL
 204      */
 205     if ((cellHandle == NULL) && (serverHandle == NULL)) {
 206         tst = ADMKASCELLHANDLEANDSERVERHANDLENULL;
 207         goto fail_ChooseValidServer;
 208     }
 209
 210     if ((cellHandle != NULL) && (serverHandle != NULL)) {
 211         tst = ADMKASCELLHANDLEANDSERVERHANDLENOTNULL;
 212         goto fail_ChooseValidServer;
 213     }
 214
 215     /*
 216      * Validate the non-NULL handle
 217      */
 218
 219     if (cellHandle != NULL) {
 220         if (IsValidCellHandle(cellHandle, &tst)) {
 221             kasHandle->servers = cellHandle->kas;
 222             kasHandle->cell = cellHandle->working_cell;
 223         } else {
 224             goto fail_ChooseValidServer;
 225         }
 226     } else {
 227         if (IsValidServerHandle(serverHandle, &tst)) {
 228             kasHandle->servers = serverHandle->servers;
 229             kasHandle->cell = serverHandle->cell;
 230         } else {
 231             goto fail_ChooseValidServer;
 232         }
 233     }
 234
 235     kasHandle->begin_magic = BEGIN_MAGIC;
 236     kasHandle->end_magic = END_MAGIC;
 237     kasHandle->is_valid = 1;
 238     rc = 1;
 239
 240   fail_ChooseValidServer:
 241
 242     if (st != NULL) {
 243         *st = tst;
 244     }
 245     return rc;
 246 }
 247
 248
 249 static int
 250 kaentryinfo_to_kas_principalEntry_t(struct kaentryinfo *from,
 251                                     kas_principalEntry_p to, afs_status_p st)
 252 {
 253     int rc = 0;
 254     afs_status_t tst = 0;
 255     int short reuse;
 256     unsigned char misc_stuff[4];
 257
 258     if (from == NULL) {
 259         tst = ADMKASFROMNULL;
 260         goto fail_kaentryinfo_to_kas_principalEntry_t;
 261     }
 262
 263     if (to == NULL) {
 264         tst = ADMKASTONULL;
 265         goto fail_kaentryinfo_to_kas_principalEntry_t;
 266     }
 267
 268     if (from->flags & KAFADMIN) {
 269         to->adminSetting = KAS_ADMIN;
 270     } else {
 271         to->adminSetting = NO_KAS_ADMIN;
 272     }
 273
 274     if (from->flags & KAFNOTGS) {
 275         to->tgsSetting = NO_TGS;
 276     } else {
 277         to->tgsSetting = TGS;
 278     }
 279
 280     if (from->flags & KAFNOSEAL) {
 281         to->encSetting = NO_ENCRYPT;
 282     } else {
 283         to->encSetting = ENCRYPT;
 284     }
 285
 286     if (from->flags & KAFNOCPW) {
 287         to->cpwSetting = NO_CHANGE_PASSWORD;
 288     } else {
 289         to->cpwSetting = CHANGE_PASSWORD;
 290     }
 291
 292     reuse = (short)from->reserved3;
 293     if (!reuse) {
 294         to->rpwSetting = REUSE_PASSWORD;
 295     } else {
 296         to->rpwSetting = NO_REUSE_PASSWORD;
 297     }
 298
 299
 300     if (from->user_expiration == NEVERDATE) {
 301         to->userExpiration = 0;
 302     } else {
 303         to->userExpiration = from->user_expiration;
 304     }
 305
 306     to->lastModTime = from->modification_time;
 307     strcpy(to->lastModPrincipal.principal, from->modification_user.name);
 308     strcpy(to->lastModPrincipal.instance, from->modification_user.instance);
 309     to->lastChangePasswordTime = from->change_password_time;
 310     to->maxTicketLifetime = from->max_ticket_lifetime;
 311     to->keyVersion = from->key_version;
 312     memcpy(&to->key, &from->key, sizeof(to->key));
 313     to->keyCheckSum = from->keyCheckSum;
 314
 315     unpack_long(from->misc_auth_bytes, misc_stuff);
 316     to->daysToPasswordExpire = misc_stuff[0];
 317     to->failLoginCount = misc_stuff[2];
 318     to->lockTime = misc_stuff[3] << 9;
 319     rc = 1;
 320
 321   fail_kaentryinfo_to_kas_principalEntry_t:
 322
 323     if (st != NULL) {
 324         *st = tst;
 325     }
 326     return rc;
 327 }
 328
 329 /*
 330  * kas_ServerOpen - open a handle to a set of kaserver's.
 331  *
 332  * PARAMETERS
 333  *
 334  * IN cellHandle - a previously opened cellHandle that corresponds
 335  * to the cell where the server(s) live.
 336  *
 337  * IN serverList - a NULL terminated list (a la argv) of server's that
 338  * should be opened.
 339  *
 340  * OUT serverHandleP - a pointer to a void pointer that upon successful
 341  * completion contains serverHandle that can be used in other kas functions.
 342  *
 343  * LOCKS
 344  *
 345  * No locks are obtained or released by this function
 346  *
 347  * RETURN CODES
 348  *
 349  * Returns != 0 upon successful completion.
 350  *
 351  * ASSUMPTIONS
 352  *
 353  * This function make some assumptions about the afsconf_cell used by
 354  * ka_AuthSpecificServersConn (since I just wrote ka_AuthSpecificServersConn).
 355  * It only fills in the fields that are required.
 356  *
 357  * Also we assume that the servers listed are members of the cell in
 358  * cellHandle without verifying that this is in fact the case.  kas itself
 359  * always assumes that the -servers parameter lists servers in the current
 360  * cell without verifying, so I am no worse than the current
 361  * implementation.  In fact I'm actually a little more flexible since you
 362  * can actually use my serverList to play with servers in another cell.
 363  * You can't do that with kas.  For certain functions in kas the same
 364  * cell assumption can cause things to fail (the ka_StringToKey function in
 365  * UserCreate).
 366  */
 367
 368 int ADMINAPI
 369 kas_ServerOpen(const void *cellHandle, const char **serverList,
 370                void **serverHandleP, afs_status_p st)
 371 {
 372     int rc = 0;
 373     afs_status_t tst = 0;
 374     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
 375     int server_count = 0, server_addr;
 376     struct afsconf_cell server_info;
 377     kas_server_p k_handle = (kas_server_p) malloc(sizeof(kas_server_t));
 378
 379     /*
 380      * Validate input parameters
 381      */
 382
 383     if (c_handle == NULL) {
 384         tst = ADMCLIENTCELLHANDLENULL;
 385         goto fail_kas_ServerOpen;
 386     }
 387
 388     if (c_handle->kas_valid == 0) {
 389         tst = ADMCLIENTCELLKASINVALID;
 390         goto fail_kas_ServerOpen;
 391     }
 392
 393     if (serverList == NULL) {
 394         tst = ADMKASSERVERLISTNULL;
 395         goto fail_kas_ServerOpen;
 396     }
 397
 398     if (serverHandleP == NULL) {
 399         tst = ADMKASSERVERHANDLEPNULL;
 400         goto fail_kas_ServerOpen;
 401     }
 402
 403     if (k_handle == NULL) {
 404         tst = ADMNOMEM;
 405         goto fail_kas_ServerOpen;
 406     }
 407
 408     k_handle->begin_magic = BEGIN_MAGIC;
 409     k_handle->end_magic = END_MAGIC;
 410     k_handle->is_valid = 0;
 411     k_handle->servers = NULL;
 412
 413     /*
 414      * Convert serverList to numeric addresses
 415      */
 416
 417     for (server_count = 0; serverList[server_count] != NULL; server_count++) {
 418         if (server_count >= MAXHOSTSPERCELL) {
 419             tst = ADMKASSERVERLISTTOOLONG;
 420             goto fail_kas_ServerOpen;
 421         }
 422         if (util_AdminServerAddressGetFromName
 423             (serverList[server_count], &server_addr, &tst)) {
 424             server_info.hostAddr[server_count].sin_addr.s_addr =
 425                 htonl(server_addr);
 426             server_info.hostAddr[server_count].sin_port =
 427                 htons(AFSCONF_KAUTHPORT);
 428         } else {
 429             goto fail_kas_ServerOpen;
 430         }
 431     }
 432
 433     if (server_count == 0) {
 434         tst = ADMKASSERVERLISTEMPTY;
 435         goto fail_kas_ServerOpen;
 436     }
 437
 438     /*
 439      * Get a ubik_client handle for the specified servers
 440      */
 441     server_info.numServers = server_count;
 442     if (!
 443         (tst =
 444          ka_AuthSpecificServersConn(KA_MAINTENANCE_SERVICE,
 445                                     &c_handle->tokens->kas_token,
 446                                     &server_info, &k_handle->servers))) {
 447         k_handle->is_valid = 1;
 448         k_handle->cell = c_handle->working_cell;
 449         *serverHandleP = (void *)k_handle;
 450     } else {
 451         goto fail_kas_ServerOpen;
 452     }
 453     rc = 1;
 454
 455   fail_kas_ServerOpen:
 456
 457     if ((rc == 0) && (k_handle != NULL)) {
 458         free(k_handle);
 459     }
 460
 461     if (st != NULL) {
 462         *st = tst;
 463     }
 464     return rc;
 465 }
 466
 467 /*
 468  * kas_ServerClose - close a serverHandle.
 469  *
 470  * PARAMETERS
 471  *
 472  * IN serverHandle - a serverHandle previously returned by kas_ServerOpen.
 473  *
 474  * LOCKS
 475  *
 476  * No locks are obtained or released by this function
 477  *
 478  * RETURN CODES
 479  *
 480  * Returns != 0 upon successful completion.
 481  */
 482
 483 int ADMINAPI
 484 kas_ServerClose(const void *serverHandle, afs_status_p st)
 485 {
 486     int rc = 0;
 487     afs_status_t tst = 0;
 488     kas_server_p k_handle = (kas_server_p) serverHandle;
 489
 490     if (!IsValidServerHandle(k_handle, &tst)) {
 491         goto fail_kas_ServerClose;
 492     }
 493
 494     tst = ubik_ClientDestroy(k_handle->servers);
 495     if (tst) {
 496         goto fail_kas_ServerClose;
 497     }
 498
 499     k_handle->is_valid = 0;
 500     free(k_handle);
 501     rc = 1;
 502
 503   fail_kas_ServerClose:
 504
 505     if (st != NULL) {
 506         *st = tst;
 507     }
 508     return rc;
 509 }
 510
 511 /*
 512  * kas_PrincipalCreate - create a new principal.
 513  *
 514  * PARAMETERS
 515  *
 516  * IN cellHandle - a cellHandle previously returned by afsclient_CellOpen.
 517  *
 518  * IN serverHandle - a serverHandle previously returned by kas_ServerOpen.
 519  *
 520  * IN who - a kas_identity_p containing the identity of the new principal
 521  * to be created.
 522  *
 523  * IN password - the new principal's initial password.
 524  *
 525  * LOCKS
 526  *
 527  * No locks are obtained or released by this function
 528  *
 529  * RETURN CODES
 530  *
 531  * Returns != 0 upon successful completion.
 532  */
 533
 534 int ADMINAPI
 535 kas_PrincipalCreate(const void *cellHandle, const void *serverHandle,
 536                     const kas_identity_p who, const char *password,
 537                     afs_status_p st)
 538 {
 539     int rc = 0;
 540     afs_status_t tst = 0;
 541     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
 542     kas_server_p k_handle = (kas_server_p) serverHandle;
 543     kas_server_t kaserver;
 544     struct kas_encryptionKey key;
 545
 546     /*
 547      * Validate input arguments and make rpc.
 548      */
 549
 550     if (who == NULL) {
 551         tst = ADMKASWHONULL;
 552         goto fail_kas_PrincipalCreate;
 553     }
 554
 555     if (password == NULL) {
 556         tst = ADMKASPASSWORDNULL;
 557         goto fail_kas_PrincipalCreate;
 558     }
 559
 560     if (!ChooseValidServer(c_handle, k_handle, &kaserver, &tst)) {
 561         goto fail_kas_PrincipalCreate;
 562     }
 563
 564     if (!kas_StringToKey(kaserver.cell, password, &key, &tst)) {
 565         goto fail_kas_PrincipalCreate;
 566     }
 567
 568     tst =
 569         ubik_Call(KAM_CreateUser, kaserver.servers, 0, who->principal,
 570                   who->instance, key);
 571     if (tst) {
 572         goto fail_kas_PrincipalCreate;
 573     }
 574     rc = 1;
 575
 576
 577   fail_kas_PrincipalCreate:
 578
 579     if (st != NULL) {
 580         *st = tst;
 581     }
 582     return rc;
 583 }
 584
 585 /*
 586  * kas_PrincipalDelete - delete an existing principal.
 587  *
 588  * PARAMETERS
 589  *
 590  * IN cellHandle - a cellHandle previously returned by afsclient_CellOpen.
 591  *
 592  * IN serverHandle - a serverHandle previously returned by kas_ServerOpen.
 593  *
 594  * IN who - a kas_identity_p containing the identity of the principal
 595  * to be deleted.
 596  *
 597  * LOCKS
 598  *
 599  * No locks are obtained or released by this function
 600  *
 601  * RETURN CODES
 602  *
 603  * Returns != 0 upon successful completion.
 604  */
 605
 606 int ADMINAPI
 607 kas_PrincipalDelete(const void *cellHandle, const void *serverHandle,
 608                     const kas_identity_p who, afs_status_p st)
 609 {
 610     int rc = 0;
 611     afs_status_t tst = 0;
 612     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
 613     kas_server_p k_handle = (kas_server_p) serverHandle;
 614     kas_server_t kaserver;
 615
 616     /*
 617      * Validate input arguments and make rpc.
 618      */
 619
 620     if (who == NULL) {
 621         tst = ADMKASWHONULL;
 622         goto fail_kas_PrincipalDelete;
 623     }
 624
 625     if (!ChooseValidServer(c_handle, k_handle, &kaserver, &tst)) {
 626         goto fail_kas_PrincipalDelete;
 627     }
 628     tst =
 629         ubik_Call(KAM_DeleteUser, kaserver.servers, 0, who->principal,
 630                   who->instance);
 631     if (tst) {
 632         goto fail_kas_PrincipalDelete;
 633     }
 634     rc = 1;
 635
 636   fail_kas_PrincipalDelete:
 637
 638     if (st != NULL) {
 639         *st = tst;
 640     }
 641     return rc;
 642 }
 643
 644 /*
 645  * GetPrincipalLockStatus - get the lock status of a principal.
 646  *
 647  * PARAMETERS
 648  *
 649  * IN kaserver - a valid kaserver handle previously returned by
 650  * ChooseValidServer
 651  *
 652  * IN who - a kas_identity_p containing the identity of the principal
 653  * to be queried.
 654  *
 655  * OUT lockedUntil - the remaining number of seconds the principal is locked.
 656  *
 657  * LOCKS
 658  *
 659  * No locks are obtained or released by this function
 660  *
 661  * RETURN CODES
 662  *
 663  * Returns != 0 upon successful completion.
 664  */
 665
 666 static int
 667 GetPrincipalLockStatus(const kas_server_p kaserver, const kas_identity_p who,
 668                        unsigned int *lockedUntil, afs_status_p st)
 669 {
 670     int rc = 0;
 671     afs_status_t tst = 0;
 672     unsigned int locked;
 673     int count = 0;
 674     int once = 0;
 675
 676     /*
 677      * Validate input arguments and make rpc.
 678      */
 679
 680     if (kaserver == NULL) {
 681         tst = ADMKASKASERVERNULL;
 682         goto fail_GetPrincipalLockStatus;
 683     }
 684
 685     if (who == NULL) {
 686         tst = ADMKASWHONULL;
 687         goto fail_GetPrincipalLockStatus;
 688     }
 689
 690     if (lockedUntil == NULL) {
 691         tst = ADMKASLOCKEDUNTILNULL;
 692         goto fail_GetPrincipalLockStatus;
 693     }
 694
 695     /*
 696      * Unlike every other kas rpc we make here, the lock/unlock rpc's
 697      * aren't ubik based.  So instead of calling ubik_Call, we use
 698      * ubik_CallIter.  ubik_CallIter steps through the list of hosts
 699      * in the ubik_client and calls them one at a time.  Since there's
 700      * no synchronization of this data across the servers we have to
 701      * manually keep track of the shortest time to unlock the user ourselves.
 702      *
 703      * The original inspiration for this function is ka_islocked
 704      * in admin_tools.c.  I think that function is totally bogus so I'm
 705      * rewriting it here.
 706      *
 707      * This function should contact all the kaservers and request the lock
 708      * status of the principal.  If any of the servers say the principal is
 709      * unlocked, we report it as unlocked.  If all the servers say the
 710      * principal is locked, we find the server with the shortest lock time
 711      * remaining on the principal and return that time.
 712      *
 713      * This is different than kas, but I think kas is buggy.
 714      */
 715
 716     *lockedUntil = 0;
 717     do {
 718         locked = 0;
 719         tst =
 720             ubik_CallIter(KAM_LockStatus, kaserver->servers, UPUBIKONLY,
 721                           &count, who->principal, who->instance, &locked, 0,
 722                           0, 0, 0);
 723         if (tst == 0) {
 724             if (locked) {
 725                 if ((locked < *lockedUntil) || !once) {
 726                     *lockedUntil = locked;
 727                     once++;
 728                 }
 729             }
 730         }
 731     } while ((tst != UNOSERVERS) && (locked != 0));
 732
 733     /*
 734      * Check to see if any server reported this principal unlocked.
 735      */
 736
 737     if ((tst == 0) && (locked == 0)) {
 738         *lockedUntil = 0;
 739     }
 740     if ((tst == 0) || (tst == UNOSERVERS)) {
 741         rc = 1;
 742     }
 743
 744   fail_GetPrincipalLockStatus:
 745
 746     if (st != NULL) {
 747         *st = tst;
 748     }
 749     return rc;
 750 }
 751
 752 /*
 753  * kas_PrincipalGet - retrieve information about a single principal.
 754  *
 755  * PARAMETERS
 756  *
 757  * IN cellHandle - a cellHandle previously returned by afsclient_CellOpen.
 758  *
 759  * IN serverHandle - a serverHandle previously returned by kas_ServerOpen.
 760  *
 761  * IN who - a kas_identity_p containing the identity of the principal
 762  * to be retrieved.
 763  *
 764  * OUT principal - upon successful completion contains information
 765  * about who.
 766  *
 767  * LOCKS
 768  *
 769  * No locks are obtained or released by this function
 770  *
 771  * RETURN CODES
 772  *
 773  * Returns != 0 upon successful completion.
 774  */
 775
 776 int ADMINAPI
 777 kas_PrincipalGet(const void *cellHandle, const void *serverHandle,
 778                  const kas_identity_p who, kas_principalEntry_p principal,
 779                  afs_status_p st)
 780 {
 781     int rc = 0;
 782     afs_status_t tst = 0;
 783     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
 784     kas_server_p k_handle = (kas_server_p) serverHandle;
 785     kas_server_t kaserver;
 786     struct kaentryinfo entry;
 787
 788     /*
 789      * Validate input arguments and make rpc.
 790      */
 791
 792     if (who == NULL) {
 793         tst = ADMKASWHONULL;
 794         goto fail_kas_PrincipalGet;
 795     }
 796
 797     if (principal == NULL) {
 798         tst = ADMKASPRINCIPALNULL;
 799         goto fail_kas_PrincipalGet;
 800     }
 801
 802     if (!ChooseValidServer(c_handle, k_handle, &kaserver, &tst)) {
 803         goto fail_kas_PrincipalGet;
 804     }
 805
 806     tst =
 807         ubik_Call(KAM_GetEntry, kaserver.servers, 0, who->principal,
 808                   who->instance, KAMAJORVERSION, &entry);
 809     if (tst) {
 810         goto fail_kas_PrincipalGet;
 811     }
 812
 813     /*
 814      * copy the kaentryinfo structure to our kas_principalEntry_t
 815      * format
 816      */
 817     if (!kaentryinfo_to_kas_principalEntry_t(&entry, principal, &tst)) {
 818         goto fail_kas_PrincipalGet;
 819     }
 820     rc = 1;
 821
 822   fail_kas_PrincipalGet:
 823
 824     if (st != NULL) {
 825         *st = tst;
 826     }
 827     return rc;
 828 }
 829
 830 typedef struct principal_get {
 831     int current;
 832     int next;
 833     int count;
 834     kas_server_t kaserver;
 835     kas_identity_t principal[CACHED_ITEMS];
 836 } principal_get_t, *principal_get_p;
 837
 838 static int
 839 DeletePrincipalSpecificData(void *rpc_specific, afs_status_p st)
 840 {
 841     int rc = 0;
 842     afs_status_t tst = 0;
 843     principal_get_p prin = (principal_get_p) rpc_specific;
 844
 845     prin->kaserver.is_valid = 0;
 846     rc = 1;
 847
 848     if (st != NULL) {
 849         *st = tst;
 850     }
 851     return rc;
 852 }
 853
 854 static int
 855 GetPrincipalRPC(void *rpc_specific, int slot, int *last_item,
 856                 int *last_item_contains_data, afs_status_p st)
 857 {
 858     int rc = 0;
 859     afs_status_t tst = 0;
 860     principal_get_p prin = (principal_get_p) rpc_specific;
 861
 862     tst =
 863         ubik_Call(KAM_ListEntry, prin->kaserver.servers, 0, prin->current,
 864                   &prin->next, &prin->count, &prin->principal[slot]);
 865     if (tst == 0) {
 866         prin->current = prin->next;
 867         if (prin->next == 0) {
 868             *last_item = 1;
 869             *last_item_contains_data = 0;
 870         }
 871         rc = 1;
 872     }
 873
 874     if (st != NULL) {
 875         *st = tst;
 876     }
 877     return rc;
 878 }
 879
 880 static int
 881 GetPrincipalFromCache(void *rpc_specific, int slot, void *dest,
 882                       afs_status_p st)
 883 {
 884     int rc = 0;
 885     afs_status_t tst = 0;
 886     principal_get_p prin = (principal_get_p) rpc_specific;
 887
 888     memcpy(dest, &prin->principal[slot], sizeof(kas_identity_t));
 889     rc = 1;
 890
 891     if (st != NULL) {
 892         *st = tst;
 893     }
 894     return rc;
 895 }
 896
 897 /*
 898  * kas_PrincipalGetBegin - start the process of iterating over the entire
 899  * kas database.
 900  *
 901  * PARAMETERS
 902  *
 903  * IN cellHandle - a cellHandle previously returned by afsclient_CellOpen.
 904  *
 905  * IN serverHandle - a serverHandle previously returned by kas_ServerOpen.
 906  *
 907  * OUT iterationIdP - upon successful completion contains a iterator that
 908  * can be passed to kas_PrincipalGetNext.
 909  *
 910  * LOCKS
 911  *
 912  * No locks are obtained or released by this function
 913  *
 914  * RETURN CODES
 915  *
 916  * Returns != 0 upon successful completion.
 917  *
 918  * ASSUMPTIONS
 919  */
 920
 921 int ADMINAPI
 922 kas_PrincipalGetBegin(const void *cellHandle, const void *serverHandle,
 923                       void **iterationIdP, afs_status_p st)
 924 {
 925     int rc = 0;
 926     afs_status_t tst = 0;
 927     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
 928     kas_server_p k_handle = (kas_server_p) serverHandle;
 929     afs_admin_iterator_p iter =
 930         (afs_admin_iterator_p) malloc(sizeof(afs_admin_iterator_t));
 931     principal_get_p principal =
 932         (principal_get_p) malloc(sizeof(principal_get_t));
 933
 934     /*
 935      * Validate arguments
 936      */
 937
 938     if (iter == NULL) {
 939         tst = ADMNOMEM;
 940         goto fail_kas_PrincipalGetBegin;
 941     }
 942
 943     if (principal == NULL) {
 944         tst = ADMNOMEM;
 945         goto fail_kas_PrincipalGetBegin;
 946     }
 947
 948     if (iterationIdP == NULL) {
 949         tst = ADMITERATIONIDPNULL;
 950         goto fail_kas_PrincipalGetBegin;
 951     }
 952
 953     if (!ChooseValidServer(c_handle, k_handle, &principal->kaserver, &tst)) {
 954         goto fail_kas_PrincipalGetBegin;
 955     }
 956
 957     /*
 958      * Initialize the iterator structure
 959      */
 960
 961     principal->current = 0;
 962     principal->next = 0;
 963     principal->count = 0;
 964     if (IteratorInit
 965         (iter, (void *)principal, GetPrincipalRPC, GetPrincipalFromCache,
 966          NULL, DeletePrincipalSpecificData, &tst)) {
 967         *iterationIdP = (void *)iter;
 968         rc = 1;
 969     }
 970
 971   fail_kas_PrincipalGetBegin:
 972
 973     if (rc == 0) {
 974         if (iter != NULL) {
 975             free(iter);
 976         }
 977         if (principal != NULL) {
 978             free(principal);
 979         }
 980     }
 981
 982     if (st != NULL) {
 983         *st = tst;
 984     }
 985     return rc;
 986 }
 987
 988 /*
 989  * kas_PrincipalGetNext - retrieve the next principal from the kaserver.
 990  *
 991  * PARAMETERS
 992  *
 993  * IN iterationId - an iterator previously returned by kas_PrincipalGetBegin
 994  *
 995  * OUT who - upon successful completion contains the next principal from the
 996  * kaserver
 997  *
 998  * LOCKS
 999  *
1000  * Hold the iterator mutex across the call to the kaserver.
1001  *
1002  * RETURN CODES
1003  *
1004  * Returns != 0 upon successful completion.
1005  * Returns 0 and st == ADMITERATORDONE when the last entry is returned.
1006  */
1007
1008 int ADMINAPI
1009 kas_PrincipalGetNext(const void *iterationId, kas_identity_p who,
1010                      afs_status_p st)
1011 {
1012     int rc = 0;
1013     afs_status_t tst = 0;
1014     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
1015
1016     /*
1017      * Validate arguments
1018      */
1019
1020     if (who == NULL) {
1021         tst = ADMKASWHONULL;
1022         goto fail_kas_PrincipalGetNext;
1023     }
1024
1025     if (iter == NULL) {
1026         tst = ADMITERATORNULL;
1027         goto fail_kas_PrincipalGetNext;
1028     }
1029
1030     rc = IteratorNext(iter, (void *)who, &tst);
1031
1032   fail_kas_PrincipalGetNext:
1033
1034     if (st != NULL) {
1035         *st = tst;
1036     }
1037     return rc;
1038 }
1039
1040 /*
1041  * kas_PrincipalGetDone - finish using a principal iterator
1042  *
1043  * PARAMETERS
1044  *
1045  * IN iterationId - an iterator previously returned by kas_PrincipalGetBegin
1046  *
1047  * LOCKS
1048  *
1049  * No locks are held by this function.
1050  *
1051  * RETURN CODES
1052  *
1053  * Returns != 0 upon successful completion.
1054  *
1055  * ASSUMPTIONS
1056  *
1057  * It is the user's responsibility to make sure kas_PrincipalGetDone
1058  * is called only once for each iterator.
1059  */
1060
1061 int ADMINAPI
1062 kas_PrincipalGetDone(const void *iterationIdP, afs_status_p st)
1063 {
1064     int rc = 0;
1065     afs_status_t tst = 0;
1066     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationIdP;
1067
1068     /*
1069      * Validate argument
1070      */
1071
1072     if (iter == NULL) {
1073         tst = ADMITERATORNULL;
1074         goto fail_kas_PrincipalGetDone;
1075     }
1076
1077     rc = IteratorDone(iter, &tst);
1078
1079   fail_kas_PrincipalGetDone:
1080
1081     if (st != NULL) {
1082         *st = tst;
1083     }
1084     return rc;
1085 }
1086
1087 /*
1088  * kas_PrincipalKeySet - set a principal's password to a known value.
1089  *
1090  * PARAMETERS
1091  *
1092  * IN cellHandle - a cellHandle previously returned by afsclient_CellOpen.
1093  *
1094  * IN serverHandle - a serverHandle previously returned by kas_ServerOpen.
1095  *
1096  * IN who - the principal for whom the password is being set.
1097  *
1098  * IN keyVersion - the version number of the new key.
1099  *
1100  * IN key - the new password.
1101  *
1102  * LOCKS
1103  *
1104  * No locks are held by this function.
1105  *
1106  * RETURN CODES
1107  *
1108  * Returns != 0 upon successful completion.
1109  */
1110
1111 int ADMINAPI
1112 kas_PrincipalKeySet(const void *cellHandle, const void *serverHandle,
1113                     const kas_identity_p who, int keyVersion,
1114                     const kas_encryptionKey_p key, afs_status_p st)
1115 {
1116     int rc = 0;
1117     afs_status_t tst = 0;
1118     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
1119     kas_server_p k_handle = (kas_server_p) serverHandle;
1120     kas_server_t kaserver;
1121
1122     /*
1123      * Validate input arguments and make rpc.
1124      */
1125
1126     if (who == NULL) {
1127         tst = ADMKASWHONULL;
1128         goto fail_kas_PrincipalKeySet;
1129     }
1130
1131     if (key == NULL) {
1132         tst = ADMKASKEYNULL;
1133         goto fail_kas_PrincipalKeySet;
1134     }
1135
1136     if (!ChooseValidServer(c_handle, k_handle, &kaserver, &tst)) {
1137         goto fail_kas_PrincipalKeySet;
1138     }
1139
1140     tst =
1141         ubik_Call(KAM_SetPassword, kaserver.servers, 0, who->principal,
1142                   who->instance, keyVersion, *key);
1143     if (tst) {
1144         goto fail_kas_PrincipalKeySet;
1145     }
1146
1147     /* If we failed to fail we must have succeeded */
1148     rc = 1;
1149
1150   fail_kas_PrincipalKeySet:
1151
1152     if (st != NULL) {
1153         *st = tst;
1154     }
1155     return rc;
1156 }
1157
1158 /*
1159  * kas_PrincipalLockStatusGet - determine a principal's lock status.
1160  *
1161  * PARAMETERS
1162  *
1163  * IN cellHandle - a cellHandle previously returned by afsclient_CellOpen.
1164  *
1165  * IN serverHandle - a serverHandle previously returned by kas_ServerOpen.
1166  *
1167  * IN who - the principal whose lock status is being checked.
1168  *
1169  * OUT lock_end_timeP - the number of seconds until the principal is unlocked.
1170  * If 0 => user is unlocked.
1171  *
1172  * LOCKS
1173  *
1174  * No locks are held by this function.
1175  *
1176  * RETURN CODES
1177  *
1178  * Returns != 0 upon successful completion.
1179  *
1180  * ASSUMPTIONS
1181  *
1182  * See the comments in GetPrincipalLockStatus regarding how the locking data
1183  * is kept INconsistently between servers.
1184  */
1185
1186 int ADMINAPI
1187 kas_PrincipalLockStatusGet(const void *cellHandle, const void *serverHandle,
1188                            const kas_identity_p who,
1189                            unsigned int *lock_end_timeP, afs_status_p st)
1190 {
1191     int rc = 0;
1192     afs_status_t tst = 0;
1193     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
1194     kas_server_p k_handle = (kas_server_p) serverHandle;
1195     kas_server_t kaserver;
1196
1197     /*
1198      * Validate input arguments and make rpc.
1199      */
1200
1201     if (who == NULL) {
1202         tst = ADMKASWHONULL;
1203         goto fail_kas_PrincipalLockStatusGet;
1204     }
1205
1206     if (lock_end_timeP == NULL) {
1207         tst = ADMKASLOCKENDTIMEPNULL;
1208         goto fail_kas_PrincipalLockStatusGet;
1209     }
1210
1211     if (!ChooseValidServer(c_handle, k_handle, &kaserver, &tst)) {
1212         goto fail_kas_PrincipalLockStatusGet;
1213     }
1214
1215     rc = GetPrincipalLockStatus(&kaserver, who, lock_end_timeP, &tst);
1216
1217   fail_kas_PrincipalLockStatusGet:
1218
1219     if (st != NULL) {
1220         *st = tst;
1221     }
1222     return rc;
1223 }
1224
1225 /*
1226  * kas_PrincipalUnlock - unlock a principal.
1227  *
1228  * PARAMETERS
1229  *
1230  * IN cellHandle - a cellHandle previously returned by afsclient_CellOpen.
1231  *
1232  * IN serverHandle - a serverHandle previously returned by kas_ServerOpen.
1233  *
1234  * IN who - the principal who is being unlocked.
1235  *
1236  * LOCKS
1237  *
1238  * No locks are held by this function.
1239  *
1240  * RETURN CODES
1241  *
1242  * Returns != 0 upon successful completion.
1243  *
1244  * ASSUMPTIONS
1245  *
1246  * See the comments in GetPrincipalLockStatus regarding how the locking data
1247  * is kept INconsistently between servers.
1248  */
1249
1250 int ADMINAPI
1251 kas_PrincipalUnlock(const void *cellHandle, const void *serverHandle,
1252                     const kas_identity_p who, afs_status_p st)
1253 {
1254     int rc = 0;
1255     afs_status_t tst = 0;
1256     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
1257     kas_server_p k_handle = (kas_server_p) serverHandle;
1258     kas_server_t kaserver;
1259     int count = 0;
1260     afs_status_t save_tst = 0;
1261
1262     /*
1263      * Validate input arguments and make rpc.
1264      */
1265
1266     if (who == NULL) {
1267         tst = ADMKASWHONULL;
1268         goto fail_kas_PrincipalUnlock;
1269     }
1270
1271     if (!ChooseValidServer(c_handle, k_handle, &kaserver, &tst)) {
1272         goto fail_kas_PrincipalUnlock;
1273     }
1274
1275     do {
1276         tst =
1277             ubik_CallIter(KAM_Unlock, kaserver.servers, 0, &count,
1278                           who->principal, who->instance, 0, 0, 0, 0);
1279         if (tst && (tst != UNOSERVERS)) {
1280             if (save_tst == 0) {
1281                 save_tst = tst; /* save the first failure */
1282             }
1283         }
1284     } while (tst != UNOSERVERS);
1285
1286     if ((tst == 0) || (tst == UNOSERVERS)) {
1287         rc = 1;
1288     }
1289
1290   fail_kas_PrincipalUnlock:
1291
1292     if (st != NULL) {
1293         *st = tst;
1294     }
1295     return rc;
1296 }
1297
1298 static int
1299 getPrincipalFlags(const void *cellHandle, const void *serverHandle,
1300                   const kas_identity_p who, afs_int32 * cur_flags,
1301                   afs_status_p st)
1302 {
1303     int rc = 0;
1304     afs_status_t tst = 0;
1305     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
1306     kas_server_p k_handle = (kas_server_p) serverHandle;
1307     kas_server_t kaserver;
1308     struct kaentryinfo tentry;
1309
1310     if (!ChooseValidServer(c_handle, k_handle, &kaserver, &tst)) {
1311         goto fail_getPrincipalFlags;
1312     }
1313
1314     tst =
1315         ubik_Call(KAM_GetEntry, kaserver.servers, 0, who->principal,
1316                   who->instance, KAMAJORVERSION, &tentry);
1317     if (tst == 0) {
1318         *cur_flags = tentry.flags;
1319         rc = 1;
1320     }
1321
1322   fail_getPrincipalFlags:
1323
1324     if (st != NULL) {
1325         *st = tst;
1326     }
1327     return rc;
1328 }
1329
1330 /*
1331  * kas_PrincipalFieldsSet - modify an existing principal.
1332  *
1333  * PARAMETERS
1334  *
1335  * IN cellHandle - a cellHandle previously returned by afsclient_CellOpen.
1336  *
1337  * IN serverHandle - a serverHandle previously returned by kas_ServerOpen.
1338  *
1339  * IN who - the principal who is being modified.
1340  *
1341  * IN isAdmin - the admin status of the principal.
1342  *
1343  * IN grantTickets - should the TGS issue tickets for the principal.
1344  *
1345  * IN canEncrypt - should the TGS allow the use of encryption via the
1346  * principal's key.
1347  *
1348  * IN canChangePassword - should the principal be allowed to change their
1349  * own password?
1350  *
1351  * IN expirationDate - the date when the principal will expire.
1352  *
1353  * IN maxTicketLifetime - the maximum lifetime of a ticket issued for
1354  * the principal.
1355  *
1356  * IN passwordExpires - the maximum number of days a particular
1357  * password can be used.  The limit is 255, 0 => no expiration.
1358  *
1359  * IN passwordReuse - can a password be reused by this principal.
1360  *
1361  * IN failedPasswordAttempts - number of failed login attempts before
1362  * a principal is locked.  The limit is 255, 0 => no limit.
1363  *
1364  * IN failedPasswordLockTime - the number of seconds a principal is
1365  * locked once failedPasswordAttempts is reached.  Some bizarre rounding
1366  * occurs for this value, see kas for more details.
1367  *
1368  * LOCKS
1369  *
1370  * No locks are held by this function.
1371  *
1372  * RETURN CODES
1373  *
1374  * Returns != 0 upon successful completion.
1375  *
1376  * ASSUMPTIONS
1377  *
1378  * See the comments in GetPrincipalLockStatus regarding how the locking data
1379  * is kept INconsistently between servers.
1380  */
1381
1382 int ADMINAPI
1383 kas_PrincipalFieldsSet(const void *cellHandle, const void *serverHandle,
1384                        const kas_identity_p who, const kas_admin_p isAdmin,
1385                        const kas_tgs_p grantTickets,
1386                        const kas_enc_p canEncrypt,
1387                        const kas_cpw_p canChangePassword,
1388                        const unsigned int *expirationDate,
1389                        const unsigned int *maxTicketLifetime,
1390                        const unsigned int *passwordExpires,
1391                        const kas_rpw_p passwordReuse,
1392                        const unsigned int *failedPasswordAttempts,
1393                        const unsigned int *failedPasswordLockTime,
1394                        afs_status_p st)
1395 {
1396     int rc = 0;
1397     afs_status_t tst = 0;
1398     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
1399     kas_server_p k_handle = (kas_server_p) serverHandle;
1400     kas_server_t kaserver;
1401     afs_int32 flags = 0;
1402     Date expiration = 0;
1403     afs_int32 lifetime = 0;
1404     int was_spare;
1405     char spare_bytes[4] = { 0, 0, 0, 0 };
1406     int somethings_changing = 0;
1407
1408     /*
1409      * Validate input arguments.
1410      */
1411
1412     if (who == NULL) {
1413         tst = ADMKASWHONULL;
1414         goto fail_kas_PrincipalFieldsSet;
1415     }
1416
1417     /*
1418      * set flags based upon input
1419      *
1420      * If we're changing the flags, we need to get the current value of
1421      * the flags first and then make the changes
1422      */
1423
1424     if ((isAdmin != NULL) || (grantTickets != NULL) || (canEncrypt != NULL)
1425         || (canChangePassword != NULL)) {
1426         if (!getPrincipalFlags(cellHandle, serverHandle, who, &flags, &tst)) {
1427             goto fail_kas_PrincipalFieldsSet;
1428         }
1429     }
1430
1431     if (isAdmin != NULL) {
1432         somethings_changing = 1;
1433         if (*isAdmin == KAS_ADMIN) {
1434             flags |= KAFADMIN;
1435         } else {
1436             flags &= ~KAFADMIN;
1437         }
1438     }
1439
1440     if (grantTickets != NULL) {
1441         somethings_changing = 1;
1442         if (*grantTickets == NO_TGS) {
1443             flags |= KAFNOTGS;
1444         } else {
1445             flags &= ~KAFNOTGS;
1446         }
1447     }
1448
1449     if (canEncrypt != NULL) {
1450         somethings_changing = 1;
1451         if (*canEncrypt == NO_ENCRYPT) {
1452             flags |= KAFNOSEAL;
1453         } else {
1454             flags &= ~KAFNOSEAL;
1455         }
1456     }
1457
1458     if (canChangePassword != NULL) {
1459         somethings_changing = 1;
1460         if (*canChangePassword == NO_CHANGE_PASSWORD) {
1461             flags |= KAFNOCPW;
1462         } else {
1463             flags &= ~KAFNOCPW;
1464         }
1465     }
1466
1467     flags = (flags & KAF_SETTABLE_FLAGS) | KAFNORMAL;
1468
1469     if (expirationDate != NULL) {
1470         somethings_changing = 1;
1471         expiration = *expirationDate;
1472     }
1473
1474     if (maxTicketLifetime != NULL) {
1475         somethings_changing = 1;
1476         lifetime = *maxTicketLifetime;
1477     }
1478
1479     if (passwordExpires != NULL) {
1480         if (*passwordExpires > 255) {
1481             tst = ADMKASPASSWORDEXPIRESTOOBIG;
1482             goto fail_kas_PrincipalFieldsSet;
1483         }
1484         somethings_changing = 1;
1485         spare_bytes[0] = *passwordExpires + 1;
1486     }
1487
1488     if (passwordReuse != NULL) {
1489         somethings_changing = 1;
1490         if (*passwordReuse == REUSE_PASSWORD) {
1491             spare_bytes[1] = KA_REUSEPW;
1492         } else {
1493             spare_bytes[1] = KA_NOREUSEPW;
1494         }
1495     }
1496
1497     if (failedPasswordAttempts != NULL) {
1498         if (*failedPasswordAttempts > 255) {
1499             tst = ADMKASFAILEDPASSWORDATTEMPTSTOOBIG;
1500             goto fail_kas_PrincipalFieldsSet;
1501         }
1502         somethings_changing = 1;
1503         spare_bytes[2] = *failedPasswordAttempts + 1;
1504     }
1505
1506     if (failedPasswordLockTime != NULL) {
1507         if (*failedPasswordLockTime > 36 * 60 * 60) {
1508             tst = ADMKASFAILEDPASSWORDLOCKTIME;
1509             goto fail_kas_PrincipalFieldsSet;
1510         }
1511         somethings_changing = 1;
1512         spare_bytes[3] = ((*failedPasswordLockTime + 511) >> 9) + 1;
1513     }
1514
1515     was_spare = pack_long(spare_bytes);
1516
1517     if (somethings_changing) {
1518         if (!ChooseValidServer(c_handle, k_handle, &kaserver, &tst)) {
1519             goto fail_kas_PrincipalFieldsSet;
1520         }
1521         tst =
1522             ubik_Call(KAM_SetFields, kaserver.servers, 0, who->principal,
1523                       who->instance, flags, expiration, lifetime, -1,
1524                       was_spare, 0);
1525         if (tst == 0) {
1526             rc = 1;
1527         }
1528     } else {
1529         tst = ADMKASPRINCIPALFIELDSNOCHANGE;
1530     }
1531
1532   fail_kas_PrincipalFieldsSet:
1533
1534     if (st != NULL) {
1535         *st = tst;
1536     }
1537     return rc;
1538 }
1539
1540 /*
1541  * kas_ServerStatsGet - get server statistics.
1542  *
1543  * PARAMETERS
1544  *
1545  * IN cellHandle - a cellHandle previously returned by afsclient_CellOpen.
1546  *
1547  * IN serverHandle - a serverHandle previously returned by kas_ServerOpen.
1548  *
1549  * OUT stats - the statistics retrieved.
1550  *
1551  * LOCKS
1552  *
1553  * No locks are held by this function.
1554  *
1555  * RETURN CODES
1556  *
1557  * Returns != 0 upon successful completion.
1558  */
1559
1560 int ADMINAPI
1561 kas_ServerStatsGet(const void *cellHandle, const void *serverHandle,
1562                    kas_serverStats_p stats, afs_status_p st)
1563 {
1564     int rc = 0;
1565     afs_status_t tst = 0;
1566     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
1567     kas_server_p k_handle = (kas_server_p) serverHandle;
1568     kas_server_t kaserver;
1569     afs_int32 admins;
1570     kasstats statics;
1571     kadstats dynamics;
1572     size_t i;
1573
1574     /*
1575      * Validate input arguments and make rpc.
1576      */
1577
1578     if (stats == NULL) {
1579         tst = ADMKASSTATSNULL;
1580         goto fail_kas_ServerStatsGet;
1581     }
1582
1583     if (!ChooseValidServer(c_handle, k_handle, &kaserver, &tst)) {
1584         goto fail_kas_ServerStatsGet;
1585     }
1586
1587     tst =
1588         ubik_Call(KAM_GetStats, kaserver.servers, 0, KAMAJORVERSION, &admins,
1589                   &statics, &dynamics);
1590     if (tst) {
1591         goto fail_kas_ServerStatsGet;
1592     }
1593
1594     stats->allocations = statics.allocs;
1595     stats->frees = statics.frees;
1596     stats->changePasswordRequests = statics.cpws;
1597     stats->adminAccounts = admins;
1598     stats->host = dynamics.host;
1599     stats->serverStartTime = dynamics.start_time;
1600     stats->hashTableUtilization = dynamics.hashTableUtilization;
1601
1602     i = sizeof(kas_serverProcStats_t);
1603     memcpy(&stats->authenticate, &dynamics.Authenticate, i);
1604     memcpy(&stats->changePassword, &dynamics.ChangePassword, i);
1605     memcpy(&stats->getTicket, &dynamics.GetTicket, i);
1606     memcpy(&stats->createUser, &dynamics.CreateUser, i);
1607     memcpy(&stats->setPassword, &dynamics.SetPassword, i);
1608     memcpy(&stats->setFields, &dynamics.SetFields, i);
1609     memcpy(&stats->deleteUser, &dynamics.DeleteUser, i);
1610     memcpy(&stats->getEntry, &dynamics.GetEntry, i);
1611     memcpy(&stats->listEntry, &dynamics.ListEntry, i);
1612     memcpy(&stats->getStats, &dynamics.GetStats, i);
1613     memcpy(&stats->getPassword, &dynamics.GetPassword, i);
1614     memcpy(&stats->getRandomKey, &dynamics.GetRandomKey, i);
1615     memcpy(&stats->debug, &dynamics.Debug, i);
1616     memcpy(&stats->udpAuthenticate, &dynamics.UAuthenticate, i);
1617     memcpy(&stats->udpGetTicket, &dynamics.UGetTicket, i);
1618     memcpy(&stats->unlock, &dynamics.Unlock, i);
1619     memcpy(&stats->lockStatus, &dynamics.LockStatus, i);
1620
1621     stats->stringChecks = dynamics.string_checks;
1622     rc = 1;
1623
1624   fail_kas_ServerStatsGet:
1625
1626     if (st != NULL) {
1627         *st = tst;
1628     }
1629     return rc;
1630 }
1631
1632 /*
1633  * kas_ServerDebugGet - get server debug info.
1634  *
1635  * PARAMETERS
1636  *
1637  * IN cellHandle - a cellHandle previously returned by afsclient_CellOpen.
1638  *
1639  * IN serverHandle - a serverHandle previously returned by kas_ServerOpen.
1640  *
1641  * OUT stats - the debug info retrieved.
1642  *
1643  * LOCKS
1644  *
1645  * No locks are held by this function.
1646  *
1647  * RETURN CODES
1648  *
1649  * Returns != 0 upon successful completion.
1650  */
1651
1652 int ADMINAPI
1653 kas_ServerDebugGet(const void *cellHandle, const void *serverHandle,
1654                    kas_serverDebugInfo_p debug, afs_status_p st)
1655 {
1656     int rc = 0;
1657     afs_status_t tst = 0;
1658     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
1659     kas_server_p k_handle = (kas_server_p) serverHandle;
1660     kas_server_t kaserver;
1661     struct ka_debugInfo info;
1662     int i;
1663
1664     /*
1665      * Validate input arguments and make rpc.
1666      */
1667
1668     if (debug == NULL) {
1669         tst = ADMKASDEBUGNULL;
1670         goto fail_kas_ServerDebugGet;
1671     }
1672
1673     if (!ChooseValidServer(c_handle, k_handle, &kaserver, &tst)) {
1674         goto fail_kas_ServerDebugGet;
1675     }
1676     tst = ubik_Call(KAM_Debug, kaserver.servers, 0, KAMAJORVERSION, 0, &info);
1677     if (tst) {
1678         goto fail_kas_ServerDebugGet;
1679     }
1680     debug->host = info.host;
1681     debug->serverStartTime = info.startTime;
1682     debug->currentTime = info.reserved1;
1683     debug->noAuth = info.noAuth;
1684     debug->lastTransaction = info.lastTrans;
1685     strcpy(debug->lastOperation, info.lastOperation);
1686     strcpy(debug->lastPrincipalAuth, info.lastAuth);
1687     strcpy(debug->lastPrincipalUDPAuth, info.lastUAuth);
1688     strcpy(debug->lastPrincipalTGS, info.lastTGS);
1689     strcpy(debug->lastPrincipalUDPTGS, info.lastUTGS);
1690     strcpy(debug->lastPrincipalAdmin, info.lastAdmin);
1691     strcpy(debug->lastServerTGS, info.lastTGSServer);
1692     strcpy(debug->lastServerUDPTGS, info.lastUTGSServer);
1693     debug->nextAutoCheckPointWrite = info.nextAutoCPW;
1694     debug->updatesRemainingBeforeAutoCheckPointWrite = info.updatesRemaining;
1695     debug->dbHeaderRead = info.dbHeaderRead;
1696     debug->dbVersion = info.dbVersion;
1697     debug->dbFreePtr = info.dbFreePtr;
1698     debug->dbEOFPtr = info.dbEofPtr;
1699     debug->dbKvnoPtr = info.dbKvnoPtr;
1700     debug->dbSpecialKeysVersion = info.dbSpecialKeysVersion;
1701     debug->dbHeaderLock = info.cheader_lock;
1702     debug->keyCacheLock = info.keycache_lock;
1703     debug->keyCacheVersion = info.kcVersion;
1704     debug->keyCacheSize = info.kcSize;
1705     debug->keyCacheUsed = info.kcUsed;
1706     for (i = 0; i < info.kcUsed; i++) {
1707         debug->keyCache[i].lastUsed = info.kcInfo[i].used;
1708         debug->keyCache[i].keyVersionNumber = info.kcInfo[i].kvno;
1709         debug->keyCache[i].primary = info.kcInfo[i].primary;
1710         debug->keyCache[i].keyCheckSum = info.kcInfo[i].keycksum;
1711         strcpy(debug->keyCache[i].principal, info.kcInfo[i].principal);
1712     }
1713     rc = 1;
1714
1715   fail_kas_ServerDebugGet:
1716
1717     if (st != NULL) {
1718         *st = tst;
1719     }
1720     return rc;
1721 }
1722
1723 /*
1724  * kas_ServerRandomKeyGet - get a random key from a server.
1725  *
1726  * PARAMETERS
1727  *
1728  * IN cellHandle - a cellHandle previously returned by afsclient_CellOpen.
1729  *
1730  * IN serverHandle - a serverHandle previously returned by kas_ServerOpen.
1731  *
1732  * OUT key - a random key.
1733  *
1734  * LOCKS
1735  *
1736  * No locks are held by this function.
1737  *
1738  * RETURN CODES
1739  *
1740  * Returns != 0 upon successful completion.
1741  */
1742
1743 int ADMINAPI
1744 kas_ServerRandomKeyGet(const void *cellHandle, const void *serverHandle,
1745                        kas_encryptionKey_p key, afs_status_p st)
1746 {
1747     int rc = 0;
1748     afs_status_t tst = 0;
1749     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
1750     kas_server_p k_handle = (kas_server_p) serverHandle;
1751     kas_server_t kaserver;
1752
1753     /*
1754      * Validate input arguments and make rpc.
1755      */
1756
1757     if (key == NULL) {
1758         tst = ADMKASKEYNULL;
1759         goto fail_kas_ServerRandomKeyGet;
1760     }
1761
1762     if (!ChooseValidServer(c_handle, k_handle, &kaserver, &tst)) {
1763         goto fail_kas_ServerRandomKeyGet;
1764     }
1765
1766     tst = ubik_Call(KAM_GetRandomKey, kaserver.servers, 0, key);
1767     if (tst) {
1768         goto fail_kas_ServerRandomKeyGet;
1769     }
1770     rc = 1;
1771
1772   fail_kas_ServerRandomKeyGet:
1773
1774     if (st != NULL) {
1775         *st = tst;
1776     }
1777     return rc;
1778 }
1779
1780 /*
1781  * kas_StringToKey - turn a string key into a key.
1782  *
1783  * PARAMETERS
1784  *
1785  * IN cellName - the name of the cell where the key will be used.
1786  *
1787  * IN string - the string to be converted.
1788  *
1789  * OUT key - the encryption key.
1790  *
1791  * LOCKS
1792  *
1793  * No locks are held by this function.
1794  *
1795  * RETURN CODES
1796  *
1797  * Returns != 0 upon successful completion.
1798  */
1799
1800 int ADMINAPI
1801 kas_StringToKey(const char *cellName, const char *string,
1802                 kas_encryptionKey_p key, afs_status_p st)
1803 {
1804     int rc = 0;
1805     afs_status_t tst = 0;
1806
1807     ka_StringToKey(string, cellName, (struct ktc_encryptionKey *)key);
1808     rc = 1;
1809
1810     if (st != NULL) {
1811         *st = tst;
1812     }
1813     return rc;
1814 }
1815
1816
1817 /*
1818  * kas_KeyCheckSum - compute the checksum of an encryption key.
1819  *
1820  * PARAMETERS
1821  *
1822  * IN key - the encryption key.
1823  *
1824  * OUT cksumP - key checksum
1825  *
1826  * LOCKS
1827  *
1828  * No locks are held by this function.
1829  *
1830  * RETURN CODES
1831  *
1832  * Returns != 0 upon successful completion.
1833  */
1834
1835 int ADMINAPI
1836 kas_KeyCheckSum(const kas_encryptionKey_p key, unsigned int *cksumP,
1837                 afs_status_p st)
1838 {
1839     int rc = 0;
1840     afs_status_t tst = 0;
1841     afs_uint32 cksum32;
1842
1843     if ((tst = ka_KeyCheckSum((char *)key, &cksum32)) == 0) {
1844         *cksumP = cksum32;
1845         rc = 1;
1846     }
1847
1848     if (st != NULL) {
1849         *st = tst;
1850     }
1851     return rc;
1852 }