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