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