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