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