auth: Refactor afsconf_Open failure handler
[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 #if     defined(AFS_OSF_ENV)
218     ts = getservbyname(aname, "");
219 #else
220     ts = (struct servent *) getservbyname(aname, NULL);
221 #endif
222     if (ts) {
223         /* we found it in /etc/services, so we use this value */
224         return ts->s_port;      /* already in network byte order */
225     }
226
227     /* not found in /etc/services, see if it is one of ours */
228     for (tsp = serviceTable; tsp->port; tsp++) {
229         if ((tsp->name && (!strcmp(tsp->name, aname)))
230             || (tsp->ianaName && (!strcmp(tsp->ianaName, aname))))
231             return htons(tsp->port);
232     }
233     return -1;
234 }
235
236 const char *
237 afsconf_FindIANAName(const char *aname)
238 {
239     /* lookup a service name */
240     struct afsconf_servPair *tsp;
241
242     if (aname == NULL || aname[0] == '\0')
243         return NULL;
244
245     /* see if it is one of ours */
246     for (tsp = serviceTable; tsp->port; tsp++) {
247         if ((tsp->name && (!strcmp(tsp->name, aname)))
248             || (tsp->ianaName && (!strcmp(tsp->ianaName, aname))))
249             return tsp->ianaName;
250     }
251     return NULL;
252 }
253
254 static int
255 TrimLine(char *abuffer, int abufsize)
256 {
257     char tbuffer[256];
258     char *tp;
259     int tc;
260
261     tp = abuffer;
262     while ((tc = *tp)) {
263         if (!isspace(tc))
264             break;
265         tp++;
266     }
267     strlcpy(tbuffer, tp, sizeof tbuffer);
268     strlcpy(abuffer, tbuffer, abufsize);
269     return 0;
270 }
271
272 /*
273  * IsClientConfigDirectory() -- determine if path matches well-known
274  *     client configuration directory.
275  */
276 #ifdef AFS_NT40_ENV
277 #define IS_SEP(x) ((x) == '\\' || (x) == '/')
278 #else /* AFS_NT40_ENV */
279 #define IS_SEP(x) ((x) == '/')
280 #endif /* AFS_NT40_ENV */
281 int
282 _afsconf_IsClientConfigDirectory(const char *path)
283 {
284     const char *cdir = AFSDIR_CLIENT_ETC_DIRPATH;
285     int i, cc, pc;
286
287     for (i = 0; cdir[i] != '\0' && path[i] != '\0'; i++) {
288 #ifdef AFS_NT40_ENV
289         cc = tolower(cdir[i]);
290         pc = tolower(path[i]);
291
292         if (cc == '\\') {
293             cc = '/';
294         }
295         if (pc == '\\') {
296             pc = '/';
297         }
298 #else /* AFS_NT40_ENV */
299         cc = cdir[i];
300         pc = path[i];
301 #endif /* AFS_NT40_ENV */
302         if (cc != pc) {
303             return 0;
304         }
305     }
306
307     /* hit end of one or both; allow mismatch in existence of trailing slash */
308     if (cdir[i] != '\0') {
309         if (!IS_SEP(cdir[i]) || (cdir[i + 1] != '\0')) {
310             return 0;
311         }
312     }
313     if (path[i] != '\0') {
314         if (!IS_SEP(path[i]) || (path[i + 1] != '\0')) {
315             return 0;
316         }
317     }
318     return 1;
319 }
320
321 #ifdef AFS_NT40_ENV
322 static void
323 _afsconf_CellServDBPath(struct afsconf_dir *adir, char **path)
324 {
325     char *p;
326
327     /* NT client CellServDB has different file name than NT server or Unix */
328     if (_afsconf_IsClientConfigDirectory(adir->name)) {
329         if (!afssw_GetClientCellServDBDir(&p)) {
330             asprintf(path, "%s/%s", p, AFSDIR_CELLSERVDB_FILE_NTCLIENT);
331             free(p);
332         } else {
333             asprintf(path, "%s/%s", adir->name, AFSDIR_CELLSERVDB_FILE_NTCLIENT);
334         }
335     } else {
336         asprintf(path, "%s/%s", adir->name, AFSDIR_CELLSERVDB_FILE);
337     }
338     return;
339 }
340 #else
341 static void
342 _afsconf_CellServDBPath(struct afsconf_dir *adir, char **path)
343 {
344     asprintf(path, "%s/%s", adir->name, AFSDIR_CELLSERVDB_FILE);
345 }
346 #endif /* AFS_NT40_ENV */
347
348 int
349 _afsconf_UpToDate(struct afsconf_dir *adir)
350 {
351     char *cellservDB;
352     struct stat tstat;
353     int code;
354     time_t now = time(0);
355
356     if (adir->timeCheck == now) {
357         return 1; /* stat no more than once a second */
358     }
359     adir->timeCheck = now;
360
361     _afsconf_CellServDBPath(adir, &cellservDB);
362     if (cellservDB == NULL)
363         return 0;
364
365     code = stat(cellservDB, &tstat);
366     free(cellservDB);
367     if (code < 0)
368         return 0; /* Can't throw the error, so just say we're not up to date */
369
370     /* did file change? */
371     if (tstat.st_mtime == adir->timeRead)
372         return 1;
373
374     /* otherwise file has changed */
375     return 0;
376 }
377
378 int
379 afsconf_UpToDate(void *rock)
380 {
381     int code;
382
383     LOCK_GLOBAL_MUTEX;
384     code = _afsconf_UpToDate(rock);
385     UNLOCK_GLOBAL_MUTEX;
386
387     return code;
388 }
389
390 int
391 _afsconf_Check(struct afsconf_dir *adir)
392 {
393     /* did configuration change? */
394     if (_afsconf_UpToDate(adir))
395         return 0;
396
397     /* otherwise file has changed, so reopen it */
398     return afsconf_Reopen(adir);
399 }
400
401 /* set modtime on file */
402 int
403 _afsconf_Touch(struct afsconf_dir *adir)
404 {
405     char *cellservDB;
406     int code;
407 #ifndef AFS_NT40_ENV
408     struct timeval tvp[2];
409 #endif
410
411     adir->timeRead = 0;         /* just in case */
412     adir->timeCheck = 0;
413
414     _afsconf_CellServDBPath(adir, &cellservDB);
415     if (cellservDB == NULL)
416         return ENOMEM;
417
418 #ifdef AFS_NT40_ENV
419     code = _utime(cellservDB, NULL);
420 #else
421     gettimeofday(&tvp[0], NULL);
422     tvp[1] = tvp[0];
423     code = utimes(cellservDB, tvp);
424 #endif /* AFS_NT40_ENV */
425     free(cellservDB);
426
427     return code;
428 }
429
430 struct afsconf_dir *
431 afsconf_Open(const char *adir)
432 {
433     struct afsconf_dir *tdir;
434     afs_int32 code;
435
436     LOCK_GLOBAL_MUTEX;
437     /* zero structure and fill in name; rest is done by internal routine */
438     tdir = calloc(1, sizeof(struct afsconf_dir));
439     tdir->name = strdup(adir);
440
441     code = afsconf_OpenInternal(tdir, 0, 0);
442     if (code) {
443         char *afsconf_path, afs_confdir[128];
444
445         free(tdir->name);
446         /* Check global place only when local Open failed for whatever reason */
447         if (!(afsconf_path = getenv("AFSCONF"))) {
448             /* 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... */
449             char *home_dir;
450             afsconf_FILE *fp;
451             size_t len;
452
453             if (!(home_dir = getenv("HOME"))) {
454                 /* Our last chance is the "/.AFSCONF" file */
455                 fp = fopen("/.AFSCONF", "r");
456                 if (fp == 0)
457                     goto fail;
458
459                 fgets(afs_confdir, 128, fp);
460                 fclose(fp);
461             } else {
462                 char *pathname = NULL;
463
464                 asprintf(&pathname, "%s/%s", home_dir, ".AFSCONF");
465                 if (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                 fgets(afs_confdir, 128, fp);
478                 fclose(fp);
479             }
480             len = strlen(afs_confdir);
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     /* figure out the local cell name */
636 #ifdef AFS_NT40_ENV
637     i = GetCellNT(adir);
638     enumCellRegistry.adir = adir;
639 #else
640     i = GetCellUnix(adir);
641 #endif
642
643 #ifndef AFS_FREELANCE_CLIENT    /* no local cell not fatal in freelance */
644     if (i) {
645         return i;
646     }
647 #endif
648
649     /* now parse the individual lines */
650     curEntry = 0;
651
652     _afsconf_CellServDBPath(adir, &cellservDB);
653
654 #ifdef AFS_NT40_ENV
655     if (_afsconf_IsClientConfigDirectory(adir->name))
656         enumCellRegistry.client = 1;
657 #endif /* AFS_NT40_ENV */
658
659     if (!stat(cellservDB, &tstat)) {
660         adir->timeRead = tstat.st_mtime;
661     } else {
662         adir->timeRead = 0;
663     }
664
665     tf = fopen(cellservDB, "r");
666     if (!tf) {
667         return -1;
668     }
669
670     /* init the keys queue before any call to afsconf_CloseInternal() */
671     _afsconf_InitKeys(adir);
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 c1, c2, c3, c4;
843     afs_int32 code;
844     char *tp;
845
846     if (*aline == '[') {
847         if (aclone)
848             *aclone = 1;
849         /* FIXME: length of aname unknown here */
850         code = sscanf(aline, "[%d.%d.%d.%d] #%s", &c1, &c2, &c3, &c4, aname);
851     } else {
852         if (aclone)
853             *aclone = 0;
854         /* FIXME: length of aname unknown here */
855         code = sscanf(aline, "%d.%d.%d.%d #%s", &c1, &c2, &c3, &c4, aname);
856     }
857     if (code != 5)
858         return AFSCONF_SYNTAX;
859     addr->sin_family = AF_INET;
860     addr->sin_port = 0;
861 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
862     addr->sin_len = sizeof(struct sockaddr_in);
863 #endif
864     tp = (char *)&addr->sin_addr;
865     *tp++ = c1;
866     *tp++ = c2;
867     *tp++ = c3;
868     *tp++ = c4;
869     return 0;
870 }
871
872 /* parse a line of the form
873  * ">cellname [linkedcellname] [#comments]"
874  * into the appropriate pieces.
875  */
876 static int
877 ParseCellLine(char *aline, char *aname,
878               char *alname)
879 {
880     int code;
881     /* FIXME: length of aname, alname unknown here */
882     code = sscanf(aline, ">%s %s", aname, alname);
883     if (code == 1)
884         *alname = '\0';
885     if (code == 2) {
886         if (*alname == '#') {
887             *alname = '\0';
888         }
889     }
890     return (code > 0 ? 0 : AFSCONF_SYNTAX);
891 }
892
893 /* call aproc(entry, arock, adir) for all cells.  Proc must return 0, or we'll stop early and return the code it returns */
894 int
895 afsconf_CellApply(struct afsconf_dir *adir,
896                   int (*aproc) (struct afsconf_cell * cell, void *arock,
897                                 struct afsconf_dir * dir), void *arock)
898 {
899     struct afsconf_entry *tde;
900     afs_int32 code;
901     LOCK_GLOBAL_MUTEX;
902     for (tde = adir->entries; tde; tde = tde->next) {
903         code = (*aproc) (&tde->cellInfo, arock, adir);
904         if (code) {
905             UNLOCK_GLOBAL_MUTEX;
906             return code;
907         }
908     }
909     UNLOCK_GLOBAL_MUTEX;
910     return 0;
911 }
912
913 /* call aproc(entry, arock, adir) for all cell aliases.
914  * Proc must return 0, or we'll stop early and return the code it returns
915  */
916 int
917 afsconf_CellAliasApply(struct afsconf_dir *adir,
918                        int (*aproc) (struct afsconf_cellalias * alias,
919                                      void *arock, struct afsconf_dir * dir),
920                        void *arock)
921 {
922     struct afsconf_aliasentry *tde;
923     afs_int32 code;
924     LOCK_GLOBAL_MUTEX;
925     for (tde = adir->alias_entries; tde; tde = tde->next) {
926         code = (*aproc) (&tde->aliasInfo, arock, adir);
927         if (code) {
928             UNLOCK_GLOBAL_MUTEX;
929             return code;
930         }
931     }
932     UNLOCK_GLOBAL_MUTEX;
933     return 0;
934 }
935
936 afs_int32 afsconf_SawCell = 0;
937
938 int
939 afsconf_GetExtendedCellInfo(struct afsconf_dir *adir, char *acellName,
940                             char *aservice, struct afsconf_cell *acellInfo,
941                             char clones[])
942 {
943     afs_int32 code;
944     char *cell;
945
946     code = afsconf_GetCellInfo(adir, acellName, aservice, acellInfo);
947     if (code)
948         return code;
949
950     if (acellName)
951         cell = acellName;
952     else
953         cell = (char *)&acellInfo->name;
954
955     code = afsconf_OpenInternal(adir, cell, clones);
956     return code;
957 }
958
959 #if !defined(AFS_NT40_ENV)
960 int
961 afsconf_LookupServer(const char *service, const char *protocol,
962                      const char *cellName, unsigned short afsdbPort,
963                      int *cellHostAddrs, char cellHostNames[][MAXHOSTCHARS],
964                      unsigned short ports[], unsigned short ipRanks[],
965                      int *numServers, int *ttl, char **arealCellName)
966 {
967     int code = 0;
968     int len;
969     unsigned char answer[4096];
970     unsigned char *p;
971     char *dotcellname = NULL;
972     char *realCellName;
973     char host[256];
974     int server_num = 0;
975     int minttl = 0;
976     int try_init = 0;
977     int dnstype = 0;
978     int pass = 0;
979     char *IANAname = (char *) afsconf_FindIANAName(service);
980     int tservice = afsconf_FindService(service);
981
982     realCellName = NULL;
983
984     *numServers = 0;
985     *ttl = 0;
986     if (tservice <= 0 || !IANAname)
987         return AFSCONF_NOTFOUND;        /* service not found */
988
989     if (strchr(cellName,'.'))
990         pass += 2;
991
992 #ifdef HAVE_RES_RETRANSRETRY
993     if ((_res.options & RES_INIT) == 0 && res_init() == -1)
994       return (0);
995
996     /*
997      * Rx timeout is typically 56 seconds; limit user experience to
998      * similar timeout
999      */
1000     _res.retrans = 18;
1001     _res.retry = 3;
1002 #endif
1003
1004  retryafsdb:
1005     switch (pass) {
1006     case 0:
1007         dnstype = T_SRV;
1008         asprintf(&dotcellname, "_%s._%s.%s.", IANAname, protocol, cellName);
1009         break;
1010     case 1:
1011         dnstype = T_AFSDB;
1012         asprintf(&dotcellname, "%s.", cellName);
1013         break;
1014     case 2:
1015         dnstype = T_SRV;
1016         asprintf(&dotcellname, "_%s._%s.%s", IANAname, protocol, cellName);
1017         break;
1018     case 3:
1019         dnstype = T_AFSDB;
1020         asprintf(&dotcellname, "%s", cellName);
1021         break;
1022     }
1023     if (dotcellname == NULL)
1024         goto findservererror;
1025
1026     LOCK_GLOBAL_MUTEX;
1027     len = res_search(dotcellname, C_IN, dnstype, answer, sizeof(answer));
1028     UNLOCK_GLOBAL_MUTEX;
1029
1030     if (dotcellname != NULL) {
1031         free(dotcellname);
1032         dotcellname = NULL;
1033     }
1034
1035     if (len < 0) {
1036         if (try_init < 1) {
1037             try_init++;
1038             res_init();
1039             goto retryafsdb;
1040         }
1041         if (pass < 3) {
1042             pass++;
1043             goto retryafsdb;
1044         } else {
1045             code = AFSCONF_NOTFOUND;
1046             goto findservererror;
1047         }
1048     }
1049
1050     p = answer + sizeof(HEADER);        /* Skip header */
1051     code = dn_expand(answer, answer + len, p, host, sizeof(host));
1052     if (code < 0) {
1053         code = AFSCONF_NOTFOUND;
1054         goto findservererror;
1055     }
1056
1057     p += code + QFIXEDSZ;       /* Skip name */
1058
1059     while (p < answer + len) {
1060         int type, ttl, size;
1061
1062         code = dn_expand(answer, answer + len, p, host, sizeof(host));
1063         if (code < 0) {
1064             code = AFSCONF_NOTFOUND;
1065             goto findservererror;
1066         }
1067
1068         p += code;              /* Skip the name */
1069         type = (p[0] << 8) | p[1];
1070         p += 4;                 /* Skip type and class */
1071         ttl = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
1072         p += 4;                 /* Skip the TTL */
1073         size = (p[0] << 8) | p[1];
1074         p += 2;                 /* Skip the size */
1075
1076         if (type == T_AFSDB) {
1077             struct hostent *he;
1078             short afsdb_type;
1079
1080             afsdb_type = (p[0] << 8) | p[1];
1081             if (afsdb_type == 1) {
1082                 /*
1083                  * We know this is an AFSDB record for our cell, of the
1084                  * right AFSDB type.  Write down the true cell name that
1085                  * the resolver gave us above.
1086                  */
1087                 if (!realCellName)
1088                     realCellName = strdup(host);
1089             }
1090
1091             code = dn_expand(answer, answer + len, p + 2, host, sizeof(host));
1092             if (code < 0) {
1093                 code = AFSCONF_NOTFOUND;
1094                 goto findservererror;
1095             }
1096
1097             if ((afsdb_type == 1) && (server_num < MAXHOSTSPERCELL) &&
1098                 /* Do we want to get TTL data for the A record as well? */
1099                 (he = gethostbyname(host))) {
1100                 if (he->h_addrtype == AF_INET) {
1101                     afs_int32 ipaddr;
1102                     memcpy(&ipaddr, he->h_addr, sizeof(ipaddr));
1103                     cellHostAddrs[server_num] = ipaddr;
1104                     ports[server_num] = afsdbPort;
1105                     ipRanks[server_num] = 0;
1106                     strncpy(cellHostNames[server_num], host,
1107                             sizeof(cellHostNames[server_num]));
1108                     server_num++;
1109                     if (!minttl || ttl < minttl)
1110                         minttl = ttl;
1111                 }
1112             }
1113         }
1114         if (type == T_SRV) {
1115             struct hostent *he;
1116             /* math here: _ is 1, _ ._ is 3, _ ._ . is 4. then the domain. */
1117             if ((strncmp(host + 1, IANAname, strlen(IANAname)) == 0) &&
1118                 (strncmp(host + strlen(IANAname) + 3, protocol,
1119                          strlen(protocol)) == 0)) {
1120                 if (!realCellName)
1121                     realCellName = strdup(host + strlen(IANAname) +
1122                                           strlen(protocol) + 4);
1123             }
1124
1125             code = dn_expand(answer, answer + len, p + 6, host, sizeof(host));
1126             if (code < 0) {
1127                 code = AFSCONF_NOTFOUND;
1128                 goto findservererror;
1129             }
1130
1131             if ((server_num < MAXHOSTSPERCELL) &&
1132                 /* Do we want to get TTL data for the A record as well? */
1133                 (he = gethostbyname(host))) {
1134                 if (he->h_addrtype == AF_INET) {
1135                     afs_int32 ipaddr;
1136
1137                     memcpy(&ipaddr, he->h_addr, sizeof(ipaddr));
1138                     cellHostAddrs[server_num] = ipaddr;
1139                     ipRanks[server_num] = (p[0] << 8) | p[1];
1140                     ports[server_num] = htons((p[4] << 8) | p[5]);
1141                     /* weight = (p[2] << 8) | p[3]; */
1142                     strncpy(cellHostNames[server_num], host,
1143                             sizeof(cellHostNames[server_num]));
1144                     server_num++;
1145
1146                     if (!minttl || ttl < minttl)
1147                         minttl = ttl;
1148                 }
1149             }
1150         }
1151
1152         p += size;
1153     }
1154
1155     if (server_num == 0) {      /* No AFSDB or SRV records */
1156         code = AFSCONF_NOTFOUND;
1157         goto findservererror;
1158     }
1159
1160     if (realCellName) {
1161         /* Convert the real cell name to lowercase */
1162         for (p = (unsigned char *)realCellName; *p; p++)
1163             *p = tolower(*p);
1164     }
1165
1166     *numServers = server_num;
1167     *ttl = minttl ? (time(0) + minttl) : 0;
1168
1169     if ( *numServers > 0 ) {
1170         code =  0;
1171         *arealCellName = realCellName;
1172     } else
1173         code = AFSCONF_NOTFOUND;
1174
1175 findservererror:
1176     if (code && realCellName)
1177         free(realCellName);
1178     return code;
1179 }
1180
1181 int
1182 afsconf_GetAfsdbInfo(char *acellName, char *aservice,
1183                      struct afsconf_cell *acellInfo)
1184 {
1185     afs_int32 cellHostAddrs[AFSMAXCELLHOSTS];
1186     char cellHostNames[AFSMAXCELLHOSTS][MAXHOSTCHARS];
1187     unsigned short ipRanks[AFSMAXCELLHOSTS];
1188     unsigned short ports[AFSMAXCELLHOSTS];
1189     char *realCellName = NULL;
1190     int ttl, numServers, i;
1191     char *service = aservice;
1192     int code;
1193     unsigned short afsdbport;
1194     if (!service) {
1195         service = "afs3-vlserver";
1196         afsdbport = htons(7003);
1197     } else {
1198         service = aservice;
1199         afsdbport = afsconf_FindService(service);
1200     }
1201     code = afsconf_LookupServer((const char *)service, "udp",
1202                                 (const char *)acellName, afsdbport,
1203                                 cellHostAddrs, cellHostNames,
1204                                 ports, ipRanks, &numServers, &ttl,
1205                                 &realCellName);
1206
1207     /* If we couldn't find an entry for the requested service
1208      * and that service happens to be the prservice or kaservice
1209      * then fallback to searching for afs3-vlserver and assigning
1210      * the port number here. */
1211     if (code < 0 && (afsdbport == htons(7002) || afsdbport == htons(7004))) {
1212         code = afsconf_LookupServer("afs3-vlserver", "udp",
1213                                     (const char *)acellName, afsdbport,
1214                                     cellHostAddrs, cellHostNames,
1215                                     ports, ipRanks, &numServers, &ttl,
1216                                     &realCellName);
1217         if (code >= 0) {
1218             for (i = 0; i < numServers; i++)
1219                 ports[i] = afsdbport;
1220         }
1221     }
1222     if (code == 0) {
1223         acellInfo->timeout = ttl;
1224         acellInfo->numServers = numServers;
1225         for (i = 0; i < numServers; i++) {
1226             memcpy(&acellInfo->hostAddr[i].sin_addr.s_addr, &cellHostAddrs[i],
1227                    sizeof(afs_int32));
1228             memcpy(acellInfo->hostName[i], cellHostNames[i], MAXHOSTCHARS);
1229             acellInfo->hostAddr[i].sin_family = AF_INET;
1230             acellInfo->hostAddr[i].sin_port = ports[i];
1231
1232             if (realCellName) {
1233                 strlcpy(acellInfo->name, realCellName,
1234                         sizeof(acellInfo->name));
1235                 free(realCellName);
1236                 realCellName = NULL;
1237             }
1238         }
1239         acellInfo->linkedCell = NULL;       /* no linked cell */
1240         acellInfo->flags = 0;
1241     }
1242     return code;
1243 }
1244 #else /* windows */
1245 int
1246 afsconf_GetAfsdbInfo(char *acellName, char *aservice,
1247                      struct afsconf_cell *acellInfo)
1248 {
1249     afs_int32 i;
1250     int tservice = afsconf_FindService(aservice);   /* network byte order */
1251     const char *ianaName = afsconf_FindIANAName(aservice);
1252     struct afsconf_entry DNSce;
1253     afs_int32 cellHostAddrs[AFSMAXCELLHOSTS];
1254     char cellHostNames[AFSMAXCELLHOSTS][MAXHOSTCHARS];
1255     unsigned short ipRanks[AFSMAXCELLHOSTS];
1256     unsigned short ports[AFSMAXCELLHOSTS];          /* network byte order */
1257     int numServers;
1258     int rc;
1259     int ttl;
1260
1261     if (tservice < 0) {
1262         if (aservice)
1263             return AFSCONF_NOTFOUND;
1264         else
1265             tservice = 0;       /* port will be assigned by caller */
1266     }
1267
1268     if (ianaName == NULL)
1269         ianaName = "afs3-vlserver";
1270
1271     DNSce.cellInfo.numServers = 0;
1272     DNSce.next = NULL;
1273
1274     rc = getAFSServer(ianaName, "udp", acellName, tservice,
1275                       cellHostAddrs, cellHostNames, ports, ipRanks, &numServers,
1276                       &ttl);
1277     /* ignore the ttl here since this code is only called by transitory programs
1278      * like klog, etc. */
1279
1280     /* If we couldn't find an entry for the requested service
1281      * and that service happens to be the prservice or kaservice
1282      * then fallback to searching for afs3-vlserver and assigning
1283      * the port number here. */
1284     if (rc < 0 && (tservice == htons(7002) || tservice == htons(7004))) {
1285         rc = getAFSServer("afs3-vlserver", "udp", acellName, tservice,
1286                            cellHostAddrs, cellHostNames, ports, ipRanks, &numServers,
1287                            &ttl);
1288         if (rc >= 0) {
1289             for (i = 0; i < numServers; i++)
1290                 ports[i] = tservice;
1291         }
1292     }
1293
1294     if (rc < 0 || numServers == 0)
1295         return -1;
1296
1297     for (i = 0; i < numServers; i++) {
1298         memcpy(&acellInfo->hostAddr[i].sin_addr.s_addr, &cellHostAddrs[i],
1299                sizeof(long));
1300         memcpy(acellInfo->hostName[i], cellHostNames[i], MAXHOSTCHARS);
1301         acellInfo->hostAddr[i].sin_family = AF_INET;
1302         if (aservice)
1303             acellInfo->hostAddr[i].sin_port = ports[i];
1304         else
1305             acellInfo->hostAddr[i].sin_port = 0;
1306     }
1307
1308     acellInfo->numServers = numServers;
1309     strlcpy(acellInfo->name, acellName, sizeof acellInfo->name);
1310     acellInfo->linkedCell = NULL;       /* no linked cell */
1311     acellInfo->flags = 0;
1312     return 0;
1313 }
1314 #endif /* windows */
1315
1316 int
1317 afsconf_GetCellInfo(struct afsconf_dir *adir, char *acellName, char *aservice,
1318                     struct afsconf_cell *acellInfo)
1319 {
1320     struct afsconf_entry *tce;
1321     struct afsconf_aliasentry *tcae;
1322     struct afsconf_entry *bestce;
1323     afs_int32 i;
1324     int tservice;
1325     char *tcell;
1326     int cnLen;
1327     int ambig;
1328     char tbuffer[64];
1329
1330     LOCK_GLOBAL_MUTEX;
1331     if (adir)
1332         _afsconf_Check(adir);
1333     if (acellName) {
1334         tcell = acellName;
1335         cnLen = (int)(strlen(tcell) + 1);
1336         lcstring(tcell, tcell, cnLen);
1337         afsconf_SawCell = 1;    /* will ignore the AFSCELL switch on future */
1338         /* call to afsconf_GetLocalCell: like klog  */
1339     } else {
1340         i = afsconf_GetLocalCell(adir, tbuffer, sizeof(tbuffer));
1341         if (i) {
1342             UNLOCK_GLOBAL_MUTEX;
1343             return i;
1344         }
1345         tcell = tbuffer;
1346     }
1347     cnLen = strlen(tcell);
1348     bestce = (struct afsconf_entry *)0;
1349     ambig = 0;
1350     if (!adir) {
1351         UNLOCK_GLOBAL_MUTEX;
1352         return 0;
1353     }
1354
1355     /* Look through the list of aliases */
1356     for (tcae = adir->alias_entries; tcae; tcae = tcae->next) {
1357         if (strcasecmp(tcae->aliasInfo.aliasName, tcell) == 0) {
1358             tcell = tcae->aliasInfo.realName;
1359             break;
1360         }
1361     }
1362
1363     for (tce = adir->entries; tce; tce = tce->next) {
1364         if (strcasecmp(tce->cellInfo.name, tcell) == 0) {
1365             /* found our cell */
1366             bestce = tce;
1367             ambig = 0;
1368             break;
1369         }
1370         if (strlen(tce->cellInfo.name) < cnLen)
1371             continue;           /* clearly wrong */
1372         if (strncasecmp(tce->cellInfo.name, tcell, cnLen) == 0) {
1373             if (bestce)
1374                 ambig = 1;      /* ambiguous unless we get exact match */
1375             bestce = tce;
1376         }
1377     }
1378     if (!ambig && bestce && bestce->cellInfo.numServers) {
1379         *acellInfo = bestce->cellInfo;  /* structure assignment */
1380         if (aservice) {
1381             tservice = afsconf_FindService(aservice);
1382             if (tservice < 0) {
1383                 UNLOCK_GLOBAL_MUTEX;
1384                 return AFSCONF_NOTFOUND;        /* service not found */
1385             }
1386             for (i = 0; i < acellInfo->numServers; i++) {
1387                 acellInfo->hostAddr[i].sin_port = tservice;
1388             }
1389         }
1390         acellInfo->timeout = 0;
1391
1392         /*
1393          * Until we figure out how to separate out ubik server
1394          * queries from other server queries, only perform gethostbyname()
1395          * lookup on the specified hostnames for the client CellServDB files.
1396          */
1397         if (_afsconf_IsClientConfigDirectory(adir->name) &&
1398             !(acellInfo->flags & AFSCONF_CELL_FLAG_DNS_QUERIED)) {
1399             int j;
1400             short numServers=0;                                 /*Num active servers for the cell */
1401             struct sockaddr_in hostAddr[MAXHOSTSPERCELL];       /*IP addresses for cell's servers */
1402             char hostName[MAXHOSTSPERCELL][MAXHOSTCHARS];       /*Names for cell's servers */
1403
1404             memset(&hostAddr, 0, sizeof(hostAddr));
1405             memset(&hostName, 0, sizeof(hostName));
1406
1407             for ( j=0; j<acellInfo->numServers && numServers < MAXHOSTSPERCELL; j++ ) {
1408                 struct hostent *he = gethostbyname(acellInfo->hostName[j]);
1409                 int foundAddr = 0;
1410
1411                 if (he && he->h_addrtype == AF_INET) {
1412                     int i;
1413                     /* obtain all the valid address from the list */
1414                     for (i=0 ; he->h_addr_list[i] && numServers < MAXHOSTSPERCELL; i++) {
1415                         /* check to see if this is a new address; if so insert it into the list */
1416                         int k, dup;
1417                         for (k=0, dup=0; !dup && k < numServers; k++) {
1418                             if (hostAddr[k].sin_addr.s_addr == *(u_long *)he->h_addr_list[i])
1419                                 dup = 1;
1420                         }
1421                         if (dup)
1422                             continue;
1423
1424                         hostAddr[numServers].sin_family = AF_INET;
1425                         hostAddr[numServers].sin_port = acellInfo->hostAddr[0].sin_port;
1426 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
1427                         hostAddr[numServers].sin_len = sizeof(struct sockaddr_in);
1428 #endif
1429                         memcpy(&hostAddr[numServers].sin_addr.s_addr, he->h_addr_list[i], sizeof(long));
1430                         strcpy(hostName[numServers], acellInfo->hostName[j]);
1431                         foundAddr = 1;
1432                         numServers++;
1433                     }
1434                 }
1435                 if (!foundAddr) {
1436                     hostAddr[numServers] = acellInfo->hostAddr[j];
1437                     strcpy(hostName[numServers], acellInfo->hostName[j]);
1438                     numServers++;
1439                 }
1440             }
1441
1442             for (i=0; i<numServers; i++) {
1443                 acellInfo->hostAddr[i] = hostAddr[i];
1444                 strcpy(acellInfo->hostName[i], hostName[i]);
1445             }
1446             acellInfo->numServers = numServers;
1447             acellInfo->flags |= AFSCONF_CELL_FLAG_DNS_QUERIED;
1448         }
1449         UNLOCK_GLOBAL_MUTEX;
1450         return 0;
1451     } else {
1452         UNLOCK_GLOBAL_MUTEX;
1453         return afsconf_GetAfsdbInfo(tcell, aservice, acellInfo);
1454     }
1455 }
1456
1457 /**
1458  * Get the current localcell name.
1459  *
1460  * Internal function to get a pointer to the local cell name.
1461  * This function must be called with the global afsconf lock held.
1462  *
1463  * @param[in]  adir    afsconf object
1464  * @param[out] aname   address to a char pointer
1465  * @param[in]  check   always perform a config check, even if the
1466  *                     the AFSCELL name is set.
1467  *
1468  * @return status
1469  *    @retval 0 success
1470  *    @retval AFSCONF_UNKNOWN failed to get cellname
1471  *
1472  * @internal
1473  */
1474 int
1475 _afsconf_GetLocalCell(struct afsconf_dir *adir, char **pname, int check)
1476 {
1477     static int afsconf_showcell = 0;
1478     char *afscell_path;
1479     afs_int32 code = 0;
1480
1481     /*
1482      * If a cell switch was specified in a command, then it should override the
1483      * AFSCELL variable.  If a cell was specified, then the afsconf_SawCell flag
1484      * is set and the cell name in the adir structure is used.
1485      * Read the AFSCELL var each time: in case it changes (unsetenv AFSCELL).
1486      * Optionally, check the configuration, even if using the environment variable.
1487      */
1488     if (!afsconf_SawCell && (afscell_path = getenv("AFSCELL"))) {
1489         if (check) {
1490             _afsconf_Check(adir);
1491         }
1492         if (!afsconf_showcell) {
1493             fprintf(stderr, "Note: Operation is performed on cell %s\n",
1494                     afscell_path);
1495             afsconf_showcell = 1;
1496         }
1497         *pname = afscell_path;
1498     } else {
1499         _afsconf_Check(adir);
1500         if (adir->cellName) {
1501             *pname = adir->cellName;
1502         } else
1503             code = AFSCONF_UNKNOWN;
1504     }
1505     return code;
1506 }
1507
1508 int
1509 afsconf_GetLocalCell(struct afsconf_dir *adir, char *aname, afs_int32 alen)
1510 {
1511     afs_int32 code = 0;
1512     char *cellname = NULL;
1513
1514     LOCK_GLOBAL_MUTEX;
1515     code = _afsconf_GetLocalCell(adir, &cellname, 0);
1516     if (!code && cellname) {
1517         strlcpy(aname, cellname, alen);
1518     }
1519     UNLOCK_GLOBAL_MUTEX;
1520     return (code);
1521 }
1522
1523 int
1524 afsconf_Close(struct afsconf_dir *adir)
1525 {
1526     LOCK_GLOBAL_MUTEX;
1527     afsconf_CloseInternal(adir);
1528     if (adir->name)
1529         free(adir->name);
1530     free(adir);
1531     UNLOCK_GLOBAL_MUTEX;
1532     return 0;
1533 }
1534
1535 static int
1536 afsconf_CloseInternal(struct afsconf_dir *adir)
1537 {
1538     struct afsconf_entry *td, *nd;
1539     struct afsconf_aliasentry *ta, *na;
1540     char *tname;
1541
1542     tname = adir->name;         /* remember name, since that's all we preserve */
1543
1544     /* free everything we can find */
1545     if (adir->cellName)
1546         free(adir->cellName);
1547     for (td = adir->entries; td; td = nd) {
1548         nd = td->next;
1549         if (td->cellInfo.linkedCell)
1550             free(td->cellInfo.linkedCell);
1551         free(td);
1552     }
1553     for (ta = adir->alias_entries; ta; ta = na) {
1554         na = ta->next;
1555         free(ta);
1556     }
1557
1558     _afsconf_FreeAllKeys(adir);
1559     _afsconf_FreeRealms(adir);
1560
1561     /* reinit */
1562     memset(adir, 0, sizeof(struct afsconf_dir));
1563     adir->name = tname;         /* restore it */
1564     return 0;
1565 }
1566
1567 static int
1568 afsconf_Reopen(struct afsconf_dir *adir)
1569 {
1570     afs_int32 code;
1571     code = afsconf_CloseInternal(adir);
1572     if (code)
1573         return code;
1574     code = afsconf_OpenInternal(adir, 0, 0);
1575     return code;
1576 }