src/auth/cellconfig.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 <afs/stds.h>
  17 #include <afs/pthread_glock.h>
  18 #ifdef UKERNEL
  19 #include "afs/sysincludes.h"
  20 #include "afsincludes.h"
  21 #include "des/des.h"
  22 #include "rx/rxkad.h"
  23 #else /* UKERNEL */
  24 #include <sys/types.h>
  25 #ifdef AFS_NT40_ENV
  26 #include <winsock2.h>
  27 #include <sys/utime.h>
  28 #include <io.h>
  29 #include <WINNT/afssw.h>
  30 #else
  31 #include <sys/socket.h>
  32 #include <netinet/in.h>
  33 #include <netdb.h>
  34 #include <sys/file.h>
  35 #include <sys/time.h>
  36 #ifdef AFS_AFSDB_ENV
  37 #include <arpa/nameser.h>
  38 #ifdef HAVE_ARPA_NAMESER_COMPAT_H
  39 #include <arpa/nameser_compat.h>
  40 #endif
  41 #include <resolv.h>
  42 #endif /* AFS_AFSDB_ENV */
  43 #endif /* AFS_NT40_ENV */
  44 #include <afs/afsint.h>
  45 #include <errno.h>
  46 #include <ctype.h>
  47 #include <time.h>
  48 #include <stdio.h>
  49 #include <stdlib.h>
  50 #include <sys/stat.h>
  51 #include <fcntl.h>
  52 #include <string.h>
  53 #ifdef HAVE_UNISTD_H
  54 #include <unistd.h>
  55 #endif
  56 #include <rx/rxkad.h>
  57 #include <rx/rx.h>
  58 #endif /* UKERNEL */
  59 #include <afs/afsutil.h>
  60 #include "cellconfig.h"
  61 #include "keys.h"
  62 #ifdef AFS_NT40_ENV
  63 #ifdef AFS_AFSDB_ENV
  64 /* cm_dns.h depends on cellconfig.h */
  65 #include <cm_nls.h>
  66 #include <cm_dns.h>
  67 #endif /* AFS_AFSDB_ENV */
  68 #endif
  69 static struct afsconf_servPair serviceTable[] = {
  70     {"afs", 7000,},
  71     {"afscb", 7001,},
  72     {"afsprot", 7002,},
  73     {"afsvldb", 7003,},
  74     {"afskauth", 7004,},
  75     {"afsvol", 7005,},
  76     {"afserror", 7006,},
  77     {"afsnanny", 7007,},
  78     {"afsupdate", 7008,},
  79     {"afsrmtsys", 7009,},
  80     {"afsres", 7010,},          /* residency database for MR-AFS */
  81     {"afsremio", 7011,},        /* remote I/O interface for MR-AFS */
  82     {0, 0}                      /* insert new services before this spot */
  83 };
  84
  85 /* Prototypes */
  86 static afs_int32 afsconf_FindService(register const char *aname);
  87 static int TrimLine(char *abuffer, int abufsize);
  88 #ifdef AFS_NT40_ENV
  89 static int IsClientConfigDirectory(const char *path);
  90 static int GetCellNT(struct afsconf_dir *adir);
  91 #endif
  92 static int afsconf_Check(register struct afsconf_dir *adir);
  93 static int afsconf_Touch(register struct afsconf_dir *adir);
  94 static int GetCellUnix(struct afsconf_dir *adir);
  95 static int afsconf_OpenInternal(register struct afsconf_dir *adir, char *cell,
  96                                 char clones[]);
  97 static int ParseHostLine(char *aline, register struct sockaddr_in *addr,
  98                          char *aname, char *aclone);
  99 static int ParseCellLine(register char *aline, register char *aname,
 100                          register char *alname);
 101 static int afsconf_CloseInternal(register struct afsconf_dir *adir);
 102 static int afsconf_Reopen(register struct afsconf_dir *adir);
 103 static int SaveKeys(struct afsconf_dir *adir);
 104
 105 #ifndef T_AFSDB
 106 #define T_AFSDB 18              /* per RFC1183 section 1 */
 107 #endif
 108
 109 /*
 110  * Basic Rule: we touch "<AFSCONF_DIR>/CellServDB" every time we change anything, so
 111  * our code can tell if there is new info in the key files, the cell server db
 112  * files or any of the other files (and reopen the thing) if the date on
 113  * CellServDB changes.
 114  */
 115
 116 #if defined(AFS_SUN5_ENV) && !defined(__sparcv9)
 117 /* Solaris through 10 in 32 bit mode will return EMFILE if fopen can't
 118    get an fd <= 255. We allow the fileserver to claim more fds than that.
 119    This has always been a problem since pr_Initialize would have the same
 120    issue, but hpr_Initialize makes it more likely that we would see this.
 121    Work around it. This is not generic. It's coded with the needs of
 122    afsconf_* in mind only.
 123
 124    http://www.opensolaris.org/os/community/onnv/flag-days/pages/2006042001/
 125 */
 126
 127 #define BUFFER 4096
 128
 129 struct afsconf_iobuffer {
 130     int _file;
 131     char *buffer;
 132     char *ptr;
 133     char *endptr;
 134 };
 135
 136 typedef struct afsconf_iobuffer afsconf_FILE;
 137
 138 static afsconf_FILE *
 139 afsconf_fopen(const char *fname, const char *fmode)
 140 {
 141     int fd;
 142     afsconf_FILE *iop;
 143
 144     if ((fd = open(fname, O_RDONLY)) == -1) {
 145         return NULL;
 146     }
 147
 148     iop = malloc(sizeof(struct afsconf_iobuffer));
 149     if (iop == NULL) {
 150         (void) close(fd);
 151         errno = ENOMEM;
 152         return NULL;
 153     }
 154     iop->_file = fd;
 155     iop->buffer = malloc(BUFFER);
 156     if (iop->buffer == NULL) {
 157         (void) close(fd);
 158         free((void *) iop);
 159         errno = ENOMEM;
 160         return NULL;
 161     }
 162     iop->ptr = iop->buffer;
 163     iop->endptr = iop->buffer;
 164     return iop;
 165 }
 166
 167 static int
 168 afsconf_fclose(afsconf_FILE *iop)
 169 {
 170     if (iop == NULL) {
 171         return 0;
 172     }
 173     close(iop->_file);
 174     free((void *)iop->buffer);
 175     free((void *)iop);
 176     return 0;
 177 }
 178
 179 static char *
 180 afsconf_fgets(char *s, int n, afsconf_FILE *iop)
 181 {
 182     char *p;
 183
 184     p = s;
 185     for (;;) {
 186         char c;
 187
 188         if (iop->ptr == iop->endptr) {
 189             ssize_t len;
 190
 191             if ((len = read(iop->_file, (void *)iop->buffer, BUFFER)) == -1) {
 192                 return NULL;
 193             }
 194             if (len == 0) {
 195                 *p = 0;
 196                 if (s == p) {
 197                     return NULL;
 198                 }
 199                 return s;
 200             }
 201             iop->ptr = iop->buffer;
 202             iop->endptr = iop->buffer + len;
 203         }
 204         c = *iop->ptr++;
 205         *p++ = c;
 206         if ((p - s) == (n - 1)) {
 207             *p = 0;
 208             return s;
 209         }
 210         if (c == '\n') {
 211             *p = 0;
 212             return s;
 213         }
 214     }
 215 }
 216 #define fopen afsconf_fopen
 217 #define fclose afsconf_fclose
 218 #define fgets afsconf_fgets
 219 #else
 220 #define afsconf_FILE FILE
 221 #endif /* AFS_SUN5_ENV && ! __sparcv9 */
 222
 223 /* return port number in network byte order in the low 16 bits of a long; return -1 if not found */
 224 static afs_int32
 225 afsconf_FindService(register const char *aname)
 226 {
 227     /* lookup a service name */
 228     struct servent *ts;
 229     register struct afsconf_servPair *tsp;
 230
 231 #if     defined(AFS_OSF_ENV)
 232     ts = getservbyname(aname, "");
 233 #else
 234     ts = getservbyname(aname, NULL);
 235 #endif
 236     if (ts) {
 237         /* we found it in /etc/services, so we use this value */
 238         return ts->s_port;      /* already in network byte order */
 239     }
 240
 241     /* not found in /etc/services, see if it is one of ours */
 242     for (tsp = serviceTable;; tsp++) {
 243         if (tsp->name == NULL)
 244             return -1;
 245         if (!strcmp(tsp->name, aname))
 246             return htons(tsp->port);
 247     }
 248 }
 249
 250 static int
 251 TrimLine(char *abuffer, int abufsize)
 252 {
 253     char tbuffer[256];
 254     register char *tp;
 255     register int tc;
 256
 257     tp = abuffer;
 258     while ((tc = *tp)) {
 259         if (!isspace(tc))
 260             break;
 261         tp++;
 262     }
 263     strlcpy(tbuffer, tp, sizeof tbuffer);
 264     strlcpy(abuffer, tbuffer, abufsize);
 265     return 0;
 266 }
 267
 268 #ifdef AFS_NT40_ENV
 269 /*
 270  * IsClientConfigDirectory() -- determine if path matches well-known
 271  *     client configuration directory.
 272  */
 273 static int
 274 IsClientConfigDirectory(const char *path)
 275 {
 276     const char *cdir = AFSDIR_CLIENT_ETC_DIRPATH;
 277     int i;
 278
 279     for (i = 0; cdir[i] != '\0' && path[i] != '\0'; i++) {
 280         int cc = tolower(cdir[i]);
 281         int pc = tolower(path[i]);
 282
 283         if (cc == '\\') {
 284             cc = '/';
 285         }
 286         if (pc == '\\') {
 287             pc = '/';
 288         }
 289         if (cc != pc) {
 290             return 0;
 291         }
 292     }
 293
 294     /* hit end of one or both; allow mismatch in existence of trailing slash */
 295     if (cdir[i] != '\0') {
 296         if ((cdir[i] != '\\' && cdir[i] != '/') || (cdir[i + 1] != '\0')) {
 297             return 0;
 298         }
 299     }
 300     if (path[i] != '\0') {
 301         if ((path[i] != '\\' && path[i] != '/') || (path[i + 1] != '\0')) {
 302             return 0;
 303         }
 304     }
 305     return 1;
 306 }
 307 #endif /* AFS_NT40_ENV */
 308
 309
 310 static int
 311 afsconf_Check(register struct afsconf_dir *adir)
 312 {
 313     char tbuffer[256];
 314 #ifdef AFS_NT40_ENV
 315     char *p;
 316 #endif
 317     struct stat tstat;
 318     register afs_int32 code;
 319
 320 #ifdef AFS_NT40_ENV
 321     /* NT client CellServDB has different file name than NT server or Unix */
 322     if (IsClientConfigDirectory(adir->name)) {
 323         if (!afssw_GetClientCellServDBDir(&p)) {
 324             strcompose(tbuffer, sizeof(tbuffer), p, "/",
 325                        AFSDIR_CELLSERVDB_FILE_NTCLIENT, NULL);
 326             free(p);
 327         } else {
 328             int len;
 329             strncpy(tbuffer, adir->name, sizeof(tbuffer));
 330             len = (int)strlen(tbuffer);
 331             if (tbuffer[len - 1] != '\\' && tbuffer[len - 1] != '/') {
 332                 strncat(tbuffer, "\\", sizeof(tbuffer));
 333             }
 334             strncat(tbuffer, AFSDIR_CELLSERVDB_FILE_NTCLIENT,
 335                     sizeof(tbuffer));
 336             tbuffer[sizeof(tbuffer) - 1] = '\0';
 337         }
 338     } else {
 339         strcompose(tbuffer, 256, adir->name, "/", AFSDIR_CELLSERVDB_FILE,
 340                    NULL);
 341     }
 342 #else
 343     strcompose(tbuffer, 256, adir->name, "/", AFSDIR_CELLSERVDB_FILE, NULL);
 344 #endif /* AFS_NT40_ENV */
 345
 346     code = stat(tbuffer, &tstat);
 347     if (code < 0) {
 348         return code;
 349     }
 350     /* did file change? */
 351     if (tstat.st_mtime == adir->timeRead) {
 352         return 0;
 353     }
 354     /* otherwise file has changed, so reopen it */
 355     return afsconf_Reopen(adir);
 356 }
 357
 358 /* set modtime on file */
 359 static int
 360 afsconf_Touch(register struct afsconf_dir *adir)
 361 {
 362     char tbuffer[256];
 363 #ifndef AFS_NT40_ENV
 364     struct timeval tvp[2];
 365 #else
 366     char *p;
 367 #endif
 368
 369     adir->timeRead = 0;         /* just in case */
 370
 371 #ifdef AFS_NT40_ENV
 372     /* NT client CellServDB has different file name than NT server or Unix */
 373
 374     if (IsClientConfigDirectory(adir->name)) {
 375         if (!afssw_GetClientCellServDBDir(&p)) {
 376             strcompose(tbuffer, sizeof(tbuffer), p, "/",
 377                        AFSDIR_CELLSERVDB_FILE_NTCLIENT, NULL);
 378             free(p);
 379         } else {
 380             int len = (int)strlen(tbuffer);
 381             if (tbuffer[len - 1] != '\\' && tbuffer[len - 1] != '/') {
 382                 strncat(tbuffer, "\\", sizeof(tbuffer));
 383             }
 384             strncat(tbuffer, AFSDIR_CELLSERVDB_FILE_NTCLIENT,
 385                     sizeof(tbuffer));
 386             tbuffer[sizeof(tbuffer) - 1] = '\0';
 387         }
 388     } else {
 389         strcompose(tbuffer, 256, adir->name, "/", AFSDIR_CELLSERVDB_FILE,
 390                    NULL);
 391     }
 392
 393     return _utime(tbuffer, NULL);
 394
 395 #else
 396     strcompose(tbuffer, 256, adir->name, "/", AFSDIR_CELLSERVDB_FILE, NULL);
 397     gettimeofday(&tvp[0], NULL);
 398     tvp[1] = tvp[0];
 399     return utimes(tbuffer, tvp);
 400 #endif /* AFS_NT40_ENV */
 401 }
 402
 403 struct afsconf_dir *
 404 afsconf_Open(register const char *adir)
 405 {
 406     register struct afsconf_dir *tdir;
 407     register afs_int32 code;
 408
 409     LOCK_GLOBAL_MUTEX;
 410     /* zero structure and fill in name; rest is done by internal routine */
 411     tdir = (struct afsconf_dir *)malloc(sizeof(struct afsconf_dir));
 412     memset(tdir, 0, sizeof(struct afsconf_dir));
 413     tdir->name = strdup(adir);
 414
 415     code = afsconf_OpenInternal(tdir, 0, 0);
 416     if (code) {
 417         char *afsconf_path, afs_confdir[128];
 418
 419         free(tdir->name);
 420         /* Check global place only when local Open failed for whatever reason */
 421         if (!(afsconf_path = getenv("AFSCONF"))) {
 422             /* The "AFSCONF" environment (or contents of "/.AFSCONF") will be typically set to something like "/afs/<cell>/common/etc" where, by convention, the default files for "ThisCell" and "CellServDB" will reside; note that a major drawback is that a given afs client on that cell may NOT contain the same contents... */
 423             char *home_dir;
 424             afsconf_FILE *fp;
 425             size_t len;
 426
 427             if (!(home_dir = getenv("HOME"))) {
 428                 /* Our last chance is the "/.AFSCONF" file */
 429                 fp = fopen("/.AFSCONF", "r");
 430                 if (fp == 0) {
 431                     free(tdir);
 432                     UNLOCK_GLOBAL_MUTEX;
 433                     return (struct afsconf_dir *)0;
 434                 }
 435                 fgets(afs_confdir, 128, fp);
 436                 fclose(fp);
 437             } else {
 438                 char pathname[256];
 439
 440                 sprintf(pathname, "%s/%s", home_dir, ".AFSCONF");
 441                 fp = fopen(pathname, "r");
 442                 if (fp == 0) {
 443                     /* Our last chance is the "/.AFSCONF" file */
 444                     fp = fopen("/.AFSCONF", "r");
 445                     if (fp == 0) {
 446                         free(tdir);
 447                         UNLOCK_GLOBAL_MUTEX;
 448                         return (struct afsconf_dir *)0;
 449                     }
 450                 }
 451                 fgets(afs_confdir, 128, fp);
 452                 fclose(fp);
 453             }
 454             len = strlen(afs_confdir);
 455             if (len == 0) {
 456                 free(tdir);
 457                 UNLOCK_GLOBAL_MUTEX;
 458                 return (struct afsconf_dir *)0;
 459             }
 460             if (afs_confdir[len - 1] == '\n') {
 461                 afs_confdir[len - 1] = 0;
 462             }
 463             afsconf_path = afs_confdir;
 464         }
 465         tdir->name = strdup(afsconf_path);
 466         code = afsconf_OpenInternal(tdir, 0, 0);
 467         if (code) {
 468             free(tdir->name);
 469             free(tdir);
 470             UNLOCK_GLOBAL_MUTEX;
 471             return (struct afsconf_dir *)0;
 472         }
 473     }
 474     UNLOCK_GLOBAL_MUTEX;
 475     return tdir;
 476 }
 477
 478 static int
 479 GetCellUnix(struct afsconf_dir *adir)
 480 {
 481     char *rc;
 482     char tbuffer[256];
 483     char *start, *p;
 484     afsconf_FILE *fp;
 485
 486     strcompose(tbuffer, 256, adir->name, "/", AFSDIR_THISCELL_FILE, NULL);
 487     fp = fopen(tbuffer, "r");
 488     if (fp == 0) {
 489         return -1;
 490     }
 491     rc = fgets(tbuffer, 256, fp);
 492     fclose(fp);
 493     if (rc == NULL)
 494         return -1;
 495
 496     start = tbuffer;
 497     while (*start != '\0' && isspace(*start))
 498         start++;
 499     p = start;
 500     while (*p != '\0' && !isspace(*p))
 501         p++;
 502     *p = '\0';
 503     if (*start == '\0')
 504         return -1;
 505
 506     adir->cellName = strdup(start);
 507     return 0;
 508 }
 509
 510
 511 #ifdef AFS_NT40_ENV
 512 static int
 513 GetCellNT(struct afsconf_dir *adir)
 514 {
 515     if (IsClientConfigDirectory(adir->name)) {
 516         /* NT client config dir; ThisCell is in registry (no file). */
 517         return afssw_GetClientCellName(&adir->cellName);
 518     } else {
 519         /* NT server config dir; works just like Unix */
 520         return GetCellUnix(adir);
 521     }
 522 }
 523 #endif /* AFS_NT40_ENV */
 524
 525
 526 static int
 527 afsconf_OpenInternal(register struct afsconf_dir *adir, char *cell,
 528                      char clones[])
 529 {
 530     afsconf_FILE *tf;
 531     register char *tp, *bp;
 532     register struct afsconf_entry *curEntry;
 533     struct afsconf_aliasentry *curAlias;
 534     register afs_int32 code;
 535     afs_int32 i;
 536     char tbuffer[256], tbuf1[256];
 537     struct stat tstat;
 538
 539     /* figure out the local cell name */
 540 #ifdef AFS_NT40_ENV
 541     i = GetCellNT(adir);
 542 #else
 543     i = GetCellUnix(adir);
 544 #endif
 545
 546 #ifndef AFS_FREELANCE_CLIENT    /* no local cell not fatal in freelance */
 547     if (i) {
 548         return i;
 549     }
 550 #endif
 551
 552     /* now parse the individual lines */
 553     curEntry = 0;
 554
 555 #ifdef AFS_NT40_ENV
 556     /* NT client/server have a CellServDB that is the same format as Unix.
 557      * However, the NT client uses a different file name
 558      */
 559     if (IsClientConfigDirectory(adir->name)) {
 560         /* NT client config dir */
 561         char *p;
 562         if (!afssw_GetClientCellServDBDir(&p)) {
 563             strcompose(tbuffer, sizeof(tbuffer), p, "/",
 564                        AFSDIR_CELLSERVDB_FILE_NTCLIENT, NULL);
 565             free(p);
 566         } else {
 567             int len;
 568             strncpy(tbuffer, adir->name, sizeof(tbuffer));
 569             len = (int)strlen(tbuffer);
 570             if (tbuffer[len - 1] != '\\' && tbuffer[len - 1] != '/') {
 571                 strncat(tbuffer, "\\", sizeof(tbuffer));
 572             }
 573             strncat(tbuffer, AFSDIR_CELLSERVDB_FILE_NTCLIENT,
 574                     sizeof(tbuffer));
 575             tbuffer[sizeof(tbuffer) - 1] = '\0';
 576         }
 577     } else {
 578         /* NT server config dir */
 579         strcompose(tbuffer, 256, adir->name, "/", AFSDIR_CELLSERVDB_FILE,
 580                    NULL);
 581     }
 582 #else
 583     strcompose(tbuffer, 256, adir->name, "/", AFSDIR_CELLSERVDB_FILE, NULL);
 584 #endif /* AFS_NT40_ENV */
 585
 586     if (!stat(tbuffer, &tstat)) {
 587         adir->timeRead = tstat.st_mtime;
 588     } else {
 589         adir->timeRead = 0;
 590     }
 591
 592     strlcpy(tbuf1, tbuffer, sizeof tbuf1);
 593     tf = fopen(tbuffer, "r");
 594     if (!tf) {
 595         return -1;
 596     }
 597     while (1) {
 598         tp = fgets(tbuffer, sizeof(tbuffer), tf);
 599         if (!tp)
 600             break;
 601         TrimLine(tbuffer, sizeof tbuffer);      /* remove white space */
 602         if (tbuffer[0] == 0 || tbuffer[0] == '\n')
 603             continue;           /* empty line */
 604         if (tbuffer[0] == '>') {
 605             char linkedcell[MAXCELLCHARS];
 606             /* start new cell item */
 607             if (curEntry) {
 608                 /* thread this guy on the list */
 609                 curEntry->next = adir->entries;
 610                 adir->entries = curEntry;
 611                 curEntry = 0;
 612             }
 613             curEntry =
 614                 (struct afsconf_entry *)malloc(sizeof(struct afsconf_entry));
 615             memset(curEntry, 0, sizeof(struct afsconf_entry));
 616             code =
 617                 ParseCellLine(tbuffer, curEntry->cellInfo.name, linkedcell);
 618             if (code) {
 619                 afsconf_CloseInternal(adir);
 620                 fclose(tf);
 621                 free(curEntry);
 622                 return -1;
 623             }
 624             if (linkedcell[0] != '\0')
 625                 curEntry->cellInfo.linkedCell = strdup(linkedcell);
 626         } else {
 627             /* new host in the current cell */
 628             if (!curEntry) {
 629                 afsconf_CloseInternal(adir);
 630                 fclose(tf);
 631                 return -1;
 632             }
 633             i = curEntry->cellInfo.numServers;
 634             if (cell && !strcmp(cell, curEntry->cellInfo.name))
 635                 code =
 636                     ParseHostLine(tbuffer, &curEntry->cellInfo.hostAddr[i],
 637                                   curEntry->cellInfo.hostName[i], &clones[i]);
 638             else
 639                 code =
 640                     ParseHostLine(tbuffer, &curEntry->cellInfo.hostAddr[i],
 641                                   curEntry->cellInfo.hostName[i], 0);
 642             if (code) {
 643                 if (code == AFSCONF_SYNTAX) {
 644                     for (bp = tbuffer; *bp != '\n'; bp++) {     /* Take out the <cr> from the buffer */
 645                         if (!*bp)
 646                             break;
 647                     }
 648                     *bp = '\0';
 649                     fprintf(stderr,
 650                             "Can't properly parse host line \"%s\" in configuration file %s\n",
 651                             tbuffer, tbuf1);
 652                 }
 653                 free(curEntry);
 654                 fclose(tf);
 655                 afsconf_CloseInternal(adir);
 656                 return -1;
 657             }
 658             curEntry->cellInfo.numServers = ++i;
 659         }
 660     }
 661     fclose(tf);                 /* close the file now */
 662
 663     /* end the last partially-completed cell */
 664     if (curEntry) {
 665         curEntry->next = adir->entries;
 666         adir->entries = curEntry;
 667     }
 668
 669     /* Read in the alias list */
 670     strcompose(tbuffer, 256, adir->name, "/", AFSDIR_CELLALIAS_FILE, NULL);
 671
 672     tf = fopen(tbuffer, "r");
 673     while (tf) {
 674         char *aliasPtr;
 675
 676         tp = fgets(tbuffer, sizeof(tbuffer), tf);
 677         if (!tp)
 678             break;
 679         TrimLine(tbuffer, sizeof tbuffer);      /* remove white space */
 680
 681         if (tbuffer[0] == '\0' || tbuffer[0] == '\n' || tbuffer[0] == '#')
 682             continue;           /* empty line */
 683
 684         tp = tbuffer;
 685         while (tp[0] != '\0' && tp[0] != ' ' && tp[0] != '\t')
 686             tp++;
 687         if (tp[0] == '\0')
 688             continue;           /* invalid line */
 689
 690         while (tp[0] != '\0' && (tp[0] == ' ' || tp[0] == '\t'))
 691             0[tp++] = '\0';
 692         if (tp[0] == '\0')
 693             continue;           /* invalid line */
 694
 695         aliasPtr = tp;
 696         while (tp[0] != '\0' && tp[0] != ' ' && tp[0] != '\t' && tp[0] != '\r'
 697                && tp[0] != '\n')
 698             tp++;
 699         tp[0] = '\0';
 700
 701         curAlias = malloc(sizeof(*curAlias));
 702         memset(curAlias, 0, sizeof(*curAlias));
 703
 704         strlcpy(curAlias->aliasInfo.aliasName, aliasPtr, sizeof curAlias->aliasInfo.aliasName);
 705         strlcpy(curAlias->aliasInfo.realName, tbuffer, sizeof curAlias->aliasInfo.realName);
 706
 707         curAlias->next = adir->alias_entries;
 708         adir->alias_entries = curAlias;
 709     }
 710
 711     if (tf != NULL)
 712         fclose(tf);
 713     /* now read the fs keys, if possible */
 714     adir->keystr = (struct afsconf_keys *)0;
 715     afsconf_IntGetKeys(adir);
 716
 717     return 0;
 718 }
 719
 720 /* parse a line of the form
 721  *"128.2.1.3   #hostname" or
 722  *"[128.2.1.3]  #hostname" for clones
 723  * into the appropriate pieces.
 724  */
 725 static int
 726 ParseHostLine(char *aline, register struct sockaddr_in *addr, char *aname,
 727               char *aclone)
 728 {
 729     int c1, c2, c3, c4;
 730     register afs_int32 code;
 731     register char *tp;
 732
 733     if (*aline == '[') {
 734         if (aclone)
 735             *aclone = 1;
 736         /* FIXME: length of aname unknown here */
 737         code = sscanf(aline, "[%d.%d.%d.%d] #%s", &c1, &c2, &c3, &c4, aname);
 738     } else {
 739         if (aclone)
 740             *aclone = 0;
 741         /* FIXME: length of aname unknown here */
 742         code = sscanf(aline, "%d.%d.%d.%d #%s", &c1, &c2, &c3, &c4, aname);
 743     }
 744     if (code != 5)
 745         return AFSCONF_SYNTAX;
 746     addr->sin_family = AF_INET;
 747     addr->sin_port = 0;
 748 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
 749     addr->sin_len = sizeof(struct sockaddr_in);
 750 #endif
 751     tp = (char *)&addr->sin_addr;
 752     *tp++ = c1;
 753     *tp++ = c2;
 754     *tp++ = c3;
 755     *tp++ = c4;
 756     return 0;
 757 }
 758
 759 /* parse a line of the form
 760  * ">cellname [linkedcellname] [#comments]"
 761  * into the appropriate pieces.
 762  */
 763 static int
 764 ParseCellLine(register char *aline, register char *aname,
 765               register char *alname)
 766 {
 767     register int code;
 768     /* FIXME: length of aname, alname unknown here */
 769     code = sscanf(aline, ">%s %s", aname, alname);
 770     if (code == 1)
 771         *alname = '\0';
 772     if (code == 2) {
 773         if (*alname == '#') {
 774             *alname = '\0';
 775         }
 776     }
 777     return (code > 0 ? 0 : AFSCONF_SYNTAX);
 778 }
 779
 780 /* call aproc(entry, arock, adir) for all cells.  Proc must return 0, or we'll stop early and return the code it returns */
 781 int
 782 afsconf_CellApply(struct afsconf_dir *adir,
 783                   int (*aproc) (struct afsconf_cell * cell, void *arock,
 784                                 struct afsconf_dir * dir), void *arock)
 785 {
 786     register struct afsconf_entry *tde;
 787     register afs_int32 code;
 788     LOCK_GLOBAL_MUTEX;
 789     for (tde = adir->entries; tde; tde = tde->next) {
 790         code = (*aproc) (&tde->cellInfo, arock, adir);
 791         if (code) {
 792             UNLOCK_GLOBAL_MUTEX;
 793             return code;
 794         }
 795     }
 796     UNLOCK_GLOBAL_MUTEX;
 797     return 0;
 798 }
 799
 800 /* call aproc(entry, arock, adir) for all cell aliases.
 801  * Proc must return 0, or we'll stop early and return the code it returns
 802  */
 803 int
 804 afsconf_CellAliasApply(struct afsconf_dir *adir,
 805                        int (*aproc) (struct afsconf_cellalias * alias,
 806                                      void *arock, struct afsconf_dir * dir),
 807                        void *arock)
 808 {
 809     register struct afsconf_aliasentry *tde;
 810     register afs_int32 code;
 811     LOCK_GLOBAL_MUTEX;
 812     for (tde = adir->alias_entries; tde; tde = tde->next) {
 813         code = (*aproc) (&tde->aliasInfo, arock, adir);
 814         if (code) {
 815             UNLOCK_GLOBAL_MUTEX;
 816             return code;
 817         }
 818     }
 819     UNLOCK_GLOBAL_MUTEX;
 820     return 0;
 821 }
 822
 823 afs_int32 afsconf_SawCell = 0;
 824
 825 int
 826 afsconf_GetExtendedCellInfo(struct afsconf_dir *adir, char *acellName,
 827                             char *aservice, struct afsconf_cell *acellInfo,
 828                             char clones[])
 829 {
 830     afs_int32 code;
 831     char *cell;
 832
 833     code = afsconf_GetCellInfo(adir, acellName, aservice, acellInfo);
 834     if (code)
 835         return code;
 836
 837     if (acellName)
 838         cell = acellName;
 839     else
 840         cell = (char *)&acellInfo->name;
 841
 842     code = afsconf_OpenInternal(adir, cell, clones);
 843     return code;
 844 }
 845
 846 #ifdef AFS_AFSDB_ENV
 847 #if !defined(AFS_NT40_ENV)
 848 int
 849 afsconf_GetAfsdbInfo(char *acellName, char *aservice,
 850                      struct afsconf_cell *acellInfo)
 851 {
 852     afs_int32 code;
 853     int tservice, i, len;
 854     unsigned char answer[1024];
 855     unsigned char *p;
 856     char *dotcellname;
 857     int cellnamelength;
 858     char realCellName[256];
 859     char host[256];
 860     int server_num = 0;
 861     int minttl = 0;
 862     int try_init = 0;
 863
 864     /* The resolver isn't always MT-safe.. Perhaps this ought to be
 865      * replaced with a more fine-grained lock just for the resolver
 866      * operations.
 867      */
 868
 869  retryafsdb:
 870     if ( ! strchr(acellName,'.') ) {
 871        cellnamelength=strlen(acellName);
 872        dotcellname=malloc(cellnamelength+2);
 873        memcpy(dotcellname,acellName,cellnamelength);
 874        dotcellname[cellnamelength]='.';
 875        dotcellname[cellnamelength+1]=0;
 876        LOCK_GLOBAL_MUTEX;
 877        len = res_search(dotcellname, C_IN, T_AFSDB, answer, sizeof(answer));
 878        if ( len < 0 ) {
 879           len = res_search(acellName, C_IN, T_AFSDB, answer, sizeof(answer));
 880        }
 881        UNLOCK_GLOBAL_MUTEX;
 882        free(dotcellname);
 883     } else {
 884        LOCK_GLOBAL_MUTEX;
 885        len = res_search(acellName, C_IN, T_AFSDB, answer, sizeof(answer));
 886        UNLOCK_GLOBAL_MUTEX;
 887     }
 888     if (len < 0) {
 889         if (try_init < 1) {
 890             try_init++;
 891             res_init();
 892             goto retryafsdb;
 893         }
 894         return AFSCONF_NOTFOUND;
 895     }
 896
 897     p = answer + sizeof(HEADER);        /* Skip header */
 898     code = dn_expand(answer, answer + len, p, host, sizeof(host));
 899     if (code < 0)
 900         return AFSCONF_NOTFOUND;
 901
 902     p += code + QFIXEDSZ;       /* Skip name */
 903
 904     while (p < answer + len) {
 905         int type, ttl, size;
 906
 907         code = dn_expand(answer, answer + len, p, host, sizeof(host));
 908         if (code < 0)
 909             return AFSCONF_NOTFOUND;
 910
 911         p += code;              /* Skip the name */
 912         type = (p[0] << 8) | p[1];
 913         p += 4;                 /* Skip type and class */
 914         ttl = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 915         p += 4;                 /* Skip the TTL */
 916         size = (p[0] << 8) | p[1];
 917         p += 2;                 /* Skip the size */
 918
 919         if (type == T_AFSDB) {
 920             struct hostent *he;
 921             short afsdb_type;
 922
 923             afsdb_type = (p[0] << 8) | p[1];
 924             if (afsdb_type == 1) {
 925                 /*
 926                  * We know this is an AFSDB record for our cell, of the
 927                  * right AFSDB type.  Write down the true cell name that
 928                  * the resolver gave us above.
 929                  */
 930                 strlcpy(realCellName, host, sizeof realCellName);
 931             }
 932
 933             code = dn_expand(answer, answer + len, p + 2, host, sizeof(host));
 934             if (code < 0)
 935                 return AFSCONF_NOTFOUND;
 936
 937             if ((afsdb_type == 1) && (server_num < MAXHOSTSPERCELL) &&
 938                 /* Do we want to get TTL data for the A record as well? */
 939                 (he = gethostbyname(host))) {
 940                 afs_int32 ipaddr;
 941                 memcpy(&ipaddr, he->h_addr, he->h_length);
 942                 acellInfo->hostAddr[server_num].sin_addr.s_addr = ipaddr;
 943                 strncpy(acellInfo->hostName[server_num], host,
 944                         sizeof(acellInfo->hostName[server_num]));
 945                 server_num++;
 946
 947                 if (!minttl || ttl < minttl)
 948                     minttl = ttl;
 949             }
 950         }
 951
 952         p += size;
 953     }
 954
 955     if (server_num == 0)        /* No AFSDB records */
 956         return AFSCONF_NOTFOUND;
 957
 958     /* Convert the real cell name to lowercase */
 959     for (p = (unsigned char *)realCellName; *p; p++)
 960         *p = tolower(*p);
 961
 962     strncpy(acellInfo->name, realCellName, sizeof(acellInfo->name));
 963     acellInfo->numServers = server_num;
 964
 965     if (aservice) {
 966         tservice = afsconf_FindService(aservice);
 967         if (tservice < 0)
 968             return AFSCONF_NOTFOUND;    /* service not found */
 969         for (i = 0; i < acellInfo->numServers; i++) {
 970             acellInfo->hostAddr[i].sin_port = tservice;
 971         }
 972     }
 973
 974     acellInfo->timeout = minttl ? (time(0) + minttl) : 0;
 975
 976     return 0;
 977 }
 978 #else /* windows */
 979 int
 980 afsconf_GetAfsdbInfo(char *acellName, char *aservice,
 981                      struct afsconf_cell *acellInfo)
 982 {
 983     register afs_int32 i;
 984     int tservice;
 985     struct afsconf_entry DNSce;
 986     afs_int32 cellHostAddrs[AFSMAXCELLHOSTS];
 987     char cellHostNames[AFSMAXCELLHOSTS][MAXHOSTCHARS];
 988     int numServers;
 989     int rc;
 990     int ttl;
 991
 992     DNSce.cellInfo.numServers = 0;
 993     DNSce.next = NULL;
 994     rc = getAFSServer(acellName, cellHostAddrs, cellHostNames, &numServers,
 995                       &ttl);
 996     /* ignore the ttl here since this code is only called by transitory programs
 997      * like klog, etc. */
 998     if (rc < 0)
 999         return -1;
1000     if (numServers == 0)
1001         return -1;
1002
1003     for (i = 0; i < numServers; i++) {
1004         memcpy(&acellInfo->hostAddr[i].sin_addr.s_addr, &cellHostAddrs[i],
1005                sizeof(long));
1006         memcpy(acellInfo->hostName[i], cellHostNames[i], MAXHOSTCHARS);
1007         acellInfo->hostAddr[i].sin_family = AF_INET;
1008
1009         /* sin_port supplied by connection code */
1010     }
1011
1012     acellInfo->numServers = numServers;
1013     strlcpy(acellInfo->name, acellName, sizeof acellInfo->name);
1014     if (aservice) {
1015         LOCK_GLOBAL_MUTEX;
1016         tservice = afsconf_FindService(aservice);
1017         UNLOCK_GLOBAL_MUTEX;
1018         if (tservice < 0) {
1019             return AFSCONF_NOTFOUND;    /* service not found */
1020         }
1021         for (i = 0; i < acellInfo->numServers; i++) {
1022             acellInfo->hostAddr[i].sin_port = tservice;
1023         }
1024     }
1025     acellInfo->linkedCell = NULL;       /* no linked cell */
1026     acellInfo->flags = 0;
1027     return 0;
1028 }
1029 #endif /* windows */
1030 #endif /* AFS_AFSDB_ENV */
1031
1032 int
1033 afsconf_GetCellInfo(struct afsconf_dir *adir, char *acellName, char *aservice,
1034                     struct afsconf_cell *acellInfo)
1035 {
1036     register struct afsconf_entry *tce;
1037     struct afsconf_aliasentry *tcae;
1038     struct afsconf_entry *bestce;
1039     register afs_int32 i;
1040     int tservice;
1041     char *tcell;
1042     int cnLen;
1043     int ambig;
1044     char tbuffer[64];
1045
1046     LOCK_GLOBAL_MUTEX;
1047     if (adir)
1048         afsconf_Check(adir);
1049     if (acellName) {
1050         tcell = acellName;
1051         cnLen = (int)(strlen(tcell) + 1);
1052         lcstring(tcell, tcell, cnLen);
1053         afsconf_SawCell = 1;    /* will ignore the AFSCELL switch on future */
1054         /* call to afsconf_GetLocalCell: like klog  */
1055     } else {
1056         i = afsconf_GetLocalCell(adir, tbuffer, sizeof(tbuffer));
1057         if (i) {
1058             UNLOCK_GLOBAL_MUTEX;
1059             return i;
1060         }
1061         tcell = tbuffer;
1062     }
1063     cnLen = strlen(tcell);
1064     bestce = (struct afsconf_entry *)0;
1065     ambig = 0;
1066     if (!adir) {
1067         UNLOCK_GLOBAL_MUTEX;
1068         return 0;
1069     }
1070
1071     /* Look through the list of aliases */
1072     for (tcae = adir->alias_entries; tcae; tcae = tcae->next) {
1073         if (strcasecmp(tcae->aliasInfo.aliasName, tcell) == 0) {
1074             tcell = tcae->aliasInfo.realName;
1075             break;
1076         }
1077     }
1078
1079     for (tce = adir->entries; tce; tce = tce->next) {
1080         if (strcasecmp(tce->cellInfo.name, tcell) == 0) {
1081             /* found our cell */
1082             bestce = tce;
1083             ambig = 0;
1084             break;
1085         }
1086         if (strlen(tce->cellInfo.name) < cnLen)
1087             continue;           /* clearly wrong */
1088         if (strncasecmp(tce->cellInfo.name, tcell, cnLen) == 0) {
1089             if (bestce)
1090                 ambig = 1;      /* ambiguous unless we get exact match */
1091             bestce = tce;
1092         }
1093     }
1094     if (!ambig && bestce && bestce->cellInfo.numServers) {
1095         *acellInfo = bestce->cellInfo;  /* structure assignment */
1096         if (aservice) {
1097             tservice = afsconf_FindService(aservice);
1098             if (tservice < 0) {
1099                 UNLOCK_GLOBAL_MUTEX;
1100                 return AFSCONF_NOTFOUND;        /* service not found */
1101             }
1102             for (i = 0; i < acellInfo->numServers; i++) {
1103                 acellInfo->hostAddr[i].sin_port = tservice;
1104             }
1105         }
1106         acellInfo->timeout = 0;
1107         UNLOCK_GLOBAL_MUTEX;
1108         return 0;
1109     } else {
1110         UNLOCK_GLOBAL_MUTEX;
1111 #ifdef AFS_AFSDB_ENV
1112         return afsconf_GetAfsdbInfo(tcell, aservice, acellInfo);
1113 #else
1114         return AFSCONF_NOTFOUND;
1115 #endif /* AFS_AFSDB_ENV */
1116     }
1117 }
1118
1119 int
1120 afsconf_GetLocalCell(register struct afsconf_dir *adir, char *aname,
1121                      afs_int32 alen)
1122 {
1123     static int afsconf_showcell = 0;
1124     char *afscell_path;
1125     afs_int32 code = 0;
1126
1127     LOCK_GLOBAL_MUTEX;
1128     /*
1129      * If a cell switch was specified in a command, then it should override the
1130      * AFSCELL variable.  If a cell was specified, then the afsconf_SawCell flag
1131      * is set and the cell name in the adir structure is used.
1132      * Read the AFSCELL var each time: in case it changes (unsetenv AFSCELL).
1133      */
1134     if (!afsconf_SawCell && (afscell_path = getenv("AFSCELL"))) {
1135         if (!afsconf_showcell) {
1136             fprintf(stderr, "Note: Operation is performed on cell %s\n",
1137                     afscell_path);
1138             afsconf_showcell = 1;
1139         }
1140         strncpy(aname, afscell_path, alen);
1141     } else {
1142         afsconf_Check(adir);
1143         if (adir->cellName) {
1144             strncpy(aname, adir->cellName, alen);
1145         } else
1146             code = AFSCONF_UNKNOWN;
1147     }
1148
1149     UNLOCK_GLOBAL_MUTEX;
1150     return (code);
1151 }
1152
1153 int
1154 afsconf_Close(struct afsconf_dir *adir)
1155 {
1156     LOCK_GLOBAL_MUTEX;
1157     afsconf_CloseInternal(adir);
1158     if (adir->name)
1159         free(adir->name);
1160     free(adir);
1161     UNLOCK_GLOBAL_MUTEX;
1162     return 0;
1163 }
1164
1165 static int
1166 afsconf_CloseInternal(register struct afsconf_dir *adir)
1167 {
1168     register struct afsconf_entry *td, *nd;
1169     struct afsconf_aliasentry *ta, *na;
1170     register char *tname;
1171
1172     tname = adir->name;         /* remember name, since that's all we preserve */
1173
1174     /* free everything we can find */
1175     if (adir->cellName)
1176         free(adir->cellName);
1177     for (td = adir->entries; td; td = nd) {
1178         nd = td->next;
1179         if (td->cellInfo.linkedCell)
1180             free(td->cellInfo.linkedCell);
1181         free(td);
1182     }
1183     for (ta = adir->alias_entries; ta; ta = na) {
1184         na = ta->next;
1185         free(ta);
1186     }
1187     if (adir->keystr)
1188         free(adir->keystr);
1189
1190     /* reinit */
1191     memset(adir, 0, sizeof(struct afsconf_dir));
1192     adir->name = tname;         /* restore it */
1193     return 0;
1194 }
1195
1196 static int
1197 afsconf_Reopen(register struct afsconf_dir *adir)
1198 {
1199     register afs_int32 code;
1200     code = afsconf_CloseInternal(adir);
1201     if (code)
1202         return code;
1203     code = afsconf_OpenInternal(adir, 0, 0);
1204     return code;
1205 }
1206
1207 /* called during opening of config file */
1208 int
1209 afsconf_IntGetKeys(struct afsconf_dir *adir)
1210 {
1211     char tbuffer[256];
1212     register int fd;
1213     struct afsconf_keys *tstr;
1214     register afs_int32 code;
1215
1216 #ifdef AFS_NT40_ENV
1217     /* NT client config dir has no KeyFile; don't risk attempting open
1218      * because there might be a random file of this name if dir is shared.
1219      */
1220     if (IsClientConfigDirectory(adir->name)) {
1221         adir->keystr = ((struct afsconf_keys *)
1222                         malloc(sizeof(struct afsconf_keys)));
1223         adir->keystr->nkeys = 0;
1224         return 0;
1225     }
1226 #endif /* AFS_NT40_ENV */
1227
1228     LOCK_GLOBAL_MUTEX;
1229     /* compute the key name and other setup */
1230     strcompose(tbuffer, 256, adir->name, "/", AFSDIR_KEY_FILE, NULL);
1231     tstr = (struct afsconf_keys *)malloc(sizeof(struct afsconf_keys));
1232     adir->keystr = tstr;
1233
1234     /* read key file */
1235     fd = open(tbuffer, O_RDONLY);
1236     if (fd < 0) {
1237         tstr->nkeys = 0;
1238         UNLOCK_GLOBAL_MUTEX;
1239         return 0;
1240     }
1241     code = read(fd, tstr, sizeof(struct afsconf_keys));
1242     close(fd);
1243     if (code < sizeof(afs_int32)) {
1244         tstr->nkeys = 0;
1245         UNLOCK_GLOBAL_MUTEX;
1246         return 0;
1247     }
1248
1249     /* convert key structure to host order */
1250     tstr->nkeys = ntohl(tstr->nkeys);
1251
1252     if (code < sizeof(afs_int32) + (tstr->nkeys*sizeof(struct afsconf_key))) {
1253         tstr->nkeys = 0;
1254         UNLOCK_GLOBAL_MUTEX;
1255         return 0;
1256     }
1257
1258     for (fd = 0; fd < tstr->nkeys; fd++)
1259         tstr->key[fd].kvno = ntohl(tstr->key[fd].kvno);
1260
1261     UNLOCK_GLOBAL_MUTEX;
1262     return 0;
1263 }
1264
1265 /* get keys structure */
1266 int
1267 afsconf_GetKeys(struct afsconf_dir *adir, struct afsconf_keys *astr)
1268 {
1269     register afs_int32 code;
1270
1271     LOCK_GLOBAL_MUTEX;
1272     code = afsconf_Check(adir);
1273     if (code) {
1274         UNLOCK_GLOBAL_MUTEX;
1275         return AFSCONF_FAILURE;
1276     }
1277     memcpy(astr, adir->keystr, sizeof(struct afsconf_keys));
1278     UNLOCK_GLOBAL_MUTEX;
1279     return 0;
1280 }
1281
1282 /* get latest key */
1283 afs_int32
1284 afsconf_GetLatestKey(struct afsconf_dir * adir, afs_int32 * avno,
1285                      struct ktc_encryptionKey *akey)
1286 {
1287     register int i;
1288     int maxa;
1289     register struct afsconf_key *tk;
1290     register afs_int32 best;
1291     struct afsconf_key *bestk;
1292     register afs_int32 code;
1293
1294     LOCK_GLOBAL_MUTEX;
1295     code = afsconf_Check(adir);
1296     if (code) {
1297         UNLOCK_GLOBAL_MUTEX;
1298         return AFSCONF_FAILURE;
1299     }
1300     maxa = adir->keystr->nkeys;
1301
1302     best = -1;                  /* highest kvno we've seen yet */
1303     bestk = (struct afsconf_key *)0;    /* ptr to structure providing best */
1304     for (tk = adir->keystr->key, i = 0; i < maxa; i++, tk++) {
1305         if (tk->kvno == 999)
1306             continue;           /* skip bcrypt keys */
1307         if (tk->kvno > best) {
1308             best = tk->kvno;
1309             bestk = tk;
1310         }
1311     }
1312     if (bestk) {                /* found any  */
1313         if (akey)
1314             memcpy(akey, bestk->key, 8);        /* copy out latest key */
1315         if (avno)
1316             *avno = bestk->kvno;        /* and kvno to caller */
1317         UNLOCK_GLOBAL_MUTEX;
1318         return 0;
1319     }
1320     UNLOCK_GLOBAL_MUTEX;
1321     return AFSCONF_NOTFOUND;    /* didn't find any keys */
1322 }
1323
1324 /* get a particular key */
1325 int
1326 afsconf_GetKey(void *rock, int avno, struct ktc_encryptionKey *akey)
1327 {
1328     struct afsconf_dir *adir = (struct afsconf_dir *) rock;
1329     register int i, maxa;
1330     register struct afsconf_key *tk;
1331     register afs_int32 code;
1332
1333     LOCK_GLOBAL_MUTEX;
1334     code = afsconf_Check(adir);
1335     if (code) {
1336         UNLOCK_GLOBAL_MUTEX;
1337         return AFSCONF_FAILURE;
1338     }
1339     maxa = adir->keystr->nkeys;
1340
1341     for (tk = adir->keystr->key, i = 0; i < maxa; i++, tk++) {
1342         if (tk->kvno == avno) {
1343             memcpy(akey, tk->key, 8);
1344             UNLOCK_GLOBAL_MUTEX;
1345             return 0;
1346         }
1347     }
1348
1349     UNLOCK_GLOBAL_MUTEX;
1350     return AFSCONF_NOTFOUND;
1351 }
1352
1353 /* save the key structure in the appropriate file */
1354 static int
1355 SaveKeys(struct afsconf_dir *adir)
1356 {
1357     struct afsconf_keys tkeys;
1358     register int fd;
1359     register afs_int32 i;
1360     char tbuffer[256];
1361
1362     memcpy(&tkeys, adir->keystr, sizeof(struct afsconf_keys));
1363
1364     /* convert it to net byte order */
1365     for (i = 0; i < tkeys.nkeys; i++)
1366         tkeys.key[i].kvno = htonl(tkeys.key[i].kvno);
1367     tkeys.nkeys = htonl(tkeys.nkeys);
1368
1369     /* rewrite keys file */
1370     strcompose(tbuffer, 256, adir->name, "/", AFSDIR_KEY_FILE, NULL);
1371     fd = open(tbuffer, O_RDWR | O_CREAT | O_TRUNC, 0600);
1372     if (fd < 0)
1373         return AFSCONF_FAILURE;
1374     i = write(fd, &tkeys, sizeof(tkeys));
1375     if (i != sizeof(tkeys)) {
1376         close(fd);
1377         return AFSCONF_FAILURE;
1378     }
1379     if (close(fd) < 0)
1380         return AFSCONF_FAILURE;
1381     return 0;
1382 }
1383
1384 int
1385 afsconf_AddKey(struct afsconf_dir *adir, afs_int32 akvno, char akey[8],
1386                afs_int32 overwrite)
1387 {
1388     register struct afsconf_keys *tk;
1389     register struct afsconf_key *tkey;
1390     register afs_int32 i;
1391     int foundSlot;
1392
1393     LOCK_GLOBAL_MUTEX;
1394     tk = adir->keystr;
1395
1396     if (akvno != 999) {
1397         if (akvno < 0 || akvno > 255) {
1398             UNLOCK_GLOBAL_MUTEX;
1399             return ERANGE;
1400         }
1401     }
1402     foundSlot = 0;
1403     for (i = 0, tkey = tk->key; i < tk->nkeys; i++, tkey++) {
1404         if (tkey->kvno == akvno) {
1405             if (!overwrite) {
1406                 UNLOCK_GLOBAL_MUTEX;
1407                 return AFSCONF_KEYINUSE;
1408             }
1409             foundSlot = 1;
1410             break;
1411         }
1412     }
1413     if (!foundSlot) {
1414         if (tk->nkeys >= AFSCONF_MAXKEYS) {
1415             UNLOCK_GLOBAL_MUTEX;
1416             return AFSCONF_FULL;
1417         }
1418         tkey = &tk->key[tk->nkeys++];
1419     }
1420     tkey->kvno = akvno;
1421     memcpy(tkey->key, akey, 8);
1422     i = SaveKeys(adir);
1423     afsconf_Touch(adir);
1424     UNLOCK_GLOBAL_MUTEX;
1425     return i;
1426 }
1427
1428 /* this proc works by sliding the other guys down, rather than using a funny
1429     kvno value, so that callers can count on getting a good key in key[0].
1430 */
1431 int
1432 afsconf_DeleteKey(struct afsconf_dir *adir, afs_int32 akvno)
1433 {
1434     register struct afsconf_keys *tk;
1435     register struct afsconf_key *tkey;
1436     register int i;
1437     int foundFlag = 0;
1438
1439     LOCK_GLOBAL_MUTEX;
1440     tk = adir->keystr;
1441
1442     for (i = 0, tkey = tk->key; i < tk->nkeys; i++, tkey++) {
1443         if (tkey->kvno == akvno) {
1444             foundFlag = 1;
1445             break;
1446         }
1447     }
1448     if (!foundFlag) {
1449         UNLOCK_GLOBAL_MUTEX;
1450         return AFSCONF_NOTFOUND;
1451     }
1452
1453     /* otherwise slide the others down.  i and tkey point at the guy to delete */
1454     for (; i < tk->nkeys - 1; i++, tkey++) {
1455         tkey->kvno = (tkey + 1)->kvno;
1456         memcpy(tkey->key, (tkey + 1)->key, 8);
1457     }
1458     tk->nkeys--;
1459     i = SaveKeys(adir);
1460     afsconf_Touch(adir);
1461     UNLOCK_GLOBAL_MUTEX;
1462     return i;
1463 }