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