Add the CellServDB pathname to the afsconf_dir
[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     struct stat tstat;
353     int code;
354     time_t now = time(0);
355
356     if (adir->timeRead && (adir->timeCheck == now)) {
357         return 1; /* stat no more than once a second */
358     }
359     adir->timeCheck = now;
360
361     if (adir->cellservDB == NULL)
362         return 0;
363
364     code = stat(adir->cellservDB, &tstat);
365     if (code < 0)
366         return 0; /* Can't throw the error, so just say we're not up to date */
367
368     /* did file change? */
369     if (tstat.st_mtime == adir->timeRead)
370         return 1;
371
372     /* otherwise file has changed */
373     return 0;
374 }
375
376 int
377 afsconf_UpToDate(void *rock)
378 {
379     int code;
380
381     LOCK_GLOBAL_MUTEX;
382     code = _afsconf_UpToDate(rock);
383     UNLOCK_GLOBAL_MUTEX;
384
385     return code;
386 }
387
388 int
389 _afsconf_Check(struct afsconf_dir *adir)
390 {
391     /* did configuration change? */
392     if (_afsconf_UpToDate(adir))
393         return 0;
394
395     /* otherwise file has changed, so reopen it */
396     return afsconf_Reopen(adir);
397 }
398
399 /* set modtime on file */
400 int
401 _afsconf_Touch(struct afsconf_dir *adir)
402 {
403     int code;
404 #ifndef AFS_NT40_ENV
405     struct timeval tvp[2];
406 #endif
407
408     adir->timeRead = 0;         /* just in case */
409     adir->timeCheck = 0;
410
411     if (adir->cellservDB == NULL)
412         return ENOMEM;
413
414 #ifdef AFS_NT40_ENV
415     code = _utime(adir->cellservDB, NULL);
416 #else
417     gettimeofday(&tvp[0], NULL);
418     tvp[1] = tvp[0];
419     code = utimes(adir->cellservDB, tvp);
420 #endif /* AFS_NT40_ENV */
421
422     return code;
423 }
424
425 struct afsconf_dir *
426 afsconf_Open(const char *adir)
427 {
428     struct afsconf_dir *tdir;
429     afs_int32 code;
430
431     LOCK_GLOBAL_MUTEX;
432     /* zero structure and fill in name; rest is done by internal routine */
433     tdir = calloc(1, sizeof(struct afsconf_dir));
434     tdir->name = strdup(adir);
435
436     code = afsconf_OpenInternal(tdir, 0, 0);
437     if (code) {
438         char *afsconf_path, afs_confdir[128];
439
440         free(tdir->name);
441         /* Check global place only when local Open failed for whatever reason */
442         if (!(afsconf_path = getenv("AFSCONF"))) {
443             /* 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... */
444             char *home_dir;
445             afsconf_FILE *fp;
446             size_t len = 0;
447             int r;
448
449             if (!(home_dir = getenv("HOME"))) {
450                 /* Our last chance is the "/.AFSCONF" file */
451                 fp = fopen("/.AFSCONF", "r");
452                 if (fp == 0)
453                     goto fail;
454
455             } else {
456                 char *pathname = NULL;
457
458                 r = asprintf(&pathname, "%s/%s", home_dir, ".AFSCONF");
459                 if (r < 0 || pathname == NULL)
460                     goto fail;
461
462                 fp = fopen(pathname, "r");
463                 free(pathname);
464
465                 if (fp == 0) {
466                     /* Our last chance is the "/.AFSCONF" file */
467                     fp = fopen("/.AFSCONF", "r");
468                     if (fp == 0)
469                         goto fail;
470                 }
471             }
472             if (fgets(afs_confdir, 128, fp) != NULL)
473                 len = strlen(afs_confdir);
474             fclose(fp);
475             if (len == 0)
476                 goto fail;
477
478             if (afs_confdir[len - 1] == '\n') {
479                 afs_confdir[len - 1] = 0;
480             }
481             afsconf_path = afs_confdir;
482         }
483         tdir->name = strdup(afsconf_path);
484         code = afsconf_OpenInternal(tdir, 0, 0);
485         if (code) {
486             free(tdir->name);
487             goto fail;
488         }
489     }
490     UNLOCK_GLOBAL_MUTEX;
491     return tdir;
492
493 fail:
494     free(tdir);
495     UNLOCK_GLOBAL_MUTEX;
496     return NULL;
497 }
498
499 static int
500 GetCellUnix(struct afsconf_dir *adir)
501 {
502     char *rc;
503     char tbuffer[256];
504     char *start, *p;
505     afsconf_FILE *fp;
506
507     strcompose(tbuffer, 256, adir->name, "/", AFSDIR_THISCELL_FILE,
508         (char *)NULL);
509     fp = fopen(tbuffer, "r");
510     if (fp == 0) {
511         return -1;
512     }
513     rc = fgets(tbuffer, 256, fp);
514     fclose(fp);
515     if (rc == NULL)
516         return -1;
517
518     start = tbuffer;
519     while (*start != '\0' && isspace(*start))
520         start++;
521     p = start;
522     while (*p != '\0' && !isspace(*p))
523         p++;
524     *p = '\0';
525     if (*start == '\0')
526         return -1;
527
528     adir->cellName = strdup(start);
529     return 0;
530 }
531
532
533 #ifdef AFS_NT40_ENV
534 static int
535 GetCellNT(struct afsconf_dir *adir)
536 {
537     if (_afsconf_IsClientConfigDirectory(adir->name)) {
538         /* NT client config dir; ThisCell is in registry (no file). */
539         return afssw_GetClientCellName(&adir->cellName);
540     } else {
541         /* NT server config dir; works just like Unix */
542         return GetCellUnix(adir);
543     }
544 }
545
546 /* The following procedures and structs are used on Windows only
547  * to enumerate the Cell information distributed within the
548  * Windows registry.  (See src/WINNT/afsd/cm_config.c)
549  */
550 typedef struct _cm_enumCellRegistry {
551     afs_uint32 client;  /* non-zero if client query */
552     struct afsconf_dir *adir;
553 } cm_enumCellRegistry_t;
554
555 static long
556 cm_serverConfigProc(void *rockp, struct sockaddr_in *addrp,
557                     char *hostNamep, unsigned short rank)
558 {
559     struct afsconf_cell *cellInfop = (struct afsconf_cell *)rockp;
560
561     if (cellInfop->numServers == MAXHOSTSPERCELL)
562         return 0;
563
564     cellInfop->hostAddr[cellInfop->numServers] = *addrp;
565     strncpy(cellInfop->hostName[cellInfop->numServers], hostNamep, MAXHOSTCHARS);
566     cellInfop->hostName[cellInfop->numServers][MAXHOSTCHARS-1] = '\0';
567     cellInfop->numServers++;
568
569     return 0;
570 }
571
572 static long
573 cm_enumCellRegistryProc(void *rockp, char * cellNamep)
574 {
575     long code;
576     cm_enumCellRegistry_t *enump = (cm_enumCellRegistry_t *)rockp;
577     char linkedName[256] = "";
578     int timeout = 0;
579     struct afsconf_entry *newEntry;
580
581
582     newEntry = malloc(sizeof(struct afsconf_entry));
583     if (newEntry == NULL)
584         return ENOMEM;
585     newEntry->cellInfo.numServers = 0;
586
587     code = cm_SearchCellRegistry(enump->client, cellNamep, NULL, linkedName, cm_serverConfigProc, &newEntry->cellInfo);
588     if (code == CM_ERROR_FORCE_DNS_LOOKUP)
589         code = cm_SearchCellByDNS(cellNamep, NULL, &timeout, cm_serverConfigProc, &newEntry->cellInfo);
590
591     if (code == 0) {
592         strncpy(newEntry->cellInfo.name, cellNamep, MAXCELLCHARS);
593         newEntry->cellInfo.name[MAXCELLCHARS-1];
594         if (linkedName[0])
595             newEntry->cellInfo.linkedCell = strdup(linkedName);
596         else
597             newEntry->cellInfo.linkedCell = NULL;
598         newEntry->cellInfo.timeout = timeout;
599         newEntry->cellInfo.flags = 0;
600
601         newEntry->next = enump->adir->entries;
602         enump->adir->entries = newEntry;
603     } else {
604         free(newEntry);
605     }
606     return code;
607 }
608 #endif /* AFS_NT40_ENV */
609
610
611 static int
612 afsconf_OpenInternal(struct afsconf_dir *adir, char *cell,
613                      char clones[])
614 {
615     afsconf_FILE *tf;
616     char *tp, *bp;
617     struct afsconf_entry *curEntry;
618     struct afsconf_aliasentry *curAlias;
619     afs_int32 code;
620     afs_int32 i;
621     char tbuffer[256];
622     struct stat tstat;
623
624 #ifdef AFS_NT40_ENV
625     cm_enumCellRegistry_t enumCellRegistry = {0, 0};
626 #endif /* AFS_NT40_ENV */
627
628     /* init the keys queue before any call to afsconf_CloseInternal() */
629     _afsconf_InitKeys(adir);
630
631     /* figure out the local cell name */
632 #ifdef AFS_NT40_ENV
633     i = GetCellNT(adir);
634     enumCellRegistry.adir = adir;
635 #else
636     i = GetCellUnix(adir);
637 #endif
638
639 #ifndef AFS_FREELANCE_CLIENT    /* no local cell not fatal in freelance */
640     if (i) {
641         return i;
642     }
643 #endif
644
645     /* now parse the individual lines */
646     curEntry = 0;
647
648     _afsconf_CellServDBPath(adir, &adir->cellservDB);
649
650 #ifdef AFS_NT40_ENV
651     if (_afsconf_IsClientConfigDirectory(adir->name))
652         enumCellRegistry.client = 1;
653 #endif /* AFS_NT40_ENV */
654
655     if (!stat(adir->cellservDB, &tstat)) {
656         adir->timeRead = tstat.st_mtime;
657     } else {
658         adir->timeRead = 0;
659     }
660
661     tf = fopen(adir->cellservDB, "r");
662     if (!tf) {
663         return -1;
664     }
665
666     /* The CellServDB file is now open.
667      * The following code parses the contents of the
668      * file and creates a list with the first cell entry
669      * in the CellServDB file at the end of the list.
670      *
671      * No checking is performed for duplicates.
672      * The side effects of this process are that duplicate
673      * entries appended to the end of the CellServDB file
674      * take precedence and are found in a shorter period
675      * of time.
676      */
677
678     while (1) {
679         tp = fgets(tbuffer, sizeof(tbuffer), tf);
680         if (!tp)
681             break;
682         TrimLine(tbuffer, sizeof tbuffer);      /* remove white space */
683         if (tbuffer[0] == 0 || tbuffer[0] == '\n')
684             continue;           /* empty line */
685         if (tbuffer[0] == '>') {
686             char linkedcell[MAXCELLCHARS];
687             /* start new cell item */
688             if (curEntry) {
689                 /* thread this guy on the list */
690                 curEntry->next = adir->entries;
691                 adir->entries = curEntry;
692                 curEntry = 0;
693             }
694             curEntry = calloc(1, sizeof(struct afsconf_entry));
695             code =
696                 ParseCellLine(tbuffer, curEntry->cellInfo.name, linkedcell);
697             if (code) {
698                 afsconf_CloseInternal(adir);
699                 fclose(tf);
700                 free(curEntry);
701                 return -1;
702             }
703             if (linkedcell[0] != '\0')
704                 curEntry->cellInfo.linkedCell = strdup(linkedcell);
705         } else {
706             /* new host in the current cell */
707             if (!curEntry) {
708                 afsconf_CloseInternal(adir);
709                 fclose(tf);
710                 return -1;
711             }
712             i = curEntry->cellInfo.numServers;
713             if (i < MAXHOSTSPERCELL) {
714                 if (cell && !strcmp(cell, curEntry->cellInfo.name))
715                     code =
716                         ParseHostLine(tbuffer,
717                                       &curEntry->cellInfo.hostAddr[i],
718                                       curEntry->cellInfo.hostName[i],
719                                       &clones[i]);
720                 else
721                     code =
722                         ParseHostLine(tbuffer,
723                                       &curEntry->cellInfo.hostAddr[i],
724                                       curEntry->cellInfo.hostName[i], 0);
725
726                 if (code) {
727                     if (code == AFSCONF_SYNTAX) {
728                         for (bp = tbuffer; *bp != '\n'; bp++) { /* Take out the <cr> from the buffer */
729                             if (!*bp)
730                                 break;
731                         }
732                         *bp = '\0';
733                         fprintf(stderr,
734                                 "Can't properly parse host line \"%s\" in configuration file %s\n",
735                                 tbuffer, adir->cellservDB);
736                     }
737                     free(curEntry);
738                     fclose(tf);
739                     afsconf_CloseInternal(adir);
740                     return -1;
741                 }
742                 curEntry->cellInfo.numServers = ++i;
743             } else {
744                 fprintf(stderr,
745                         "Too many hosts for cell %s in configuration file %s\n",
746                         curEntry->cellInfo.name, adir->cellservDB);
747             }
748         }
749     }
750     fclose(tf);                 /* close the file now */
751
752     /* end the last partially-completed cell */
753     if (curEntry) {
754         curEntry->next = adir->entries;
755         adir->entries = curEntry;
756     }
757
758 #ifdef AFS_NT40_ENV
759      /*
760       * Windows maintains a CellServDB list in the Registry
761       * that supercedes the contents of the CellServDB file.
762       * Prepending these entries to the head of the list
763       * is sufficient to enforce the precedence.
764       */
765      cm_EnumerateCellRegistry( enumCellRegistry.client,
766                                cm_enumCellRegistryProc,
767                                &enumCellRegistry);
768 #endif /* AFS_NT40_ENV */
769
770     /* Read in the alias list */
771     strcompose(tbuffer, 256, adir->name, "/", AFSDIR_CELLALIAS_FILE,
772         (char *)NULL);
773
774     tf = fopen(tbuffer, "r");
775     while (tf) {
776         char *aliasPtr;
777
778         tp = fgets(tbuffer, sizeof(tbuffer), tf);
779         if (!tp)
780             break;
781         TrimLine(tbuffer, sizeof tbuffer);      /* remove white space */
782
783         if (tbuffer[0] == '\0' || tbuffer[0] == '\n' || tbuffer[0] == '#')
784             continue;           /* empty line */
785
786         tp = tbuffer;
787         while (tp[0] != '\0' && tp[0] != ' ' && tp[0] != '\t')
788             tp++;
789         if (tp[0] == '\0')
790             continue;           /* invalid line */
791
792         while (tp[0] != '\0' && (tp[0] == ' ' || tp[0] == '\t'))
793             0[tp++] = '\0';
794         if (tp[0] == '\0')
795             continue;           /* invalid line */
796
797         aliasPtr = tp;
798         while (tp[0] != '\0' && tp[0] != ' ' && tp[0] != '\t' && tp[0] != '\r'
799                && tp[0] != '\n')
800             tp++;
801         tp[0] = '\0';
802
803         curAlias = calloc(1, sizeof(*curAlias));
804
805         strlcpy(curAlias->aliasInfo.aliasName, aliasPtr, sizeof curAlias->aliasInfo.aliasName);
806         strlcpy(curAlias->aliasInfo.realName, tbuffer, sizeof curAlias->aliasInfo.realName);
807
808         curAlias->next = adir->alias_entries;
809         adir->alias_entries = curAlias;
810     }
811
812     if (tf != NULL)
813         fclose(tf);
814
815     /* now read the fs keys, if possible */
816     code = _afsconf_LoadKeys(adir);
817     if (code) {
818         return code;
819     }
820     code = _afsconf_LoadRealms(adir);
821
822     return code;
823 }
824
825 /* parse a line of the form
826  *"128.2.1.3   #hostname" or
827  *"[128.2.1.3]  #hostname" for clones
828  * into the appropriate pieces.
829  */
830 static int
831 ParseHostLine(char *aline, struct sockaddr_in *addr, char *aname,
832               char *aclone)
833 {
834     int i;
835     int c[4];
836     afs_int32 code;
837     char *tp;
838
839     if (*aline == '[') {
840         if (aclone)
841             *aclone = 1;
842         /* FIXME: length of aname unknown here */
843         code = sscanf(aline, "[%d.%d.%d.%d] #%s", &c[0], &c[1], &c[2], &c[3],
844                       aname);
845     } else {
846         if (aclone)
847             *aclone = 0;
848         /* FIXME: length of aname unknown here */
849         code = sscanf(aline, "%d.%d.%d.%d #%s", &c[0], &c[1], &c[2], &c[3],
850                       aname);
851     }
852     if (code != 5)
853         return AFSCONF_SYNTAX;
854     for(i = 0; i < 4; ++i) {
855         if (c[i] < 0 || c[i] > 255) {
856             fprintf(stderr, "Illegal IP address %d.%d.%d.%d\n", c[0], c[1],
857                     c[2], c[3]);
858             return AFSCONF_SYNTAX;
859         }
860     }
861     addr->sin_family = AF_INET;
862     addr->sin_port = 0;
863 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
864     addr->sin_len = sizeof(struct sockaddr_in);
865 #endif
866     tp = (char *)&addr->sin_addr;
867     *tp++ = c[0];
868     *tp++ = c[1];
869     *tp++ = c[2];
870     *tp++ = c[3];
871     return 0;
872 }
873
874 /* parse a line of the form
875  * ">cellname [linkedcellname] [#comments]"
876  * into the appropriate pieces.
877  */
878 static int
879 ParseCellLine(char *aline, char *aname,
880               char *alname)
881 {
882     int code;
883     /* FIXME: length of aname, alname unknown here */
884     code = sscanf(aline, ">%s %s", aname, alname);
885     if (code == 1)
886         *alname = '\0';
887     if (code == 2) {
888         if (*alname == '#') {
889             *alname = '\0';
890         }
891     }
892     return (code > 0 ? 0 : AFSCONF_SYNTAX);
893 }
894
895 /* call aproc(entry, arock, adir) for all cells.  Proc must return 0, or we'll stop early and return the code it returns */
896 int
897 afsconf_CellApply(struct afsconf_dir *adir,
898                   int (*aproc) (struct afsconf_cell * cell, void *arock,
899                                 struct afsconf_dir * dir), void *arock)
900 {
901     struct afsconf_entry *tde;
902     afs_int32 code;
903     LOCK_GLOBAL_MUTEX;
904     for (tde = adir->entries; tde; tde = tde->next) {
905         code = (*aproc) (&tde->cellInfo, arock, adir);
906         if (code) {
907             UNLOCK_GLOBAL_MUTEX;
908             return code;
909         }
910     }
911     UNLOCK_GLOBAL_MUTEX;
912     return 0;
913 }
914
915 /* call aproc(entry, arock, adir) for all cell aliases.
916  * Proc must return 0, or we'll stop early and return the code it returns
917  */
918 int
919 afsconf_CellAliasApply(struct afsconf_dir *adir,
920                        int (*aproc) (struct afsconf_cellalias * alias,
921                                      void *arock, struct afsconf_dir * dir),
922                        void *arock)
923 {
924     struct afsconf_aliasentry *tde;
925     afs_int32 code;
926     LOCK_GLOBAL_MUTEX;
927     for (tde = adir->alias_entries; tde; tde = tde->next) {
928         code = (*aproc) (&tde->aliasInfo, arock, adir);
929         if (code) {
930             UNLOCK_GLOBAL_MUTEX;
931             return code;
932         }
933     }
934     UNLOCK_GLOBAL_MUTEX;
935     return 0;
936 }
937
938 afs_int32 afsconf_SawCell = 0;
939
940 int
941 afsconf_GetExtendedCellInfo(struct afsconf_dir *adir, char *acellName,
942                             char *aservice, struct afsconf_cell *acellInfo,
943                             char clones[])
944 {
945     afs_int32 code;
946     char *cell;
947
948     code = afsconf_GetCellInfo(adir, acellName, aservice, acellInfo);
949     if (code)
950         return code;
951
952     if (acellName)
953         cell = acellName;
954     else
955         cell = (char *)&acellInfo->name;
956
957     code = afsconf_OpenInternal(adir, cell, clones);
958     return code;
959 }
960
961 #if !defined(AFS_NT40_ENV)
962 int
963 afsconf_LookupServer(const char *service, const char *protocol,
964                      const char *cellName, unsigned short afsdbPort,
965                      afs_uint32 *cellHostAddrs, char cellHostNames[][MAXHOSTCHARS],
966                      unsigned short ports[], unsigned short ipRanks[],
967                      int *numServers, int *ttl, char **arealCellName)
968 {
969     int code = 0;
970     int r;
971     int len;
972     unsigned char answer[4096];
973     unsigned char *p;
974     char *dotcellname = NULL;
975     char *realCellName;
976     char host[256];
977     int server_num = 0;
978     int minttl = 0;
979     int try_init = 0;
980     int dnstype = 0;
981     int pass = 0;
982     char *IANAname = (char *) afsconf_FindIANAName(service);
983     int tservice = afsconf_FindService(service);
984
985     realCellName = NULL;
986
987     *numServers = 0;
988     *ttl = 0;
989     if (tservice <= 0 || !IANAname)
990         return AFSCONF_NOTFOUND;        /* service not found */
991
992     if (strchr(cellName,'.'))
993         pass += 2;
994
995 #ifdef HAVE_RES_RETRANSRETRY
996     if ((_res.options & RES_INIT) == 0 && res_init() == -1)
997       return (0);
998
999     /*
1000      * Rx timeout is typically 56 seconds; limit user experience to
1001      * similar timeout
1002      */
1003     _res.retrans = 18;
1004     _res.retry = 3;
1005 #endif
1006
1007  retryafsdb:
1008     r = -1;
1009     switch (pass) {
1010     case 0:
1011         dnstype = T_SRV;
1012         r = asprintf(&dotcellname, "_%s._%s.%s.", IANAname, protocol, cellName);
1013         break;
1014     case 1:
1015         dnstype = T_AFSDB;
1016         r = asprintf(&dotcellname, "%s.", cellName);
1017         break;
1018     case 2:
1019         dnstype = T_SRV;
1020         r = asprintf(&dotcellname, "_%s._%s.%s", IANAname, protocol, cellName);
1021         break;
1022     case 3:
1023         dnstype = T_AFSDB;
1024         r = asprintf(&dotcellname, "%s", cellName);
1025         break;
1026     }
1027     if (r < 0 || dotcellname == NULL)
1028         goto findservererror;
1029
1030     LOCK_GLOBAL_MUTEX;
1031     len = res_search(dotcellname, C_IN, dnstype, answer, sizeof(answer));
1032     UNLOCK_GLOBAL_MUTEX;
1033
1034     if (dotcellname != NULL) {
1035         free(dotcellname);
1036         dotcellname = NULL;
1037     }
1038
1039     if (len < 0) {
1040         if (try_init < 1) {
1041             try_init++;
1042             res_init();
1043             goto retryafsdb;
1044         }
1045         if (pass < 3) {
1046             pass++;
1047             goto retryafsdb;
1048         } else {
1049             code = AFSCONF_NOTFOUND;
1050             goto findservererror;
1051         }
1052     }
1053
1054     p = answer + sizeof(HEADER);        /* Skip header */
1055     code = dn_expand(answer, answer + len, p, host, sizeof(host));
1056     if (code < 0) {
1057         code = AFSCONF_NOTFOUND;
1058         goto findservererror;
1059     }
1060
1061     p += code + QFIXEDSZ;       /* Skip name */
1062
1063     while (p < answer + len) {
1064         int type, ttl, size;
1065
1066         code = dn_expand(answer, answer + len, p, host, sizeof(host));
1067         if (code < 0) {
1068             code = AFSCONF_NOTFOUND;
1069             goto findservererror;
1070         }
1071
1072         p += code;              /* Skip the name */
1073         type = (p[0] << 8) | p[1];
1074         p += 4;                 /* Skip type and class */
1075         ttl = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
1076         p += 4;                 /* Skip the TTL */
1077         size = (p[0] << 8) | p[1];
1078         p += 2;                 /* Skip the size */
1079
1080         if (type == T_AFSDB) {
1081             struct hostent *he;
1082             short afsdb_type;
1083
1084             afsdb_type = (p[0] << 8) | p[1];
1085             if (afsdb_type == 1) {
1086                 /*
1087                  * We know this is an AFSDB record for our cell, of the
1088                  * right AFSDB type.  Write down the true cell name that
1089                  * the resolver gave us above.
1090                  */
1091                 if (!realCellName)
1092                     realCellName = strdup(host);
1093             }
1094
1095             code = dn_expand(answer, answer + len, p + 2, host, sizeof(host));
1096             if (code < 0) {
1097                 code = AFSCONF_NOTFOUND;
1098                 goto findservererror;
1099             }
1100
1101             if ((afsdb_type == 1) && (server_num < MAXHOSTSPERCELL) &&
1102                 /* Do we want to get TTL data for the A record as well? */
1103                 (he = gethostbyname(host))) {
1104                 if (he->h_addrtype == AF_INET) {
1105                     afs_uint32 ipaddr;
1106                     memcpy(&ipaddr, he->h_addr, sizeof(ipaddr));
1107                     cellHostAddrs[server_num] = ipaddr;
1108                     ports[server_num] = afsdbPort;
1109                     ipRanks[server_num] = 0;
1110                     strncpy(cellHostNames[server_num], host,
1111                             sizeof(cellHostNames[server_num]));
1112                     server_num++;
1113                     if (!minttl || ttl < minttl)
1114                         minttl = ttl;
1115                 }
1116             }
1117         }
1118         if (type == T_SRV) {
1119             struct hostent *he;
1120             /* math here: _ is 1, _ ._ is 3, _ ._ . is 4. then the domain. */
1121             if ((strncmp(host + 1, IANAname, strlen(IANAname)) == 0) &&
1122                 (strncmp(host + strlen(IANAname) + 3, protocol,
1123                          strlen(protocol)) == 0)) {
1124                 if (!realCellName)
1125                     realCellName = strdup(host + strlen(IANAname) +
1126                                           strlen(protocol) + 4);
1127             }
1128
1129             code = dn_expand(answer, answer + len, p + 6, host, sizeof(host));
1130             if (code < 0) {
1131                 code = AFSCONF_NOTFOUND;
1132                 goto findservererror;
1133             }
1134
1135             if ((server_num < MAXHOSTSPERCELL) &&
1136                 /* Do we want to get TTL data for the A record as well? */
1137                 (he = gethostbyname(host))) {
1138                 if (he->h_addrtype == AF_INET) {
1139                     afs_uint32 ipaddr;
1140
1141                     memcpy(&ipaddr, he->h_addr, sizeof(ipaddr));
1142                     cellHostAddrs[server_num] = ipaddr;
1143                     ipRanks[server_num] = (p[0] << 8) | p[1];
1144                     ports[server_num] = htons((p[4] << 8) | p[5]);
1145                     /* weight = (p[2] << 8) | p[3]; */
1146                     strncpy(cellHostNames[server_num], host,
1147                             sizeof(cellHostNames[server_num]));
1148                     server_num++;
1149
1150                     if (!minttl || ttl < minttl)
1151                         minttl = ttl;
1152                 }
1153             }
1154         }
1155
1156         p += size;
1157     }
1158
1159     if (server_num == 0) {      /* No AFSDB or SRV records */
1160         code = AFSCONF_NOTFOUND;
1161         goto findservererror;
1162     }
1163
1164     if (realCellName) {
1165         /* Convert the real cell name to lowercase */
1166         for (p = (unsigned char *)realCellName; *p; p++)
1167             *p = tolower(*p);
1168     }
1169
1170     *numServers = server_num;
1171     *ttl = minttl ? (time(0) + minttl) : 0;
1172
1173     if ( *numServers > 0 ) {
1174         code =  0;
1175         *arealCellName = realCellName;
1176     } else
1177         code = AFSCONF_NOTFOUND;
1178
1179 findservererror:
1180     if (code && realCellName)
1181         free(realCellName);
1182     return code;
1183 }
1184
1185 int
1186 afsconf_GetAfsdbInfo(char *acellName, char *aservice,
1187                      struct afsconf_cell *acellInfo)
1188 {
1189     afs_uint32 cellHostAddrs[AFSMAXCELLHOSTS];
1190     char cellHostNames[AFSMAXCELLHOSTS][MAXHOSTCHARS];
1191     unsigned short ipRanks[AFSMAXCELLHOSTS];
1192     unsigned short ports[AFSMAXCELLHOSTS];
1193     char *realCellName = NULL;
1194     int ttl, numServers, i;
1195     char *service = aservice;
1196     int code;
1197     unsigned short afsdbport;
1198     if (!service) {
1199         service = "afs3-vlserver";
1200         afsdbport = htons(7003);
1201     } else {
1202         service = aservice;
1203         afsdbport = afsconf_FindService(service);
1204     }
1205     code = afsconf_LookupServer((const char *)service, "udp",
1206                                 (const char *)acellName, afsdbport,
1207                                 cellHostAddrs, cellHostNames,
1208                                 ports, ipRanks, &numServers, &ttl,
1209                                 &realCellName);
1210
1211     /* If we couldn't find an entry for the requested service
1212      * and that service happens to be the prservice or kaservice
1213      * then fallback to searching for afs3-vlserver and assigning
1214      * the port number here. */
1215     if (code < 0 && (afsdbport == htons(7002) || afsdbport == htons(7004))) {
1216         code = afsconf_LookupServer("afs3-vlserver", "udp",
1217                                     (const char *)acellName, afsdbport,
1218                                     cellHostAddrs, cellHostNames,
1219                                     ports, ipRanks, &numServers, &ttl,
1220                                     &realCellName);
1221         if (code >= 0) {
1222             for (i = 0; i < numServers; i++)
1223                 ports[i] = afsdbport;
1224         }
1225     }
1226     if (code == 0) {
1227         acellInfo->timeout = ttl;
1228         acellInfo->numServers = numServers;
1229         for (i = 0; i < numServers; i++) {
1230             memcpy(&acellInfo->hostAddr[i].sin_addr.s_addr, &cellHostAddrs[i],
1231                    sizeof(afs_int32));
1232             memcpy(acellInfo->hostName[i], cellHostNames[i], MAXHOSTCHARS);
1233             acellInfo->hostAddr[i].sin_family = AF_INET;
1234             acellInfo->hostAddr[i].sin_port = ports[i];
1235
1236             if (realCellName) {
1237                 strlcpy(acellInfo->name, realCellName,
1238                         sizeof(acellInfo->name));
1239                 free(realCellName);
1240                 realCellName = NULL;
1241             }
1242         }
1243         acellInfo->linkedCell = NULL;       /* no linked cell */
1244         acellInfo->flags = 0;
1245     }
1246     return code;
1247 }
1248 #else /* windows */
1249 int
1250 afsconf_GetAfsdbInfo(char *acellName, char *aservice,
1251                      struct afsconf_cell *acellInfo)
1252 {
1253     afs_int32 i;
1254     int tservice = afsconf_FindService(aservice);   /* network byte order */
1255     const char *ianaName = afsconf_FindIANAName(aservice);
1256     struct afsconf_entry DNSce;
1257     afs_uint32 cellHostAddrs[AFSMAXCELLHOSTS];
1258     char cellHostNames[AFSMAXCELLHOSTS][MAXHOSTCHARS];
1259     unsigned short ipRanks[AFSMAXCELLHOSTS];
1260     unsigned short ports[AFSMAXCELLHOSTS];          /* network byte order */
1261     int numServers;
1262     int rc;
1263     int ttl;
1264
1265     if (tservice < 0) {
1266         if (aservice)
1267             return AFSCONF_NOTFOUND;
1268         else
1269             tservice = 0;       /* port will be assigned by caller */
1270     }
1271
1272     if (ianaName == NULL)
1273         ianaName = "afs3-vlserver";
1274
1275     DNSce.cellInfo.numServers = 0;
1276     DNSce.next = NULL;
1277
1278     rc = getAFSServer(ianaName, "udp", acellName, tservice,
1279                       cellHostAddrs, cellHostNames, ports, ipRanks, &numServers,
1280                       &ttl);
1281     /* ignore the ttl here since this code is only called by transitory programs
1282      * like klog, etc. */
1283
1284     /* If we couldn't find an entry for the requested service
1285      * and that service happens to be the prservice or kaservice
1286      * then fallback to searching for afs3-vlserver and assigning
1287      * the port number here. */
1288     if (rc < 0 && (tservice == htons(7002) || tservice == htons(7004))) {
1289         rc = getAFSServer("afs3-vlserver", "udp", acellName, tservice,
1290                            cellHostAddrs, cellHostNames, ports, ipRanks, &numServers,
1291                            &ttl);
1292         if (rc >= 0) {
1293             for (i = 0; i < numServers; i++)
1294                 ports[i] = tservice;
1295         }
1296     }
1297
1298     if (rc < 0 || numServers == 0)
1299         return -1;
1300
1301     for (i = 0; i < numServers; i++) {
1302         memcpy(&acellInfo->hostAddr[i].sin_addr.s_addr, &cellHostAddrs[i],
1303                sizeof(afs_uint32));
1304         memcpy(acellInfo->hostName[i], cellHostNames[i], MAXHOSTCHARS);
1305         acellInfo->hostAddr[i].sin_family = AF_INET;
1306         if (aservice)
1307             acellInfo->hostAddr[i].sin_port = ports[i];
1308         else
1309             acellInfo->hostAddr[i].sin_port = 0;
1310     }
1311
1312     acellInfo->numServers = numServers;
1313     strlcpy(acellInfo->name, acellName, sizeof acellInfo->name);
1314     acellInfo->linkedCell = NULL;       /* no linked cell */
1315     acellInfo->flags = 0;
1316     return 0;
1317 }
1318 #endif /* windows */
1319
1320 int
1321 afsconf_GetCellInfo(struct afsconf_dir *adir, char *acellName, char *aservice,
1322                     struct afsconf_cell *acellInfo)
1323 {
1324     struct afsconf_entry *tce;
1325     struct afsconf_aliasentry *tcae;
1326     struct afsconf_entry *bestce;
1327     afs_int32 i;
1328     int tservice;
1329     char *tcell;
1330     int cnLen;
1331     int ambig;
1332     char tbuffer[64];
1333
1334     LOCK_GLOBAL_MUTEX;
1335     if (adir)
1336         _afsconf_Check(adir);
1337     if (acellName) {
1338         tcell = acellName;
1339         cnLen = (int)(strlen(tcell) + 1);
1340         lcstring(tcell, tcell, cnLen);
1341         afsconf_SawCell = 1;    /* will ignore the AFSCELL switch on future */
1342         /* call to afsconf_GetLocalCell: like klog  */
1343     } else {
1344         i = afsconf_GetLocalCell(adir, tbuffer, sizeof(tbuffer));
1345         if (i) {
1346             UNLOCK_GLOBAL_MUTEX;
1347             return i;
1348         }
1349         tcell = tbuffer;
1350     }
1351     cnLen = strlen(tcell);
1352     bestce = (struct afsconf_entry *)0;
1353     ambig = 0;
1354     if (!adir) {
1355         UNLOCK_GLOBAL_MUTEX;
1356         return 0;
1357     }
1358
1359     /* Look through the list of aliases */
1360     for (tcae = adir->alias_entries; tcae; tcae = tcae->next) {
1361         if (strcasecmp(tcae->aliasInfo.aliasName, tcell) == 0) {
1362             tcell = tcae->aliasInfo.realName;
1363             break;
1364         }
1365     }
1366
1367     for (tce = adir->entries; tce; tce = tce->next) {
1368         if (strcasecmp(tce->cellInfo.name, tcell) == 0) {
1369             /* found our cell */
1370             bestce = tce;
1371             ambig = 0;
1372             break;
1373         }
1374         if (strlen(tce->cellInfo.name) < cnLen)
1375             continue;           /* clearly wrong */
1376         if (strncasecmp(tce->cellInfo.name, tcell, cnLen) == 0) {
1377             if (bestce)
1378                 ambig = 1;      /* ambiguous unless we get exact match */
1379             bestce = tce;
1380         }
1381     }
1382     if (!ambig && bestce && bestce->cellInfo.numServers) {
1383         *acellInfo = bestce->cellInfo;  /* structure assignment */
1384         if (aservice) {
1385             tservice = afsconf_FindService(aservice);
1386             if (tservice < 0) {
1387                 UNLOCK_GLOBAL_MUTEX;
1388                 return AFSCONF_NOTFOUND;        /* service not found */
1389             }
1390             for (i = 0; i < acellInfo->numServers; i++) {
1391                 acellInfo->hostAddr[i].sin_port = tservice;
1392             }
1393         }
1394         acellInfo->timeout = 0;
1395
1396         /*
1397          * Until we figure out how to separate out ubik server
1398          * queries from other server queries, only perform gethostbyname()
1399          * lookup on the specified hostnames for the client CellServDB files.
1400          */
1401         if (_afsconf_IsClientConfigDirectory(adir->name) &&
1402             !(acellInfo->flags & AFSCONF_CELL_FLAG_DNS_QUERIED)) {
1403             int j;
1404             short numServers=0;                                 /*Num active servers for the cell */
1405             struct sockaddr_in hostAddr[MAXHOSTSPERCELL];       /*IP addresses for cell's servers */
1406             char hostName[MAXHOSTSPERCELL][MAXHOSTCHARS];       /*Names for cell's servers */
1407
1408             memset(&hostAddr, 0, sizeof(hostAddr));
1409             memset(&hostName, 0, sizeof(hostName));
1410
1411             for ( j=0; j<acellInfo->numServers && numServers < MAXHOSTSPERCELL; j++ ) {
1412                 struct hostent *he = gethostbyname(acellInfo->hostName[j]);
1413                 int foundAddr = 0;
1414
1415                 if (he && he->h_addrtype == AF_INET) {
1416                     int i;
1417                     /* obtain all the valid address from the list */
1418                     for (i=0 ; he->h_addr_list[i] && numServers < MAXHOSTSPERCELL; i++) {
1419                         /* check to see if this is a new address; if so insert it into the list */
1420                         int k, dup;
1421                         afs_uint32 addr;
1422                         memcpy(&addr, he->h_addr_list[i], sizeof(addr));
1423                         for (k=0, dup=0; !dup && k < numServers; k++) {
1424                             if (hostAddr[k].sin_addr.s_addr == addr) {
1425                                 dup = 1;
1426                             }
1427                         }
1428                         if (dup)
1429                             continue;
1430
1431                         hostAddr[numServers].sin_family = AF_INET;
1432                         hostAddr[numServers].sin_port = acellInfo->hostAddr[0].sin_port;
1433 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
1434                         hostAddr[numServers].sin_len = sizeof(struct sockaddr_in);
1435 #endif
1436                         memcpy(&hostAddr[numServers].sin_addr.s_addr, he->h_addr_list[i], sizeof(afs_uint32));
1437                         strcpy(hostName[numServers], acellInfo->hostName[j]);
1438                         foundAddr = 1;
1439                         numServers++;
1440                     }
1441                 }
1442                 if (!foundAddr) {
1443                     hostAddr[numServers] = acellInfo->hostAddr[j];
1444                     strcpy(hostName[numServers], acellInfo->hostName[j]);
1445                     numServers++;
1446                 }
1447             }
1448
1449             for (i=0; i<numServers; i++) {
1450                 acellInfo->hostAddr[i] = hostAddr[i];
1451                 strcpy(acellInfo->hostName[i], hostName[i]);
1452             }
1453             acellInfo->numServers = numServers;
1454             acellInfo->flags |= AFSCONF_CELL_FLAG_DNS_QUERIED;
1455         }
1456         UNLOCK_GLOBAL_MUTEX;
1457         return 0;
1458     } else {
1459         UNLOCK_GLOBAL_MUTEX;
1460         return afsconf_GetAfsdbInfo(tcell, aservice, acellInfo);
1461     }
1462 }
1463
1464 /**
1465  * Get the current localcell name.
1466  *
1467  * Internal function to get a pointer to the local cell name.
1468  * This function must be called with the global afsconf lock held.
1469  *
1470  * @param[in]  adir    afsconf object
1471  * @param[out] aname   address to a char pointer
1472  * @param[in]  check   always perform a config check, even if the
1473  *                     the AFSCELL name is set.
1474  *
1475  * @return status
1476  *    @retval 0 success
1477  *    @retval AFSCONF_NOCELLNAME cannot determine local cell name
1478  *
1479  * @internal
1480  */
1481 int
1482 _afsconf_GetLocalCell(struct afsconf_dir *adir, char **pname, int check)
1483 {
1484     static int afsconf_showcell = 0;
1485     char *afscell_path;
1486     afs_int32 code = 0;
1487
1488     /*
1489      * If a cell switch was specified in a command, then it should override the
1490      * AFSCELL variable.  If a cell was specified, then the afsconf_SawCell flag
1491      * is set and the cell name in the adir structure is used.
1492      * Read the AFSCELL var each time: in case it changes (unsetenv AFSCELL).
1493      * Optionally, check the configuration, even if using the environment variable.
1494      */
1495     if (!afsconf_SawCell && (afscell_path = getenv("AFSCELL"))) {
1496         if (check) {
1497             _afsconf_Check(adir);
1498         }
1499         if (!afsconf_showcell) {
1500             fprintf(stderr, "Note: Operation is performed on cell %s\n",
1501                     afscell_path);
1502             afsconf_showcell = 1;
1503         }
1504         *pname = afscell_path;
1505     } else {
1506         _afsconf_Check(adir);
1507         if (adir->cellName) {
1508             *pname = adir->cellName;
1509         } else
1510             code = AFSCONF_NOCELLNAME;
1511     }
1512     return code;
1513 }
1514
1515 int
1516 afsconf_GetLocalCell(struct afsconf_dir *adir, char *aname, afs_int32 alen)
1517 {
1518     afs_int32 code = 0;
1519     char *cellname = NULL;
1520
1521     LOCK_GLOBAL_MUTEX;
1522     code = _afsconf_GetLocalCell(adir, &cellname, 0);
1523     if (!code && cellname) {
1524         strlcpy(aname, cellname, alen);
1525     }
1526     UNLOCK_GLOBAL_MUTEX;
1527     return (code);
1528 }
1529
1530 int
1531 afsconf_Close(struct afsconf_dir *adir)
1532 {
1533     if (adir == NULL) {
1534         return 0;
1535     }
1536
1537     LOCK_GLOBAL_MUTEX;
1538     afsconf_CloseInternal(adir);
1539     if (adir->name)
1540         free(adir->name);
1541     free(adir);
1542     UNLOCK_GLOBAL_MUTEX;
1543     return 0;
1544 }
1545
1546 static int
1547 afsconf_CloseInternal(struct afsconf_dir *adir)
1548 {
1549     struct afsconf_entry *td, *nd;
1550     struct afsconf_aliasentry *ta, *na;
1551     char *tname;
1552
1553     if (adir == NULL) {
1554         return 0;
1555     }
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     if (adir->cellservDB)
1563         free(adir->cellservDB);
1564     for (td = adir->entries; td; td = nd) {
1565         nd = td->next;
1566         if (td->cellInfo.linkedCell)
1567             free(td->cellInfo.linkedCell);
1568         free(td);
1569     }
1570     for (ta = adir->alias_entries; ta; ta = na) {
1571         na = ta->next;
1572         free(ta);
1573     }
1574
1575     _afsconf_FreeAllKeys(adir);
1576     _afsconf_FreeRealms(adir);
1577
1578     /* reinit */
1579     memset(adir, 0, sizeof(struct afsconf_dir));
1580     adir->name = tname;         /* restore it */
1581     return 0;
1582 }
1583
1584 static int
1585 afsconf_Reopen(struct afsconf_dir *adir)
1586 {
1587     afs_int32 code;
1588     code = afsconf_CloseInternal(adir);
1589     if (code)
1590         return code;
1591     code = afsconf_OpenInternal(adir, 0, 0);
1592     return code;
1593 }