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