90f053de5e0ceaab14e99110910820342f532081
[openafs.git] / src / util / dirpath.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 #include <roken.h>
14 #include <afs/opr.h>
15
16 #include <stddef.h>
17 #include <ctype.h>
18 #include <limits.h>
19
20 #include "afsutil.h"
21 #include "fileutil.h"
22
23 #include <afs/opr.h>
24
25 #ifdef AFS_PTHREAD_ENV
26 #include <pthread.h>
27 static pthread_once_t dirInit_once = PTHREAD_ONCE_INIT;
28 #endif
29
30 #ifdef AFS_NT40_ENV
31 #include <WINNT\afssw.h>
32 #endif
33
34 /* local vars */
35 /* static storage for path strings */
36 static char dirPathArray[AFSDIR_PATHSTRING_MAX][AFSDIR_PATH_MAX];
37
38 /* indicate if and how the dirpath module initialized. */
39 static int initFlag = 0;
40 static unsigned int initStatus = 0;
41
42
43 /* storage for dynamically-determined install dir (NT only; long and short) */
44 #ifdef AFS_NT40_ENV
45 static char ntServerInstallDirLong[AFSDIR_PATH_MAX];
46 static char ntServerInstallDirShort[AFSDIR_PATH_MAX];
47 static char ntClientConfigDirLong[AFSDIR_PATH_MAX];
48 static char ntClientConfigDirShort[AFSDIR_PATH_MAX];
49 #endif
50
51 /* storage for local afs server/client paths (top-level) */
52 static char afsSrvDirPath[AFSDIR_PATH_MAX];
53 static char afsClntDirPath[AFSDIR_PATH_MAX];
54
55 /* internal array init function */
56 static void initDirPathArray(void);
57
58 /* Additional macros for ease of use */
59 /* buf is expected to be atleast AFS_PATH_MAX bytes long */
60 #define AFSDIR_SERVER_DIRPATH(buf, dir)  \
61             (void) strcompose(buf, AFSDIR_PATH_MAX, serverPrefix, dir, (char *)NULL)
62
63 #define AFSDIR_SERVER_FILEPATH(buf, dir, file)  \
64             (void) strcompose(buf, AFSDIR_PATH_MAX, serverPrefix, dir, "/", file,  (char *)NULL)
65
66 #define AFSDIR_CLIENT_DIRPATH(buf, dir)  \
67             (void) strcompose(buf, AFSDIR_PATH_MAX, clientPrefix, dir, (char *)NULL)
68
69 #define AFSDIR_CLIENT_FILEPATH(buf, dir, file)  \
70             (void) strcompose(buf, AFSDIR_PATH_MAX,  clientPrefix, dir, "/", file,  (char *)NULL)
71
72
73 /* initAFSDirPath() -- External users call this function to initialize
74  * the dirpath module and/or to determine the initialization status.
75  */
76 unsigned int
77 initAFSDirPath(void)
78 {
79     if (initFlag == 0) {        /* not yet init'ed, so initialize */
80 #ifdef AFS_PTHREAD_ENV
81         pthread_once(&dirInit_once, initDirPathArray);
82 #else
83         initDirPathArray();
84 #endif
85     }
86     return initStatus;
87 }
88
89
90 /* initDirPathArray() -- Initializes the afs dir paths for the
91  *     server and client installations.
92  *
93  *     For NT these are determined dynamically; for Unix they are static.
94  *
95  *     NT NOTE: If a particular component (client/server) is not installed
96  *              then we may not be able to initialize the paths to anything
97  *              meaningful.  In this case the paths are set to the local
98  *              temp directory to avoid later reference to an uninitialized
99  *              variable.  The initStatus flag is set to indicate which
100  *              paths (client/server) initialized properly for callers of
101  *              initAFSDirPath() who would like to know this information.
102  */
103 static void
104 initDirPathArray(void)
105 {
106     char *pathp, *clntEtcDir;
107     const char *clientPrefix = "";
108     const char *serverPrefix = "";
109
110 #ifdef AFS_NT40_ENV
111     char *buf;
112     int status;
113
114     /* get the afs server software installation dir from the registry */
115     if (afssw_GetServerInstallDir(&buf)) {
116         /* failed; server not installed; use temp directory */
117         strcpy(ntServerInstallDirLong, gettmpdir());
118     } else {
119         strcpy(ntServerInstallDirLong, buf);
120         free(buf);
121         initStatus |= AFSDIR_SERVER_PATHS_OK;
122     }
123     FilepathNormalize(ntServerInstallDirLong);
124     status =
125         GetShortPathName(ntServerInstallDirLong, ntServerInstallDirShort,
126                          AFSDIR_PATH_MAX);
127     if (status == 0 || status > AFSDIR_PATH_MAX) {
128         /* can't convert path to short version; just use long version */
129         strcpy(ntServerInstallDirShort, ntServerInstallDirLong);
130     }
131     FilepathNormalize(ntServerInstallDirShort);
132
133     /* get the afs client configuration directory (/usr/vice/etc equivalent) */
134     if (afssw_GetClientCellServDBDir(&buf)) {
135         /* failed */
136         status = GetWindowsDirectory(ntClientConfigDirLong, AFSDIR_PATH_MAX);
137         if (status == 0 || status > AFSDIR_PATH_MAX) {
138             /* failed to get canonical Windows directory; use temp directory */
139             strcpy(ntClientConfigDirLong, gettmpdir());
140         } else {
141             initStatus |= AFSDIR_CLIENT_PATHS_OK;
142         }
143     } else {
144         strcpy(ntClientConfigDirLong, buf);
145         free(buf);
146         initStatus |= AFSDIR_CLIENT_PATHS_OK;
147     }
148     FilepathNormalize(ntClientConfigDirLong);
149
150     status =
151         GetShortPathName(ntClientConfigDirLong, ntClientConfigDirShort,
152                          AFSDIR_PATH_MAX);
153     if (status == 0 || status > AFSDIR_PATH_MAX) {
154         /* can't convert path to short version; just use long version */
155         strcpy(ntClientConfigDirShort, ntClientConfigDirLong);
156     }
157     FilepathNormalize(ntClientConfigDirShort);
158     clientPrefix = ntClientConfigDirShort;
159
160     /* setup the root server directory path (/usr/afs equivalent) */
161     strcpy(afsSrvDirPath, ntServerInstallDirShort);
162     strcat(afsSrvDirPath, AFSDIR_CANONICAL_SERVER_AFS_DIRPATH);
163
164     /* there is no root client directory path (/usr/vice equivalent) */
165     afsClntDirPath[0] = '\0';
166
167     /* setup top level dirpath (/usr equivalent); valid for server ONLY */
168     strcpy(dirPathArray[AFSDIR_USR_DIRPATH_ID], ntServerInstallDirShort);
169     serverPrefix = ntServerInstallDirShort;
170     strcat(dirPathArray[AFSDIR_USR_DIRPATH_ID], AFSDIR_CANONICAL_USR_DIRPATH);
171
172 #else /* AFS_NT40_ENV */
173     /* setup the root server directory path */
174     strcpy(afsSrvDirPath, AFSDIR_CANONICAL_SERVER_AFS_DIRPATH);
175
176     /* setup the root client directory path */
177 #ifdef AFS_DARWIN_ENV
178     if (access(AFSDIR_ALTERNATE_CLIENT_VICE_DIRPATH, F_OK) == 0)
179         strcpy(afsClntDirPath, AFSDIR_ALTERNATE_CLIENT_VICE_DIRPATH);
180     else
181 #endif
182         strcpy(afsClntDirPath, AFSDIR_CANONICAL_CLIENT_VICE_DIRPATH);
183
184     /* setup top level dirpath; valid for both server and client */
185     strcpy(dirPathArray[AFSDIR_USR_DIRPATH_ID], AFSDIR_CANONICAL_USR_DIRPATH);
186
187     initStatus |= (AFSDIR_CLIENT_PATHS_OK | AFSDIR_SERVER_PATHS_OK);
188 #endif /* AFS_NT40_ENV */
189
190     /* now initialize various dir and file paths exported by dirpath module */
191
192     /* server dir paths */
193     strcpy(dirPathArray[AFSDIR_SERVER_AFS_DIRPATH_ID], afsSrvDirPath);
194
195     pathp = dirPathArray[AFSDIR_SERVER_ETC_DIRPATH_ID];
196     AFSDIR_SERVER_DIRPATH(pathp, AFSDIR_SERVER_ETC_DIR);
197
198     pathp = dirPathArray[AFSDIR_SERVER_BIN_DIRPATH_ID];
199     AFSDIR_SERVER_DIRPATH(pathp, AFSDIR_SERVER_BIN_DIR);
200
201     pathp = dirPathArray[AFSDIR_SERVER_CORES_DIRPATH_ID];
202     AFSDIR_SERVER_DIRPATH(pathp, AFSDIR_CORES_DIR);
203
204     pathp = dirPathArray[AFSDIR_SERVER_DB_DIRPATH_ID];
205     AFSDIR_SERVER_DIRPATH(pathp, AFSDIR_DB_DIR);
206
207     pathp = dirPathArray[AFSDIR_SERVER_LOGS_DIRPATH_ID];
208     AFSDIR_SERVER_DIRPATH(pathp, AFSDIR_LOGS_DIR);
209
210     pathp = dirPathArray[AFSDIR_SERVER_LOCAL_DIRPATH_ID];
211     AFSDIR_SERVER_DIRPATH(pathp, AFSDIR_LOCAL_DIR);
212
213     pathp = dirPathArray[AFSDIR_SERVER_BACKUP_DIRPATH_ID];
214     AFSDIR_SERVER_DIRPATH(pathp, AFSDIR_BACKUP_DIR);
215
216     pathp = dirPathArray[AFSDIR_SERVER_MIGRATE_DIRPATH_ID];
217     AFSDIR_SERVER_DIRPATH(pathp, AFSDIR_MIGR_DIR);
218
219     pathp = dirPathArray[AFSDIR_SERVER_BIN_FILE_DIRPATH_ID];
220     AFSDIR_SERVER_DIRPATH(pathp, AFSDIR_BIN_FILE_DIR);
221
222     /* client dir path */
223 #ifdef AFS_NT40_ENV
224     strcpy(dirPathArray[AFSDIR_CLIENT_VICE_DIRPATH_ID],
225            "/NoUsrViceDirectoryOnWindows");
226     strcpy(dirPathArray[AFSDIR_CLIENT_ETC_DIRPATH_ID],
227            ntClientConfigDirShort);
228
229     clntEtcDir = pathp = dirPathArray[AFSDIR_CLIENT_ETC_DIRPATH_ID];
230 #else
231     strcpy(dirPathArray[AFSDIR_CLIENT_VICE_DIRPATH_ID], afsClntDirPath);
232
233     clntEtcDir = pathp = dirPathArray[AFSDIR_CLIENT_ETC_DIRPATH_ID];
234 #ifdef AFS_DARWIN_ENV
235     if (access(AFSDIR_ALTERNATE_CLIENT_ETC_DIR, F_OK) == 0)
236         AFSDIR_CLIENT_DIRPATH(pathp, AFSDIR_ALTERNATE_CLIENT_ETC_DIR);
237     else
238 #endif
239         AFSDIR_CLIENT_DIRPATH(pathp, AFSDIR_CLIENT_ETC_DIR);
240 #endif /* AFS_NT40_ENV */
241
242 #ifndef AFS_NT40_ENV
243     pathp = dirPathArray[AFSDIR_CLIENT_DATA_DIRPATH_ID];
244 #ifdef AFS_DARWIN_ENV
245     if (access(AFSDIR_ALTERNATE_CLIENT_DATA_DIR, F_OK) == 0)
246         AFSDIR_CLIENT_DIRPATH(pathp, AFSDIR_ALTERNATE_CLIENT_DATA_DIR);
247     else
248 #endif
249         AFSDIR_CLIENT_DIRPATH(pathp, AFSDIR_DATA_DIR);
250 #endif
251
252     /* server file paths */
253     pathp = dirPathArray[AFSDIR_SERVER_THISCELL_FILEPATH_ID];
254     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_ETC_DIR,
255                            AFSDIR_THISCELL_FILE);
256
257     pathp = dirPathArray[AFSDIR_SERVER_CELLSERVDB_FILEPATH_ID];
258     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_ETC_DIR,
259                            AFSDIR_CELLSERVDB_FILE);
260
261     pathp = dirPathArray[AFSDIR_SERVER_NOAUTH_FILEPATH_ID];
262     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_NOAUTH_FILE);
263
264     pathp = dirPathArray[AFSDIR_SERVER_BUDBLOG_FILEPATH_ID];
265     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_BUDBLOG_FILE);
266
267     pathp = dirPathArray[AFSDIR_SERVER_TAPECONFIG_FILEPATH_ID];
268     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_BACKUP_DIR, AFSDIR_TAPECONFIG_FILE);
269
270     pathp = dirPathArray[AFSDIR_SERVER_KALOGDB_FILEPATH_ID];
271     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_KALOGDB_FILE);
272
273     pathp = dirPathArray[AFSDIR_SERVER_KALOG_FILEPATH_ID];
274     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_KALOG_FILE);
275
276     pathp = dirPathArray[AFSDIR_SERVER_KADB_FILEPATH_ID];
277     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_DB_DIR, AFSDIR_KADB_FILE);
278
279     pathp = dirPathArray[AFSDIR_SERVER_NTPD_FILEPATH_ID];
280     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_BIN_DIR, AFSDIR_NTPD_FILE);
281
282     pathp = dirPathArray[AFSDIR_SERVER_PRDB_FILEPATH_ID];
283     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_DB_DIR, AFSDIR_PRDB_FILE);
284
285     pathp = dirPathArray[AFSDIR_SERVER_PTLOG_FILEPATH_ID];
286     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_PTLOG_FILE);
287
288     pathp = dirPathArray[AFSDIR_SERVER_KCONF_FILEPATH_ID];
289     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_ETC_DIR, AFSDIR_KCONF_FILE);
290
291     pathp = dirPathArray[AFSDIR_SERVER_VLDB_FILEPATH_ID];
292     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_DB_DIR, AFSDIR_VLDB_FILE);
293
294     pathp = dirPathArray[AFSDIR_SERVER_VLOG_FILEPATH_ID];
295     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_VLOG_FILE);
296
297     pathp = dirPathArray[AFSDIR_SERVER_CORELOG_FILEPATH_ID];
298     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_CORE_FILE);
299
300     pathp = dirPathArray[AFSDIR_SERVER_SLVGLOG_FILEPATH_ID];
301     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_SLVGLOG_FILE);
302
303     pathp = dirPathArray[AFSDIR_SERVER_SALSRVLOG_FILEPATH_ID];
304     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_SALSRVLOG_FILE);
305
306     pathp = dirPathArray[AFSDIR_SERVER_SALVAGER_FILEPATH_ID];
307     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_BIN_DIR,
308                            AFSDIR_SALVAGER_FILE);
309
310     pathp = dirPathArray[AFSDIR_SERVER_SALSRV_FILEPATH_ID];
311     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_BIN_DIR,
312                            AFSDIR_SALSRV_FILE);
313
314     pathp = dirPathArray[AFSDIR_SERVER_SLVGLOCK_FILEPATH_ID];
315     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_SLVGLOCK_FILE);
316
317     pathp = dirPathArray[AFSDIR_SERVER_KEY_FILEPATH_ID];
318     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_ETC_DIR, AFSDIR_KEY_FILE);
319
320     pathp = dirPathArray[AFSDIR_SERVER_ULIST_FILEPATH_ID];
321     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_ETC_DIR, AFSDIR_ULIST_FILE);
322
323     pathp = dirPathArray[AFSDIR_SERVER_BOZCONF_FILEPATH_ID];
324     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_BOSCONFIG_DIR, AFSDIR_BOZCONF_FILE);
325
326     pathp = dirPathArray[AFSDIR_SERVER_BOZCONFNEW_FILEPATH_ID];
327     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_BOSCONFIG_DIR,
328                            AFSDIR_BOZCONFNEW_FILE);
329
330     pathp = dirPathArray[AFSDIR_SERVER_BOZLOG_FILEPATH_ID];
331     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_BOZLOG_FILE);
332
333     pathp = dirPathArray[AFSDIR_SERVER_BOZINIT_FILEPATH_ID];
334     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_BOSCONFIG_DIR, AFSDIR_BOZINIT_FILE);
335
336     pathp = dirPathArray[AFSDIR_SERVER_BOZRXBIND_FILEPATH_ID];
337     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_BOSCONFIG_DIR, AFSDIR_BOZRXBIND_FILE);
338
339     pathp = dirPathArray[AFSDIR_SERVER_BOSVR_FILEPATH_ID];
340     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_BOSSERVER_DIR, AFSDIR_BOSVR_FILE);
341
342     pathp = dirPathArray[AFSDIR_SERVER_VOLSERLOG_FILEPATH_ID];
343     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_VOLSERLOG_FILE);
344
345     pathp = dirPathArray[AFSDIR_SERVER_ROOTVOL_FILEPATH_ID];
346     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_ETC_DIR, AFSDIR_ROOTVOL_FILE);
347
348     pathp = dirPathArray[AFSDIR_SERVER_HOSTDUMP_FILEPATH_ID];
349     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_HOSTDUMP_FILE);
350
351     pathp = dirPathArray[AFSDIR_SERVER_CLNTDUMP_FILEPATH_ID];
352     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_CLNTDUMP_FILE);
353
354     pathp = dirPathArray[AFSDIR_SERVER_CBKDUMP_FILEPATH_ID];
355     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_CBKDUMP_FILE);
356
357     pathp = dirPathArray[AFSDIR_SERVER_OLDSYSID_FILEPATH_ID];
358     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_OLDSYSID_FILE);
359
360     pathp = dirPathArray[AFSDIR_SERVER_SYSID_FILEPATH_ID];
361     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_SYSID_FILE);
362
363     pathp = dirPathArray[AFSDIR_SERVER_FILELOG_FILEPATH_ID];
364     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_FILELOG_FILE);
365
366     pathp = dirPathArray[AFSDIR_SERVER_AUDIT_FILEPATH_ID];
367     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_AUDIT_FILE);
368
369     pathp = dirPathArray[AFSDIR_SERVER_CONFIG_FILE_FILEPATH_ID];
370     AFSDIR_CLIENT_FILEPATH(pathp, AFSDIR_SERVER_ETC_DIR,
371                            AFSDIR_SERVER_CONFIG_FILE);
372
373     pathp = dirPathArray[AFSDIR_SERVER_NETINFO_FILEPATH_ID];
374     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_NETINFO_FILE);
375
376     pathp = dirPathArray[AFSDIR_SERVER_NETRESTRICT_FILEPATH_ID];
377     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_NETRESTRICT_FILE);
378
379     pathp = dirPathArray[AFSDIR_SERVER_WEIGHTING_CONSTANTS_FILEPATH_ID];
380     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_MIGR_DIR,
381                            AFSDIR_WEIGHTINGCONST_FILE);
382
383     pathp = dirPathArray[AFSDIR_SERVER_THRESHOLD_CONSTANTS_FILEPATH_ID];
384     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_MIGR_DIR,
385                            AFSDIR_THRESHOLDCONST_FILE);
386
387     pathp = dirPathArray[AFSDIR_SERVER_MIGRATELOG_FILEPATH_ID];
388     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_MIGR_DIR, AFSDIR_MIGRATE_LOGNAME);
389
390     pathp = dirPathArray[AFSDIR_SERVER_KRB_EXCL_FILEPATH_ID];
391     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_ETC_DIR, AFSDIR_KRB_EXCL_FILE);
392
393     pathp = dirPathArray[AFSDIR_SERVER_FSSTATE_FILEPATH_ID];
394     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_FSSTATE_FILE);
395
396     pathp = dirPathArray[AFSDIR_SERVER_RXKAD_KEYTAB_FILEPATH_ID];
397     AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_ETC_DIR, AFSDIR_RXKAD_KEYTAB_FILE);
398
399     /* client file paths */
400 #ifdef AFS_NT40_ENV
401     strcpy(dirPathArray[AFSDIR_CLIENT_THISCELL_FILEPATH_ID],
402            "/NoUsrViceEtcThisCellFileOnWindows");
403     sprintf(dirPathArray[AFSDIR_CLIENT_CELLSERVDB_FILEPATH_ID], "%s/%s",
404             ntClientConfigDirShort, AFSDIR_CELLSERVDB_FILE_NTCLIENT);
405     strcpy(dirPathArray[AFSDIR_CLIENT_CELLALIAS_FILEPATH_ID],
406            "/NoCellAliasOnWindows");
407 #else
408     pathp = dirPathArray[AFSDIR_CLIENT_THISCELL_FILEPATH_ID];
409     AFSDIR_CLIENT_FILEPATH(pathp, clntEtcDir, AFSDIR_THISCELL_FILE);
410
411     pathp = dirPathArray[AFSDIR_CLIENT_CELLSERVDB_FILEPATH_ID];
412     AFSDIR_CLIENT_FILEPATH(pathp, clntEtcDir, AFSDIR_CELLSERVDB_FILE);
413
414     pathp = dirPathArray[AFSDIR_CLIENT_CELLALIAS_FILEPATH_ID];
415     AFSDIR_CLIENT_FILEPATH(pathp, clntEtcDir, AFSDIR_CELLALIAS_FILE);
416 #endif /* AFS_NT40_ENV */
417
418     pathp = dirPathArray[AFSDIR_CLIENT_CONFIG_FILE_FILEPATH_ID];
419     AFSDIR_CLIENT_FILEPATH(pathp, clntEtcDir, AFSDIR_CLIENT_CONFIG_FILE);
420
421     pathp = dirPathArray[AFSDIR_CLIENT_NETINFO_FILEPATH_ID];
422     AFSDIR_CLIENT_FILEPATH(pathp, clntEtcDir, AFSDIR_NETINFO_FILE);
423
424     pathp = dirPathArray[AFSDIR_CLIENT_NETRESTRICT_FILEPATH_ID];
425     AFSDIR_CLIENT_FILEPATH(pathp, clntEtcDir, AFSDIR_NETRESTRICT_FILE);
426
427     initFlag = 1;               /* finished dirpath initialization */
428     return;
429 }
430
431 /* getDirPath - returns a const char pointer to the requested string
432  * from the internal path array.
433  * string_id - index into the path array
434  */
435 const char *
436 getDirPath(afsdir_id_t string_id)
437 {
438     /* check if the array has been initialized */
439     if (initFlag == 0) {        /* no it's not, so initialize */
440 #ifdef AFS_PTHREAD_ENV
441         pthread_once(&dirInit_once, initDirPathArray);
442 #else
443         initDirPathArray();
444 #endif
445     }
446     return (const char *)dirPathArray[string_id];
447 }
448
449 /*
450  * LocalizePathHead() -- Make path relative to local part
451  *
452  * ConstructLocalPath takes a path and a directory that path should
453  * be considered relative to.  There are two possible cases:
454  *
455  * The path is an absolute path.  In this case, the relative path
456  * is ignored.  We check the path for a prefix that represents a
457  * canonical path, and if one is found, we adjust the path to remove
458  * the prefix and adjust the directory to which it should be
459  * considered relative to be the local version of that canonical path.
460  *
461  * The path is a relative path.  In this case, we check to see if the
462  * directory to which it is relative represents a canonical path, and
463  * if so, we adjust that directory to be the local version of that
464  * canonical path.  The relative path itself is left unchanged.
465  */
466
467 /* The following array  maps cannonical parts to local parts.  It
468  * might  seem reasonable to  simply construct an array in parallel to
469  * dirpatharray  but it turns out you don't want translations for all
470  * local paths.
471 */
472
473 struct canonmapping {
474     const char *canonical;
475     const char *local;
476 };
477 static struct canonmapping CanonicalTranslations[] = {
478     {AFSDIR_CANONICAL_SERVER_ETC_DIRPATH, AFSDIR_SERVER_ETC_DIR},
479     {AFSDIR_CANONICAL_SERVER_LOGS_DIRPATH, AFSDIR_LOGS_DIR},
480     {AFSDIR_CANONICAL_SERVER_LOCAL_DIRPATH, AFSDIR_LOCAL_DIR},
481     {AFSDIR_CANONICAL_SERVER_BIN_DIRPATH, AFSDIR_SERVER_BIN_DIR},
482     {NULL, NULL}
483 };
484
485 static void
486 LocalizePathHead(const char **path, const char **relativeTo)
487 {
488      struct canonmapping *map;
489
490      if (**path == '/') {
491          for (map = CanonicalTranslations; map->local != NULL; map++) {
492              int canonlength = strlen(map->canonical);
493              if (strncmp(*path, map->canonical, canonlength) == 0) {
494                  (*path) += canonlength;
495                  if (**path == '/')
496                      (*path)++;
497                  *relativeTo = map->local;
498                  return;
499              }
500          }
501      } else {
502          for (map = CanonicalTranslations; map->local != NULL; map++) {
503              if (strcmp(*relativeTo, map->canonical) == 0) {
504                  *relativeTo = map->local;
505                  return;
506              }
507          }
508      }
509 }
510
511
512 #ifdef AFS_NT40_ENV
513 /* NT version of ConstructLocalPath() */
514
515 /*
516  * ConstructLocalPath() --  Convert a canonical (wire-format) path to a fully
517  *     specified local path.  Upon successful completion, *fullPathBufp is
518  *     set to an allocated buffer containing the fully specified local path
519  *     constructed from the cpath argument.
520  *
521  *     On NT, path construction proceeds as follows:
522  *         1) If cpath is fully qualified (i.e., starts with 'X:/') then the
523  *            path returned is equivalent to cpath.
524  *         2) If cpath begins with a drive letter but is not fully qualified,
525  *            i.e., it is drive relative, then the function fails with EINVAL.
526  *         3) If cpath begins with '/' (or '\') then the path returned is the
527  *            concatenation  AFS-server-install-dir + cpath after translating for localization.
528  *         4) Otherwise the path returned is the concatenation
529  *            AFS-server-install-dir + relativeTo + cpath.
530  *
531  *     Leading whitespace in cpath is ignored; the constructed path is
532  *     normalized (FilepathNormalize()).
533  *
534  * RETURN CODES: 0 if successful; errno code otherwise.
535  */
536 int
537 ConstructLocalPath(const char *cpath, const char *relativeTo,
538                    char **fullPathBufp)
539 {
540     int status = 0;
541     char *newPath = NULL;
542
543     if (initFlag == 0) {        /* dirpath module not yet initialized */
544 #ifdef AFS_PTHREAD_ENV
545         pthread_once(&dirInit_once, initDirPathArray);
546 #else
547         initDirPathArray();
548 #endif
549     }
550
551     *fullPathBufp = NULL;
552
553     while (isspace(*cpath)) {
554         cpath++;
555     }
556
557     LocalizePathHead(&cpath, &relativeTo);
558     if ((((*cpath >= 'a') && (*cpath <= 'z'))
559          || ((*cpath >= 'A') && (*cpath <= 'Z'))) && (*(cpath + 1) == ':')) {
560
561         /* cpath has a leading drive letter */
562         if ((*(cpath + 2) != '/') && (*(cpath + 2) != '\\')) {
563             /* drive letter relative path; this is not allowed */
564             status = EINVAL;
565         } else {
566             /* fully qualified path; just make a copy */
567             newPath = strdup(cpath);
568             if (!newPath)
569                 status = ENOMEM;
570         }
571
572     } else {
573         /* cpath has NO leading drive letter; make relative to install dir */
574         size_t pathSize = strlen(ntServerInstallDirShort) + 2;
575
576         if ((*cpath == '/') || (*cpath == '\\')) {
577             /* construct path relative to install directory only */
578             pathSize += strlen(cpath);
579
580             newPath = malloc(pathSize);
581             if (!newPath) {
582                 status = ENOMEM;
583             } else {
584                 sprintf(newPath, "%s/%s", ntServerInstallDirShort, cpath);
585             }
586         } else {
587             /* construct path relative to 'relativeTo' (and install dir) */
588             pathSize += strlen(relativeTo) + 1 + strlen(cpath);
589
590             newPath = malloc(pathSize);
591             if (!newPath) {
592                 status = ENOMEM;
593             } else {
594                 sprintf(newPath, "%s/%s/%s", ntServerInstallDirShort,
595                         relativeTo, cpath);
596             }
597         }
598     }
599
600     if (status == 0) {
601         FilepathNormalize(newPath);
602
603         /* return buffer containing fully specified path */
604         *fullPathBufp = newPath;
605     }
606
607     return status;
608 }
609
610 #else
611 /* Unix version of ConstructLocalPath() */
612
613 /*
614  * ConstructLocalPath() --  Convert a canonical (wire-format) path to a fully
615  *     specified local path.  Upon successful completion, *fullPathBufp is
616  *     set to an allocated buffer containing the fully specified local path
617  *     constructed from the cpath argument.
618  *
619  *     On Unix, path construction proceeds as follows:
620  *         1) If cpath begins with '/' then the path returned is equivalent
621  *            to cpath.
622  *         2) Otherwise the path returned is the concatenation
623  *            relativeTo + cpath.
624  *
625  *     Leading whitespace in cpath is ignored; the constructed path is
626  *     normalized (FilepathNormalize()).
627  *
628  * RETURN CODES: 0 if successful; errno code otherwise.
629  */
630 int
631 ConstructLocalPath(const char *cpath, const char *relativeTo,
632                    char **fullPathBufp)
633 {
634     int status = 0;
635     char *newPath = NULL;
636
637     if (initFlag == 0) {        /* dirpath module not yet initialized */
638 #ifdef AFS_PTHREAD_ENV
639         pthread_once(&dirInit_once, initDirPathArray);
640 #else
641         initDirPathArray();
642 #endif
643     }
644
645     *fullPathBufp = NULL;
646
647     while (isspace(*cpath)) {
648         cpath++;
649     }
650
651     LocalizePathHead(&cpath, &relativeTo);
652     if (*cpath == '/') {
653         newPath = strdup(cpath);
654     } else {
655         if (asprintf(&newPath, "%s/%s", relativeTo, cpath) < 0)
656             newPath = NULL;
657     }
658     if (newPath == NULL)
659         status = ENOMEM;
660
661     if (status == 0) {
662         FilepathNormalize(newPath);
663
664         /* return buffer containing fully specified path */
665         *fullPathBufp = newPath;
666     }
667
668     return status;
669 }
670 #endif /* AFS_NT40_ENV */
671
672
673 /*
674  * ConstructLocalBinPath() -- A convenience wrapper for ConstructLocalPath()
675  *     that specifies the canonical AFS server binary directory as the relative
676  *     directory.
677  */
678 int
679 ConstructLocalBinPath(const char *cpath, char **fullPathBufp)
680 {
681     return ConstructLocalPath(cpath, AFSDIR_SERVER_BIN_DIRPATH,
682                               fullPathBufp);
683 }
684
685
686 /*
687  * ConstructLocalLogPath() -- A convenience wrapper for ConstructLocalPath()
688  *     that specifies the canonical AFS server logs directory as the relative
689  *     directory.
690  */
691 int
692 ConstructLocalLogPath(const char *cpath, char **fullPathBufp)
693 {
694     return ConstructLocalPath(cpath, AFSDIR_SERVER_LOGS_DIRPATH,
695                               fullPathBufp);
696 }