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("$Header$");
  14
  15 #include <afs/stds.h>
  16 #include <afs/pthread_glock.h>
  17 #ifdef UKERNEL
  18 #include "../afs/sysincludes.h"
  19 #include "../afs/afsincludes.h"
  20 #else /* UKERNEL */
  21 #include <sys/types.h>
  22 #ifdef AFS_NT40_ENV
  23 #include <winsock2.h>
  24 #include <sys/utime.h>
  25 #include <io.h>
  26 #include <WINNT/afssw.h>
  27 #else
  28 #include <sys/socket.h>
  29 #include <netinet/in.h>
  30 #include <netdb.h>
  31 #include <sys/file.h>
  32 #include <sys/time.h>
  33 #ifdef AFS_AFSDB_ENV
  34 #include <arpa/nameser.h>
  35 #include <resolv.h>
  36 #endif /* AFS_AFSDB_ENV */
  37 #endif /* AFS_NT40_ENV */
  38 #include <errno.h>
  39 #include <ctype.h>
  40 #include <time.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <sys/stat.h>
  44 #include <fcntl.h>
  45 #ifdef HAVE_STRING_H
  46 #include <string.h>
  47 #else
  48 #ifdef HAVE_STRINGS_H
  49 #include <strings.h>
  50 #endif
  51 #endif
  52 #ifdef HAVE_UNISTD_H
  53 #include <unistd.h>
  54 #endif
  55 #endif /* UKERNEL */
  56 #include <afs/afsutil.h>
  57 #include "cellconfig.h"
  58 #include "keys.h"
  59
  60 static ParseHostLine();
  61 static ParseCellLine();
  62 static afsconf_OpenInternal();
  63 static afsconf_CloseInternal();
  64 static afsconf_Reopen();
  65
  66 static struct afsconf_servPair serviceTable [] = {
  67     { "afs",       7000, },
  68     { "afscb",     7001, },
  69     { "afsprot",   7002, },
  70     { "afsvldb",   7003, },
  71     { "afskauth",  7004, },
  72     { "afsvol",    7005, },
  73     { "afserror",  7006, },
  74     { "afsnanny",  7007, },
  75     { "afsupdate", 7008, },
  76     { "afsrmtsys", 7009, },
  77     { "afsres",    7010, },  /* residency database for MR-AFS */
  78     { "afsremio",  7011, },  /* remote I/O interface for MR-AFS */
  79     { 0, 0 }                 /* insert new services before this spot */
  80 };
  81
  82 /*
  83  * Basic Rule: we touch "<AFSCONF_DIR>/CellServDB" every time we change anything, so
  84  * our code can tell if there is new info in the key files, the cell server db
  85  * files or any of the other files (and reopen the thing) if the date on
  86  * CellServDB changes.
  87  */
  88
  89 /* return port number in network byte order in the low 16 bits of a long; return -1 if not found */
  90 static afs_int32 afsconf_FindService(aname)
  91 register char *aname; {
  92     /* lookup a service name */
  93     struct servent *ts;
  94     register struct afsconf_servPair *tsp;
  95
  96 #if     defined(AFS_OSF_ENV) || defined(AFS_DEC_ENV)
  97     ts = getservbyname(aname, "");
  98 #else
  99     ts = getservbyname(aname, (char *) 0);
 100 #endif
 101     if (ts) {
 102         /* we found it in /etc/services, so we use this value */
 103         return ts->s_port;  /* already in network byte order */
 104     }
 105
 106     /* not found in /etc/services, see if it is one of ours */
 107     for(tsp = serviceTable;; tsp++) {
 108         if (tsp->name == (char *) 0) return -1;
 109         if (!strcmp(tsp->name, aname)) return htons(tsp->port);
 110     }
 111 }
 112
 113 static int TrimLine(abuffer)
 114 char *abuffer; {
 115     char tbuffer[256];
 116     register char *tp;
 117     register int tc;
 118
 119     tp = abuffer;
 120     while ((tc = *tp)) {
 121         if (!isspace(tc)) break;
 122         tp++;
 123     }
 124     strcpy(tbuffer, tp);
 125     strcpy(abuffer, tbuffer);
 126     return 0;
 127 }
 128
 129 #ifdef AFS_NT40_ENV
 130 /*
 131  * IsClientConfigDirectory() -- determine if path matches well-known
 132  *     client configuration directory.
 133  */
 134 static int IsClientConfigDirectory(const char *path)
 135 {
 136     const char *cdir = AFSDIR_CLIENT_ETC_DIRPATH;
 137     int i;
 138
 139     for (i = 0; cdir[i] != '\0' && path[i] != '\0'; i++) {
 140         int cc = tolower(cdir[i]);
 141         int pc = tolower(path[i]);
 142
 143         if (cc == '\\') {
 144             cc = '/';
 145         }
 146         if (pc == '\\') {
 147             pc = '/';
 148         }
 149         if (cc != pc) {
 150             return 0;
 151         }
 152     }
 153
 154     /* hit end of one or both; allow mismatch in existence of trailing slash */
 155     if (cdir[i] != '\0') {
 156         if ((cdir[i] != '\\' && cdir[i] != '/') || (cdir[i + 1] != '\0')) {
 157             return 0;
 158         }
 159     }
 160     if (path[i] != '\0') {
 161         if ((path[i] != '\\' && path[i] != '/') || (path[i + 1] != '\0')) {
 162             return 0;
 163         }
 164     }
 165     return 1;
 166 }
 167 #endif /* AFS_NT40_ENV */
 168
 169
 170 static int afsconf_Check(adir)
 171 register struct afsconf_dir *adir; {
 172     char tbuffer[256];
 173     struct stat tstat;
 174     register afs_int32 code;
 175
 176 #ifdef AFS_NT40_ENV
 177     /* NT client CellServDB has different file name than NT server or Unix */
 178     if (IsClientConfigDirectory(adir->name)) {
 179         strcompose(tbuffer, 256,
 180                    adir->name, "/", AFSDIR_CELLSERVDB_FILE_NTCLIENT, NULL);
 181     } else {
 182         strcompose(tbuffer, 256,
 183                    adir->name, "/", AFSDIR_CELLSERVDB_FILE, NULL);
 184     }
 185 #else
 186     strcompose(tbuffer, 256, adir->name, "/", AFSDIR_CELLSERVDB_FILE, NULL);
 187 #endif /* AFS_NT40_ENV */
 188
 189     code = stat(tbuffer, &tstat);
 190     if (code < 0) {
 191         return code;
 192     }
 193     /* did file change? */
 194     if (tstat.st_mtime == adir->timeRead) {
 195         return 0;
 196     }
 197     /* otherwise file has changed, so reopen it */
 198     return afsconf_Reopen(adir);
 199 }
 200
 201 /* set modtime on file */
 202 static afsconf_Touch(adir)
 203 register struct afsconf_dir *adir; {
 204     char tbuffer[256];
 205 #ifndef AFS_NT40_ENV
 206     struct timeval tvp[2];
 207 #endif
 208
 209     adir->timeRead = 0; /* just in case */
 210
 211 #ifdef AFS_NT40_ENV
 212     /* NT client CellServDB has different file name than NT server or Unix */
 213
 214     if (IsClientConfigDirectory(adir->name)) {
 215         strcompose(tbuffer, 256,
 216                    adir->name, "/", AFSDIR_CELLSERVDB_FILE_NTCLIENT, NULL);
 217     } else {
 218         strcompose(tbuffer, 256,
 219                    adir->name, "/", AFSDIR_CELLSERVDB_FILE, NULL);
 220     }
 221
 222     return _utime(tbuffer, NULL);
 223
 224 #else
 225     strcompose(tbuffer, 256, adir->name, "/", AFSDIR_CELLSERVDB_FILE, NULL);
 226     gettimeofday(&tvp[0], NULL);
 227     tvp[1] = tvp[0];
 228     return utimes(tbuffer, tvp);
 229 #endif  /* AFS_NT40_ENV */
 230 }
 231
 232 struct afsconf_dir *afsconf_Open(adir)
 233 register char *adir; {
 234     register struct afsconf_dir *tdir;
 235     register afs_int32 code;
 236
 237     LOCK_GLOBAL_MUTEX
 238     /* zero structure and fill in name; rest is done by internal routine */
 239     tdir = (struct afsconf_dir *) malloc(sizeof(struct afsconf_dir));
 240     memset(tdir, 0, sizeof(struct afsconf_dir));
 241     tdir->name = (char *) malloc(strlen(adir)+1);
 242     strcpy(tdir->name, adir);
 243
 244     code = afsconf_OpenInternal(tdir, 0, 0);
 245     if (code) {
 246         char *afsconf_path, *getenv(), afs_confdir[128];
 247
 248         free(tdir->name);
 249         /* Check global place only when local Open failed for whatever reason */
 250         if (!(afsconf_path = getenv("AFSCONF"))) {
 251             /* 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... */
 252             char *home_dir;
 253             FILE *fp;
 254             size_t len;
 255
 256             if (!(home_dir = getenv("HOME"))) {
 257                 /* Our last chance is the "/.AFSCONF" file */
 258                 fp = fopen("/.AFSCONF", "r");
 259                 if (fp == 0) {
 260                     free(tdir);
 261                     UNLOCK_GLOBAL_MUTEX
 262                     return (struct afsconf_dir *) 0;
 263                 }
 264                 fgets(afs_confdir, 128, fp);
 265                 fclose(fp);
 266             } else {
 267                 char pathname[256];
 268
 269                 sprintf(pathname, "%s/%s", home_dir, ".AFSCONF");
 270                 fp = fopen(pathname, "r");
 271                 if (fp == 0) {
 272                     /* Our last chance is the "/.AFSCONF" file */
 273                     fp = fopen("/.AFSCONF", "r");
 274                     if (fp == 0) {
 275                         free(tdir);
 276                         UNLOCK_GLOBAL_MUTEX
 277                         return (struct afsconf_dir *) 0;
 278                     }
 279                     fgets(afs_confdir, 128, fp);
 280                     fclose(fp);
 281                 }
 282                 fgets(afs_confdir, 128, fp);
 283                 fclose(fp);
 284             }
 285             len = strlen(afs_confdir);
 286             if (len == 0) {
 287                 free(tdir);
 288                 UNLOCK_GLOBAL_MUTEX
 289                 return (struct afsconf_dir *) 0;
 290             }
 291             if (afs_confdir[len-1] == '\n') {
 292                 afs_confdir[len-1] = 0;
 293             }
 294             afsconf_path = afs_confdir;
 295         }
 296         tdir->name = (char *) malloc(strlen(afsconf_path)+1);
 297         strcpy(tdir->name, afsconf_path);
 298         code = afsconf_OpenInternal(tdir, 0, 0);
 299         if (code) {
 300             free(tdir->name);
 301             free(tdir);
 302             UNLOCK_GLOBAL_MUTEX
 303             return (struct afsconf_dir *) 0;
 304         }
 305     }
 306     UNLOCK_GLOBAL_MUTEX
 307     return tdir;
 308 }
 309
 310
 311 static int GetCellUnix(struct afsconf_dir *adir)
 312 {
 313     int rc;
 314     char tbuffer[256];
 315     FILE *tf;
 316
 317     strcompose(tbuffer, 256, adir->name, "/", AFSDIR_THISCELL_FILE, NULL);
 318     tf = fopen(tbuffer, "r");
 319     if (tf) {
 320         rc = fscanf(tf, "%s", tbuffer);
 321         if (rc == 1) {
 322             adir->cellName = (char *) malloc(strlen(tbuffer)+1);
 323             strcpy(adir->cellName, tbuffer);
 324         }
 325         fclose(tf);
 326     }
 327     else {
 328         return -1;
 329     }
 330     return 0;
 331 }
 332
 333
 334 #ifdef AFS_NT40_ENV
 335 static int GetCellNT(struct afsconf_dir *adir)
 336 {
 337     if (IsClientConfigDirectory(adir->name)) {
 338         /* NT client config dir; ThisCell is in registry (no file). */
 339         return afssw_GetClientCellName(&adir->cellName);
 340     } else {
 341         /* NT server config dir; works just like Unix */
 342         return GetCellUnix(adir);
 343     }
 344 }
 345 #endif /* AFS_NT40_ENV */
 346
 347
 348 static int afsconf_OpenInternal(adir, cell, clones)
 349 register struct afsconf_dir *adir;
 350 char *cell;
 351 char clones[];
 352 {
 353     FILE *tf;
 354     register char *tp, *bp;
 355     register struct afsconf_entry *curEntry;
 356     register afs_int32 code;
 357     afs_int32 i;
 358     char tbuffer[256], tbuf1[256];
 359     struct stat tstat;
 360
 361     /* figure out the cell name */
 362 #ifdef AFS_NT40_ENV
 363     i = GetCellNT(adir);
 364 #else
 365     i = GetCellUnix(adir);
 366 #endif
 367     if (i) {
 368         return i;
 369     }
 370
 371     /* now parse the individual lines */
 372     curEntry = 0;
 373
 374 #ifdef AFS_NT40_ENV
 375     /* NT client/server have a CellServDB that is the same format as Unix.
 376      * However, the NT client uses a different file name
 377      */
 378     if (IsClientConfigDirectory(adir->name)) {
 379         /* NT client config dir */
 380         strcompose(tbuffer, 256,
 381                    adir->name, "/", AFSDIR_CELLSERVDB_FILE_NTCLIENT, NULL);
 382     } else {
 383         /* NT server config dir */
 384         strcompose(tbuffer, 256,
 385                    adir->name, "/", AFSDIR_CELLSERVDB_FILE, NULL);
 386     }
 387 #else
 388     strcompose(tbuffer, 256, adir->name, "/", AFSDIR_CELLSERVDB_FILE, NULL);
 389 #endif  /* AFS_NT40_ENV */
 390
 391     if (!stat(tbuffer, &tstat)) {
 392         adir->timeRead = tstat.st_mtime;
 393     } else {
 394         adir->timeRead = 0;
 395     }
 396
 397     strcpy(tbuf1, tbuffer);
 398     tf = fopen(tbuffer, "r");
 399     if (!tf) {
 400         return -1;
 401     }
 402     while (1) {
 403         tp = fgets(tbuffer, sizeof(tbuffer), tf);
 404         if (!tp) break;
 405         TrimLine(tbuffer);  /* remove white space */
 406         if (tbuffer[0] == 0 || tbuffer[0] == '\n') continue;   /* empty line */
 407         if (tbuffer[0] == '>') {
 408             char linkedcell[MAXCELLCHARS];
 409             /* start new cell item */
 410             if (curEntry) {
 411                 /* thread this guy on the list */
 412                 curEntry->next = adir->entries;
 413                 adir->entries = curEntry;
 414                 curEntry = 0;
 415             }
 416             curEntry = (struct afsconf_entry *) malloc(sizeof(struct afsconf_entry));
 417             memset(curEntry, 0, sizeof(struct afsconf_entry));
 418             code = ParseCellLine(tbuffer, curEntry->cellInfo.name, linkedcell);
 419             if (code) {
 420                 afsconf_CloseInternal(adir);
 421                 fclose(tf);
 422                 return -1;
 423             }
 424             if (linkedcell[0] != '\0') {
 425                 curEntry->cellInfo.linkedCell =
 426                     (char *) malloc(strlen(linkedcell) + 1);
 427                 strcpy(curEntry->cellInfo.linkedCell, linkedcell);
 428             }
 429         }
 430         else {
 431             /* new host in the current cell */
 432             if (!curEntry) {
 433                 afsconf_CloseInternal(adir);
 434                 fclose(tf);
 435                 return -1;
 436             }
 437             i = curEntry->cellInfo.numServers;
 438            if (cell && !strcmp(cell, curEntry->cellInfo.name))
 439                 code = ParseHostLine(tbuffer, (char *) &curEntry->cellInfo.hostAddr[i], curEntry->cellInfo.hostName[i], &clones[i]);
 440            else
 441                 code = ParseHostLine(tbuffer, (char *) &curEntry->cellInfo.hostAddr[i], curEntry->cellInfo.hostName[i], 0);
 442             if (code) {
 443                 if (code == AFSCONF_SYNTAX) {
 444                     for (bp=tbuffer; *bp != '\n'; bp++) {       /* Take out the <cr> from the buffer */
 445                         if (!*bp) break;
 446                     }
 447                     *bp= '\0';
 448                     fprintf(stderr, "Can't properly parse host line \"%s\" in configuration file %s\n", tbuffer, tbuf1);
 449                 }
 450                 free(curEntry);
 451                 fclose(tf);
 452                 afsconf_CloseInternal(adir);
 453                 return -1;
 454             }
 455             curEntry->cellInfo.numServers = ++i;
 456         }
 457     }
 458     fclose(tf); /* close the file now */
 459
 460     /* end the last partially-completed cell */
 461     if (curEntry) {
 462         curEntry->next = adir->entries;
 463         adir->entries = curEntry;
 464     }
 465
 466     /* now read the fs keys, if possible */
 467     adir->keystr = (struct afsconf_keys *) 0;
 468     afsconf_IntGetKeys(adir);
 469
 470     return 0;
 471 }
 472
 473 /* parse a line of the form
 474  *"128.2.1.3   #hostname" or
 475  *"[128.2.1.3]  #hostname" for clones
 476  * into the appropriate pieces.
 477  */
 478 static ParseHostLine(aline, addr, aname, aclone)
 479     char *aclone;
 480     register struct sockaddr_in *addr;
 481     char *aline, *aname;
 482 {
 483     int c1, c2, c3, c4;
 484     register afs_int32 code;
 485     register char *tp;
 486
 487     if (*aline == '[') {
 488         if (aclone) *aclone = 1;
 489         code = sscanf(aline, "[%d.%d.%d.%d] #%s", &c1, &c2, &c3, &c4, aname);
 490     } else {
 491         if (aclone) *aclone = 0;
 492         code = sscanf(aline, "%d.%d.%d.%d #%s", &c1, &c2, &c3, &c4, aname);
 493     }
 494     if (code != 5) return AFSCONF_SYNTAX;
 495     addr->sin_family = AF_INET;
 496     addr->sin_port = 0;
 497     tp = (char *) &addr->sin_addr;
 498     *tp++ = c1;
 499     *tp++ = c2;
 500     *tp++ = c3;
 501     *tp++ = c4;
 502     return 0;
 503 }
 504
 505 /* parse a line of the form
 506  * ">cellname [linkedcellname] [#comments]"
 507  * into the appropriate pieces.
 508  */
 509 static ParseCellLine(aline, aname, alname)
 510 register char *aline, *aname, *alname; {
 511     register int code;
 512     code = sscanf(aline, ">%s %s", aname, alname);
 513     if (code == 1) *alname = '\0';
 514     if (code == 2) {
 515         if (*alname == '#') {
 516             *alname = '\0';
 517         }
 518     }
 519     return (code > 0 ? 0 : AFSCONF_SYNTAX);
 520 }
 521
 522 /* call aproc(entry, arock, adir) for all cells.  Proc must return 0, or we'll stop early and return the code it returns */
 523 afsconf_CellApply(adir, aproc, arock)
 524 struct afsconf_dir *adir;
 525 int (*aproc)();
 526 char *arock; {
 527     register struct afsconf_entry *tde;
 528     register afs_int32 code;
 529     LOCK_GLOBAL_MUTEX
 530     for(tde=adir->entries; tde; tde=tde->next) {
 531         code = (*aproc)(&tde->cellInfo, arock, adir);
 532         if (code) {
 533             UNLOCK_GLOBAL_MUTEX
 534             return code;
 535         }
 536     }
 537     UNLOCK_GLOBAL_MUTEX
 538     return 0;
 539 }
 540
 541 afs_int32 afsconf_SawCell = 0;
 542
 543 afsconf_GetExtendedCellInfo(adir, acellName, aservice, acellInfo, clones)
 544     struct afsconf_dir *adir;
 545     char *aservice;
 546     char *acellName;
 547     struct afsconf_cell *acellInfo;
 548     char clones[];
 549 {
 550     afs_int32 code;
 551     char *cell;
 552
 553     code = afsconf_GetCellInfo(adir, acellName, aservice, acellInfo);
 554     if (code)
 555        return code;
 556
 557     if (acellName)
 558        cell = acellName;
 559     else
 560        cell = (char *) &acellInfo->name;
 561
 562     code = afsconf_OpenInternal(adir, cell, clones);
 563     return code;
 564 }
 565
 566 #ifdef AFS_AFSDB_ENV
 567 afsconf_GetAfsdbInfo(acellName, aservice, acellInfo)
 568     char *acellName;
 569     char *aservice;
 570     struct afsconf_cell *acellInfo;
 571 {
 572     afs_int32 code;
 573     int tservice, i;
 574     size_t len;
 575     unsigned char answer[1024];
 576     unsigned char *p;
 577     char host[256];
 578     int server_num = 0;
 579     int minttl = 0;
 580
 581     /* The resolver isn't always MT-safe.. Perhaps this ought to be
 582      * replaced with a more fine-grained lock just for the resolver
 583      * operations.
 584      */
 585     LOCK_GLOBAL_MUTEX
 586     len = res_search(acellName, C_IN, T_AFSDB, answer, sizeof(answer));
 587     UNLOCK_GLOBAL_MUTEX
 588
 589     if (len < 0)
 590         return AFSCONF_NOTFOUND;
 591
 592     p = answer + sizeof(HEADER);        /* Skip header */
 593     code = dn_expand(answer, answer + len, p, host, sizeof(host));
 594     if (code < 0)
 595         return AFSCONF_NOTFOUND;
 596     strncpy(acellInfo->name, host, sizeof(acellInfo->name));
 597
 598     p += code + QFIXEDSZ;       /* Skip name */
 599
 600     while (p < answer + len) {
 601         int type, ttl, size;
 602
 603         code = dn_expand(answer, answer + len, p, host, sizeof(host));
 604         if (code < 0)
 605             return AFSCONF_NOTFOUND;
 606
 607         p += code;      /* Skip the name */
 608         type = (p[0] << 8) | p[1];
 609         p += 4;         /* Skip type and class */
 610         ttl = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 611         p += 4;         /* Skip the TTL */
 612         size = (p[0] << 8) | p[1];
 613         p += 2;         /* Skip the size */
 614
 615         if (type == T_AFSDB) {
 616             struct hostent *he;
 617             short afsdb_type;
 618
 619             afsdb_type = (p[0] << 8) | p[1];
 620             code = dn_expand(answer, answer+len, p+2, host, sizeof(host));
 621             if (code < 0)
 622                 return AFSCONF_NOTFOUND;
 623
 624             if ((afsdb_type == 1) &&
 625                 (server_num < MAXHOSTSPERCELL) &&
 626                 /* Do we want to get TTL data for the A record as well? */
 627                 (he = gethostbyname(host))) {
 628                 afs_int32 ipaddr;
 629                 memcpy(&ipaddr, he->h_addr, he->h_length);
 630                 acellInfo->hostAddr[server_num].sin_addr.s_addr = ipaddr;
 631                 strncpy(acellInfo->hostName[server_num], host,
 632                         sizeof(acellInfo->hostName[server_num]));
 633                 server_num++;
 634
 635                 if (!minttl || ttl < minttl) minttl = ttl;
 636             }
 637         }
 638
 639         p += size;
 640     }
 641
 642     if (server_num == 0)                /* No AFSDB records */
 643         return AFSCONF_NOTFOUND;
 644     acellInfo->numServers = server_num;
 645
 646     if (aservice) {
 647         tservice = afsconf_FindService(aservice);
 648         if (tservice < 0)
 649             return AFSCONF_NOTFOUND;  /* service not found */
 650         for (i=0; i<acellInfo->numServers; i++) {
 651             acellInfo->hostAddr[i].sin_port = tservice;
 652         }
 653     }
 654
 655     acellInfo->timeout = minttl ? (time(0) + minttl) : 0;
 656
 657     return 0;
 658 }
 659 #endif /* AFS_AFSDB_ENV */
 660
 661 afsconf_GetCellInfo(adir, acellName, aservice, acellInfo)
 662 struct afsconf_dir *adir;
 663 char *aservice;
 664 char *acellName;
 665 struct afsconf_cell *acellInfo; {
 666     register struct afsconf_entry *tce;
 667     struct afsconf_entry *bestce;
 668     register afs_int32 i;
 669     int tservice;
 670     char *tcell;
 671     size_t cnLen;
 672     int ambig;
 673     char tbuffer[64];
 674
 675     LOCK_GLOBAL_MUTEX
 676     if (adir) afsconf_Check(adir);
 677     if (acellName) {
 678         tcell = acellName;
 679         cnLen = strlen(tcell)+1;
 680         lcstring (tcell, tcell, cnLen);
 681         afsconf_SawCell = 1;    /* will ignore the AFSCELL switch on future */
 682                                 /* call to afsconf_GetLocalCell: like klog  */
 683     } else {
 684         i = afsconf_GetLocalCell(adir, tbuffer, sizeof(tbuffer));
 685         if (i) {
 686             UNLOCK_GLOBAL_MUTEX
 687             return i;
 688         }
 689         tcell = tbuffer;
 690     }
 691     cnLen = strlen(tcell);
 692     bestce = (struct afsconf_entry *) 0;
 693     ambig = 0;
 694     if (!adir) {
 695         UNLOCK_GLOBAL_MUTEX
 696         return 0;
 697     }
 698     for(tce=adir->entries;tce;tce=tce->next) {
 699         if (strcasecmp(tce->cellInfo.name, tcell) == 0) {
 700             /* found our cell */
 701             bestce = tce;
 702             ambig = 0;
 703             break;
 704         }
 705         if (strlen(tce->cellInfo.name) < cnLen) continue;   /* clearly wrong */
 706         if (strncasecmp(tce->cellInfo.name, tcell, cnLen) == 0) {
 707             if (bestce) ambig = 1;  /* ambiguous unless we get exact match */
 708             bestce = tce;
 709         }
 710     }
 711     if (!ambig && bestce) {
 712         *acellInfo = bestce->cellInfo;  /* structure assignment */
 713         if (aservice) {
 714             tservice = afsconf_FindService(aservice);
 715             if (tservice < 0) {
 716                 UNLOCK_GLOBAL_MUTEX
 717                 return AFSCONF_NOTFOUND;  /* service not found */
 718             }
 719             for(i=0;i<acellInfo->numServers;i++) {
 720                 acellInfo->hostAddr[i].sin_port = tservice;
 721             }
 722         }
 723         acellInfo->timeout = 0;
 724         UNLOCK_GLOBAL_MUTEX
 725         return 0;
 726     }
 727     else {
 728         UNLOCK_GLOBAL_MUTEX
 729 #ifdef AFS_AFSDB_ENV
 730         return afsconf_GetAfsdbInfo(acellName, aservice, acellInfo);
 731 #else
 732         return AFSCONF_NOTFOUND;
 733 #endif /* AFS_AFSDB_ENV */
 734     }
 735 }
 736
 737 afsconf_GetLocalCell(adir, aname, alen)
 738 register struct afsconf_dir *adir;
 739 char *aname;
 740 afs_int32 alen; {
 741     static int  afsconf_showcell = 0;
 742     char        *afscell_path;
 743     char        *getenv();
 744     afs_int32        code = 0;
 745
 746    LOCK_GLOBAL_MUTEX
 747    /*
 748     * If a cell switch was specified in a command, then it should override the
 749     * AFSCELL variable.  If a cell was specified, then the afsconf_SawCell flag
 750     * is set and the cell name in the adir structure is used.
 751     * Read the AFSCELL var each time: in case it changes (unsetenv AFSCELL).
 752     */
 753    if ( !afsconf_SawCell && (afscell_path= getenv("AFSCELL")) ) {
 754         if ( !afsconf_showcell ) {
 755             fprintf(stderr, "Note: Operation is performed on cell %s\n", afscell_path);
 756             afsconf_showcell = 1;
 757         }
 758         strncpy(aname, afscell_path, alen);
 759     } else {
 760         afsconf_Check(adir);
 761         if (adir->cellName) {
 762             strncpy(aname, adir->cellName, alen);
 763         }
 764         else code = AFSCONF_UNKNOWN;
 765     }
 766
 767     UNLOCK_GLOBAL_MUTEX
 768     return(code);
 769 }
 770
 771 afsconf_Close(adir)
 772 struct afsconf_dir *adir; {
 773     LOCK_GLOBAL_MUTEX
 774     afsconf_CloseInternal(adir);
 775     if (adir->name) free(adir->name);
 776     free(adir);
 777     UNLOCK_GLOBAL_MUTEX
 778     return 0;
 779 }
 780
 781 static int afsconf_CloseInternal(adir)
 782 register struct afsconf_dir *adir; {
 783     register struct afsconf_entry *td, *nd;
 784     register char *tname;
 785
 786     tname = adir->name; /* remember name, since that's all we preserve */
 787
 788     /* free everything we can find */
 789     if (adir->cellName) free(adir->cellName);
 790     for(td=adir->entries;td;td=nd) {
 791         nd = td->next;
 792         if (td->cellInfo.linkedCell)
 793             free(td->cellInfo.linkedCell);
 794         free(td);
 795     }
 796     if (adir->keystr) free(adir->keystr);
 797
 798     /* reinit */
 799     memset(adir, 0, sizeof(struct afsconf_dir));
 800     adir->name = tname;     /* restore it */
 801     return 0;
 802 }
 803
 804 static int afsconf_Reopen(adir)
 805 register struct afsconf_dir *adir; {
 806     register afs_int32 code;
 807     code = afsconf_CloseInternal(adir);
 808     if (code) return code;
 809     code = afsconf_OpenInternal(adir, 0, 0);
 810     return code;
 811 }
 812
 813 /* called during opening of config file */
 814 afsconf_IntGetKeys(adir)
 815 struct afsconf_dir *adir;
 816 {
 817     char tbuffer[256];
 818     register int fd;
 819     struct afsconf_keys *tstr;
 820     register afs_int32 code;
 821
 822 #ifdef AFS_NT40_ENV
 823     /* NT client config dir has no KeyFile; don't risk attempting open
 824      * because there might be a random file of this name if dir is shared.
 825      */
 826     if (IsClientConfigDirectory(adir->name)) {
 827         adir->keystr = ((struct afsconf_keys *)
 828                         malloc(sizeof(struct afsconf_keys)));
 829         adir->keystr->nkeys = 0;
 830         return 0;
 831     }
 832 #endif /* AFS_NT40_ENV */
 833
 834     LOCK_GLOBAL_MUTEX
 835     /* compute the key name and other setup */
 836
 837     strcompose(tbuffer, 256, adir->name, "/", AFSDIR_KEY_FILE, NULL);
 838     tstr = (struct afsconf_keys *) malloc(sizeof (struct afsconf_keys));
 839     adir->keystr = tstr;
 840
 841     /* read key file */
 842     fd = open(tbuffer, O_RDONLY);
 843     if (fd < 0) {
 844         tstr->nkeys = 0;
 845         UNLOCK_GLOBAL_MUTEX
 846         return 0;
 847     }
 848     code = read(fd, tstr, sizeof(struct afsconf_keys));
 849     close(fd);
 850     if (code < sizeof(afs_int32)) {
 851         tstr->nkeys = 0;
 852         UNLOCK_GLOBAL_MUTEX
 853         return 0;
 854     }
 855
 856     /* convert key structure to host order */
 857     tstr->nkeys = ntohl(tstr->nkeys);
 858     for(fd=0;fd<tstr->nkeys;fd++)
 859         tstr->key[fd].kvno = ntohl(tstr->key[fd].kvno);
 860
 861     UNLOCK_GLOBAL_MUTEX
 862     return 0;
 863 }
 864
 865 /* get keys structure */
 866 afsconf_GetKeys(adir, astr)
 867 struct afsconf_dir *adir;
 868 struct afsconf_keys *astr;
 869 {
 870     register afs_int32 code;
 871
 872     LOCK_GLOBAL_MUTEX
 873     code = afsconf_Check(adir);
 874     if (code)
 875         return AFSCONF_FAILURE;
 876     memcpy(astr, adir->keystr, sizeof(struct afsconf_keys));
 877     UNLOCK_GLOBAL_MUTEX
 878     return 0;
 879 }
 880
 881 /* get latest key */
 882 afs_int32 afsconf_GetLatestKey(adir, avno, akey)
 883   IN struct afsconf_dir *adir;
 884   OUT afs_int32 *avno;
 885   OUT char *akey;
 886 {
 887     register int i;
 888     int maxa;
 889     register struct afsconf_key *tk;
 890     register afs_int32 best;
 891     struct afsconf_key *bestk;
 892     register afs_int32 code;
 893
 894     LOCK_GLOBAL_MUTEX
 895     code = afsconf_Check(adir);
 896     if (code)
 897         return AFSCONF_FAILURE;
 898     maxa = adir->keystr->nkeys;
 899
 900     best = -1;      /* highest kvno we've seen yet */
 901     bestk = (struct afsconf_key *) 0;   /* ptr to structure providing best */
 902     for(tk = adir->keystr->key,i=0;i<maxa;i++,tk++) {
 903         if (tk->kvno == 999) continue;  /* skip bcrypt keys */
 904         if (tk->kvno > best) {
 905             best = tk->kvno;
 906             bestk = tk;
 907         }
 908     }
 909     if (bestk) {    /* found any  */
 910         if (akey) memcpy(akey, bestk->key, 8); /* copy out latest key */
 911         if (avno) *avno = bestk->kvno;  /* and kvno to caller */
 912         UNLOCK_GLOBAL_MUTEX
 913         return 0;
 914     }
 915     UNLOCK_GLOBAL_MUTEX
 916     return AFSCONF_NOTFOUND;    /* didn't find any keys */
 917 }
 918
 919 /* get a particular key */
 920 afsconf_GetKey(adir, avno, akey)
 921 struct afsconf_dir *adir;
 922 afs_int32 avno;
 923 char *akey;
 924 {
 925     register int i, maxa;
 926     register struct afsconf_key *tk;
 927     register afs_int32 code;
 928
 929     LOCK_GLOBAL_MUTEX
 930     code = afsconf_Check(adir);
 931     if (code)
 932         return AFSCONF_FAILURE;
 933     maxa = adir->keystr->nkeys;
 934
 935     for(tk = adir->keystr->key,i=0;i<maxa;i++,tk++) {
 936         if (tk->kvno == avno) {
 937             memcpy(akey, tk->key, 8);
 938             UNLOCK_GLOBAL_MUTEX
 939             return 0;
 940         }
 941     }
 942
 943     UNLOCK_GLOBAL_MUTEX
 944     return AFSCONF_NOTFOUND;
 945 }
 946
 947 /* save the key structure in the appropriate file */
 948 static SaveKeys(adir)
 949 struct afsconf_dir *adir;
 950 {
 951     struct afsconf_keys tkeys;
 952     register int fd;
 953     register afs_int32 i;
 954     char tbuffer[256];
 955
 956     memcpy(&tkeys, adir->keystr, sizeof(struct afsconf_keys));
 957
 958     /* convert it to net byte order */
 959     for(i = 0; i<tkeys.nkeys; i++ )
 960         tkeys.key[i].kvno = htonl(tkeys.key[i].kvno);
 961     tkeys.nkeys = htonl(tkeys.nkeys);
 962
 963     /* rewrite keys file */
 964     strcompose(tbuffer, 256, adir->name, "/", AFSDIR_KEY_FILE, NULL);
 965     fd = open(tbuffer, O_RDWR | O_CREAT | O_TRUNC, 0600);
 966     if (fd < 0) return AFSCONF_FAILURE;
 967     i = write(fd, &tkeys, sizeof(tkeys));
 968     if (i != sizeof(tkeys)) {
 969         close(fd);
 970         return AFSCONF_FAILURE;
 971     }
 972     if (close(fd) < 0) return AFSCONF_FAILURE;
 973     return 0;
 974 }
 975
 976 afsconf_AddKey(adir, akvno, akey, overwrite)
 977 struct afsconf_dir *adir;
 978 afs_int32 akvno, overwrite;
 979 char akey[8];
 980 {
 981     register struct afsconf_keys *tk;
 982     register struct afsconf_key *tkey;
 983     register afs_int32 i;
 984     int foundSlot;
 985
 986     LOCK_GLOBAL_MUTEX
 987     tk = adir->keystr;
 988
 989     if (akvno != 999) {
 990         if (akvno < 0 || akvno > 255) {
 991             UNLOCK_GLOBAL_MUTEX
 992             return ERANGE;
 993         }
 994     }
 995     foundSlot = 0;
 996     for(i=0, tkey = tk->key; i<tk->nkeys; i++, tkey++) {
 997         if (tkey->kvno == akvno) {
 998             if (!overwrite) {
 999                 UNLOCK_GLOBAL_MUTEX
1000                 return AFSCONF_KEYINUSE;
1001             }
1002             foundSlot = 1;
1003             break;
1004         }
1005     }
1006     if (!foundSlot) {
1007         if (tk->nkeys >= AFSCONF_MAXKEYS) {
1008             UNLOCK_GLOBAL_MUTEX
1009             return AFSCONF_FULL;
1010         }
1011         tkey = &tk->key[tk->nkeys++];
1012     }
1013     tkey->kvno = akvno;
1014     memcpy(tkey->key, akey, 8);
1015     i = SaveKeys(adir);
1016     afsconf_Touch(adir);
1017     UNLOCK_GLOBAL_MUTEX
1018     return i;
1019 }
1020
1021 /* this proc works by sliding the other guys down, rather than using a funny
1022     kvno value, so that callers can count on getting a good key in key[0].
1023 */
1024 afsconf_DeleteKey(adir, akvno)
1025 struct afsconf_dir *adir;
1026 afs_int32 akvno;
1027 {
1028     register struct afsconf_keys *tk;
1029     register struct afsconf_key *tkey;
1030     register int i;
1031     int foundFlag = 0;
1032
1033     LOCK_GLOBAL_MUTEX
1034     tk = adir->keystr;
1035
1036     for(i=0, tkey = tk->key; i<tk->nkeys; i++, tkey++) {
1037         if (tkey->kvno == akvno) {
1038             foundFlag = 1;
1039             break;
1040         }
1041     }
1042     if (!foundFlag) {
1043         UNLOCK_GLOBAL_MUTEX
1044         return AFSCONF_NOTFOUND;
1045     }
1046
1047     /* otherwise slide the others down.  i and tkey point at the guy to delete */
1048     for(;i<tk->nkeys-1; i++,tkey++) {
1049         tkey->kvno = (tkey+1)->kvno;
1050         memcpy(tkey->key, (tkey+1)->key, 8);
1051     }
1052     tk->nkeys--;
1053     i = SaveKeys(adir);
1054     afsconf_Touch(adir);
1055     UNLOCK_GLOBAL_MUTEX
1056     return i;
1057 }