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