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