char *
afstest_BuildTestConfig(void) {
char *dir = NULL;
FILE *file;
struct hostent *host;
char hostname[255];
struct in_addr iaddr;
if (asprintf(&dir, "%s/afs_XXXXXX", gettmpdir()) == -1)
goto fail;
if (mkdtemp(dir) == NULL)
goto fail;
/* Work out which IP address to use in our CellServDB. We figure this out
* according to the IP address which ubik is most likely to pick for one of
* our db servers */
gethostname(hostname, sizeof(hostname));
host = gethostbyname(hostname);
if (!host)
return NULL;
memcpy(&iaddr, host->h_addr, 4);
file = openConfigFile(dir, "CellServDB");
fprintf(file, ">example.org # An example cell\n");
fprintf(file, "%s #test.example.org\n", inet_ntoa(iaddr));
fclose(file);
/* Create a ThisCell file */
file = openConfigFile(dir, "ThisCell");
fprintf(file, "example.org");
fclose(file);
return dir;
fail:
if (dir)
free(dir);
return NULL;
}
/* bc_openTextFile - This function opens a temp file to read in the
* config text recd from the bu server. On Unix, an unlink() is done on
* the file as soon as it is opened, so when the program exits, the file will
* be removed automatically, while being invisible while in use.
* On NT, however, the file must be explicitly deleted after use with an unlink()
* Input:
* Pointer to a udhClientTextP struct. The open stream ptr is stored in
* the udbClientTextP.textStream member.
* Output: The temp file name is returned in tmpFileName. This should be used
* to delete the file when done with it.
* Return Values:
* !0: error code
* 0: Success.
*/
int
bc_openTextFile(udbClientTextP ctPtr, char *tmpFileName)
{
int code = 0;
int fd;
if (ctPtr->textStream != NULL) {
fclose(ctPtr->textStream);
ctPtr->textStream = NULL;
}
sprintf(tmpFileName, "%s/bu_XXXXXX", gettmpdir());
fd = mkstemp(tmpFileName);
if (fd == -1)
ERROR(BUDB_INTERNALERROR);
ctPtr->textStream = fdopen(fd, "w+");
if (ctPtr->textStream == NULL)
ERROR(BUDB_INTERNALERROR);
#ifndef AFS_NT40_ENV /* This can't be done on NT */
/* make the file invisible to others */
code = unlink(tmpFileName);
if (code)
ERROR(errno);
#endif
afs_dprintf(("file is %s\n", tmpFileName));
normal_exit:
return code;
error_exit:
if (ctPtr->textStream != NULL) {
fclose(ctPtr->textStream);
ctPtr->textStream = NULL;
}
goto normal_exit;
}
/* debug support */
void
saveTextToFile(struct ubik_trans *ut, struct textBlock *tbPtr)
{
afs_int32 blockAddr;
struct block block;
char filename[128];
afs_int32 size, chunkSize;
int fid;
sprintf(filename, "%s/%s", gettmpdir(), "dbg_XXXXXX");
fid = mkstemp(filename);
size = ntohl(tbPtr->size);
blockAddr = ntohl(tbPtr->textAddr);
while (size) {
chunkSize = MIN(BLOCK_DATA_SIZE, size);
dbread(ut, blockAddr, (char *)&block, sizeof(block));
write(fid, &block.a[0], chunkSize);
blockAddr = ntohl(block.h.next);
size -= chunkSize;
}
close(fid);
printf("wrote debug file %s\n", filename);
}
int
restoreText(struct butm_tapeInfo *tapeInfo,
struct rstTapeInfo *rstTapeInfoPtr,
struct structDumpHeader *nextHeader)
{
char filename[64];
afs_int32 nbytes;
char *readBuffer = 0;
afs_int32 readBlockSize;
afs_int32 transferSize;
struct structDumpHeader netItemHeader;
int fid = -1;
afs_int32 code = 0;
udbClientTextP ctPtr = 0;
afs_int32 textType;
ctPtr = (udbClientTextP) malloc(sizeof(*ctPtr));
if (!ctPtr)
ERROR_EXIT(TC_NOMEMORY);
/* determine the type of text block */
switch (nextHeader->type) {
case SD_TEXT_DUMPSCHEDULE:
textType = TB_DUMPSCHEDULE;
break;
case SD_TEXT_VOLUMESET:
textType = TB_VOLUMESET;
break;
case SD_TEXT_TAPEHOSTS:
textType = TB_TAPEHOSTS;
break;
default:
ErrorLog(0, rstTapeInfoPtr->taskId, TC_INTERNALERROR, 0,
"Unknown text block\n");
ERROR_EXIT(TC_INTERNALERROR);
break;
}
/* open the text file */
sprintf(filename, "%s/bu_XXXXXX", gettmpdir());
#if defined (HAVE_MKSTEMP)
fid = mkstemp(filename);
#else
fid = open(mktemp(filename), O_RDWR | O_CREAT | O_EXCL, 0600);
#endif
if (fid < 0) {
ErrorLog(0, rstTapeInfoPtr->taskId, errno, 0,
"Can't open temporary text file: %s\n", filename);
ERROR_EXIT(errno);
}
/* allocate buffer for text */
readBlockSize = BUTM_BLKSIZE;
readBuffer = (char *)malloc(readBlockSize);
if (!readBuffer)
ERROR_EXIT(TC_NOMEMORY);
/* read the text into the temporary file */
nbytes = nextHeader->size;
while (nbytes > 0) {
transferSize = (readBlockSize < nbytes) ? readBlockSize : nbytes;
/* read it from the tape */
code =
getTapeData(tapeInfo, rstTapeInfoPtr, readBuffer, transferSize);
if (code)
ERROR_EXIT(code);
/* write to the file */
if (write(fid, readBuffer, transferSize) != transferSize) {
ErrorLog(0, rstTapeInfoPtr->taskId, errno, 0,
"Can't write temporary text file: %s\n", filename);
ERROR_EXIT(errno);
}
nbytes -= transferSize;
}
close(fid);
fid = -1;
code = saveTextFile(rstTapeInfoPtr->taskId, textType, filename);
if (code)
ERROR_EXIT(code);
unlink(filename);
/* get the next item-header */
memset(nextHeader, 0, sizeof(*nextHeader));
code =
getTapeData(tapeInfo, rstTapeInfoPtr, &netItemHeader,
sizeof(netItemHeader));
if (code)
ERROR_EXIT(code);
structDumpHeader_ntoh(&netItemHeader, nextHeader);
error_exit:
if (ctPtr)
free(ctPtr);
if (readBuffer)
free(readBuffer);
if (fid != -1) {
close(fid);
unlink(filename);
}
return (code);
}
int
main(int argc, char **argv)
{
afs_int32 code, i;
afs_uint32 serverList[MAXSERVERS];
afs_uint32 myHost;
struct rx_service *tservice;
struct rx_securityClass *sc[2];
char dbfileName[128];
if (argc == 1) {
printf("usage: userver -servers <serverlist> {-sleep <sleeptime>}\n");
exit(0);
}
#ifdef AFS_NT40_ENV
/* initialize winsock */
if (afs_winsockInit() < 0)
return -1;
#endif
/* parse our own local arguments */
sleepTime = 0;
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-sleep") == 0) {
if (i >= argc - 1) {
printf("missing time in -sleep argument\n");
exit(1);
}
sleepTime = atoi(argv[i + 1]);
i++;
}
}
/* call routine to parse command line -servers switch, filling in
* myHost and serverList arrays appropriately */
code = ubik_ParseServerList(argc, argv, &myHost, serverList);
if (code) {
printf("could not parse server list, code %d\n", code);
exit(1);
}
/* call ServerInit with the values from ParseServerList. Also specify the
* name to use for the database files (/tmp/testdb), and the port (3000)
* for RPC requests. ServerInit returns a pointer to the database (in
* dbase), which is required for creating new transactions */
sprintf(dbfileName, "%s/testdb", gettmpdir());
code =
ubik_ServerInit(myHost, htons(3000), serverList, dbfileName, &dbase);
if (code) {
printf("ubik init failed with code %d\n", code);
exit(1);
}
sc[0] = rxnull_NewServerSecurityObject();
#if 0
sc[1] = rxvab_NewServerSecurityObject("applexx", 0);
#endif
tservice = rx_NewService(0, USER_SERVICE_ID, "Sample", sc, 1 /*2 */ ,
SAMPLE_ExecuteRequest);
if (tservice == (struct rx_service *)0) {
printf("Could not create SAMPLE rx service\n");
exit(3);
}
rx_SetMinProcs(tservice, 2);
rx_SetMaxProcs(tservice, 3);
rx_StartServer(1); /* Why waste this idle process?? */
return 0;
}
afs_int32
krb_write_ticket_file(char *realm)
{
int fd;
int count;
afs_int32 code;
int lifetime, kvno;
char *tf_name;
struct ktc_principal client, server;
struct ktc_token token;
if ((strlen(realm) >= sizeof(client.cell)))
return KABADNAME;
strcpy(server.name, KA_TGS_NAME);
strcpy(server.instance, realm);
lcstring(server.cell, realm, sizeof(server.cell));
code = ktc_GetToken(&server, &token, sizeof(struct ktc_token), &client);
if (code)
return code;
/* Use the KRBTKFILE environment variable if it exists, otherwise fall
* back upon /tmp/tkt(uid}.
*/
if ((tf_name = (char *)getenv("KRBTKFILE")))
fd = open(tf_name, O_WRONLY | O_CREAT | O_TRUNC, 0700);
else {
afs_asprintf(&tf_name, "%s/tkt%d", gettmpdir(), getuid());
if (tf_name == NULL)
return ENOMEM;
fd = open(tf_name, O_WRONLY | O_CREAT | O_TRUNC, 0700);
free(tf_name);
}
if (fd <= 0)
return errno;
/* write client name as file header */
count = strlen(client.name) + 1;
if (write(fd, client.name, count) != count)
goto bad;
count = strlen(client.instance) + 1;
if (write(fd, client.instance, count) != count)
goto bad;
/* Write the ticket and associated data */
/* Service */
count = strlen(server.name) + 1;
if (write(fd, server.name, count) != count)
goto bad;
/* Instance */
count = strlen(server.instance) + 1;
if (write(fd, server.instance, count) != count)
goto bad;
/* Realm */
ucstring(server.cell, server.cell, sizeof(server.cell));
count = strlen(server.cell) + 1;
if (write(fd, server.cell, count) != count)
goto bad;
/* Session key */
if (write(fd, (char *)&token.sessionKey, 8) != 8)
goto bad;
/* Lifetime */
lifetime = time_to_life(token.startTime, token.endTime);
if (write(fd, (char *)&lifetime, sizeof(int)) != sizeof(int))
goto bad;
/* Key vno */
kvno = token.kvno;
if (write(fd, (char *)&kvno, sizeof(int)) != sizeof(int))
goto bad;
/* Tkt length */
if (write(fd, (char *)&(token.ticketLen), sizeof(int)) != sizeof(int))
goto bad;
/* Ticket */
count = token.ticketLen;
if (write(fd, (char *)(token.ticket), count) != count)
goto bad;
/* Issue date */
if (write(fd, (char *)&(token.startTime), sizeof(afs_int32))
!= sizeof(afs_int32))
goto bad;
close(fd);
return 0;
bad:
close(fd);
return -1;
}
/* initDirPathArray() -- Initializes the afs dir paths for the
* server and client installations.
*
* For NT these are determined dynamically; for Unix they are static.
*
* NT NOTE: If a particular component (client/server) is not installed
* then we may not be able to initialize the paths to anything
* meaningful. In this case the paths are set to the local
* temp directory to avoid later reference to an uninitialized
* variable. The initStatus flag is set to indicate which
* paths (client/server) initialized properly for callers of
* initAFSDirPath() who would like to know this information.
*/
static void
initDirPathArray(void)
{
char *pathp;
const char *clientPrefix = "";
const char *serverPrefix = "";
#ifdef AFS_NT40_ENV
char *buf;
int status;
/* get the afs server software installation dir from the registry */
if (afssw_GetServerInstallDir(&buf)) {
/* failed; server not installed; use temp directory */
strcpy(ntServerInstallDirLong, gettmpdir());
} else {
strcpy(ntServerInstallDirLong, buf);
free(buf);
initStatus |= AFSDIR_SERVER_PATHS_OK;
}
FilepathNormalize(ntServerInstallDirLong);
status =
GetShortPathName(ntServerInstallDirLong, ntServerInstallDirShort,
AFSDIR_PATH_MAX);
if (status == 0 || status > AFSDIR_PATH_MAX) {
/* can't convert path to short version; just use long version */
strcpy(ntServerInstallDirShort, ntServerInstallDirLong);
}
FilepathNormalize(ntServerInstallDirShort);
/* get the afs client configuration directory (/usr/vice/etc equivalent) */
if (afssw_GetClientCellServDBDir(&buf)) {
/* failed */
status = GetWindowsDirectory(ntClientConfigDirLong, AFSDIR_PATH_MAX);
if (status == 0 || status > AFSDIR_PATH_MAX) {
/* failed to get canonical Windows directory; use temp directory */
strcpy(ntClientConfigDirLong, gettmpdir());
} else {
initStatus |= AFSDIR_CLIENT_PATHS_OK;
}
} else {
strcpy(ntClientConfigDirLong, buf);
free(buf);
initStatus |= AFSDIR_CLIENT_PATHS_OK;
}
FilepathNormalize(ntClientConfigDirLong);
status =
GetShortPathName(ntClientConfigDirLong, ntClientConfigDirShort,
AFSDIR_PATH_MAX);
if (status == 0 || status > AFSDIR_PATH_MAX) {
/* can't convert path to short version; just use long version */
strcpy(ntClientConfigDirShort, ntClientConfigDirLong);
}
FilepathNormalize(ntClientConfigDirShort);
clientPrefix = ntClientConfigDirShort;
/* setup the root server directory path (/usr/afs equivalent) */
strcpy(afsSrvDirPath, ntServerInstallDirShort);
strcat(afsSrvDirPath, AFSDIR_CANONICAL_SERVER_AFS_DIRPATH);
/* there is no root client directory path (/usr/vice equivalent) */
afsClntDirPath[0] = '\0';
/* setup top level dirpath (/usr equivalent); valid for server ONLY */
strcpy(dirPathArray[AFSDIR_USR_DIRPATH_ID], ntServerInstallDirShort);
serverPrefix = ntServerInstallDirShort;
strcat(dirPathArray[AFSDIR_USR_DIRPATH_ID], AFSDIR_CANONICAL_USR_DIRPATH);
#else /* AFS_NT40_ENV */
/* setup the root server directory path */
strcpy(afsSrvDirPath, AFSDIR_CANONICAL_SERVER_AFS_DIRPATH);
/* setup the root client directory path */
#ifdef AFS_DARWIN_ENV
if (access(AFSDIR_ALTERNATE_CLIENT_VICE_DIRPATH, F_OK) == 0)
strcpy(afsClntDirPath, AFSDIR_ALTERNATE_CLIENT_VICE_DIRPATH);
else
#endif
strcpy(afsClntDirPath, AFSDIR_CANONICAL_CLIENT_VICE_DIRPATH);
/* setup top level dirpath; valid for both server and client */
strcpy(dirPathArray[AFSDIR_USR_DIRPATH_ID], AFSDIR_CANONICAL_USR_DIRPATH);
initStatus |= (AFSDIR_CLIENT_PATHS_OK | AFSDIR_SERVER_PATHS_OK);
#endif /* AFS_NT40_ENV */
/* now initialize various dir and file paths exported by dirpath module */
/* server dir paths */
strcpy(dirPathArray[AFSDIR_SERVER_AFS_DIRPATH_ID], afsSrvDirPath);
pathp = dirPathArray[AFSDIR_SERVER_ETC_DIRPATH_ID];
AFSDIR_SERVER_DIRPATH(pathp, AFSDIR_SERVER_ETC_DIR);
pathp = dirPathArray[AFSDIR_SERVER_BIN_DIRPATH_ID];
AFSDIR_SERVER_DIRPATH(pathp, AFSDIR_SERVER_BIN_DIR);
pathp = dirPathArray[AFSDIR_SERVER_CORES_DIRPATH_ID];
AFSDIR_SERVER_DIRPATH(pathp, AFSDIR_CORES_DIR);
pathp = dirPathArray[AFSDIR_SERVER_DB_DIRPATH_ID];
AFSDIR_SERVER_DIRPATH(pathp, AFSDIR_DB_DIR);
pathp = dirPathArray[AFSDIR_SERVER_LOGS_DIRPATH_ID];
AFSDIR_SERVER_DIRPATH(pathp, AFSDIR_LOGS_DIR);
pathp = dirPathArray[AFSDIR_SERVER_LOCAL_DIRPATH_ID];
AFSDIR_SERVER_DIRPATH(pathp, AFSDIR_LOCAL_DIR);
pathp = dirPathArray[AFSDIR_SERVER_BACKUP_DIRPATH_ID];
AFSDIR_SERVER_DIRPATH(pathp, AFSDIR_BACKUP_DIR);
pathp = dirPathArray[AFSDIR_SERVER_MIGRATE_DIRPATH_ID];
AFSDIR_SERVER_DIRPATH(pathp, AFSDIR_MIGR_DIR);
pathp = dirPathArray[AFSDIR_SERVER_BIN_FILE_DIRPATH_ID];
AFSDIR_SERVER_DIRPATH(pathp, AFSDIR_BIN_FILE_DIR);
/* client dir path */
#ifdef AFS_NT40_ENV
strcpy(dirPathArray[AFSDIR_CLIENT_VICE_DIRPATH_ID],
"/NoUsrViceDirectoryOnWindows");
strcpy(dirPathArray[AFSDIR_CLIENT_ETC_DIRPATH_ID],
ntClientConfigDirShort);
#else
strcpy(dirPathArray[AFSDIR_CLIENT_VICE_DIRPATH_ID], afsClntDirPath);
pathp = dirPathArray[AFSDIR_CLIENT_ETC_DIRPATH_ID];
#ifdef AFS_DARWIN_ENV
if (access(AFSDIR_ALTERNATE_CLIENT_ETC_DIR, F_OK) == 0)
AFSDIR_CLIENT_DIRPATH(pathp, AFSDIR_ALTERNATE_CLIENT_ETC_DIR);
else
#endif
AFSDIR_CLIENT_DIRPATH(pathp, AFSDIR_CLIENT_ETC_DIR);
#endif /* AFS_NT40_ENV */
#ifndef AFS_NT40_ENV
pathp = dirPathArray[AFSDIR_CLIENT_DATA_DIRPATH_ID];
#ifdef AFS_DARWIN_ENV
if (access(AFSDIR_ALTERNATE_CLIENT_DATA_DIR, F_OK) == 0)
AFSDIR_CLIENT_DIRPATH(pathp, AFSDIR_ALTERNATE_CLIENT_DATA_DIR);
else
#endif
AFSDIR_CLIENT_DIRPATH(pathp, AFSDIR_DATA_DIR);
#endif
/* server file paths */
pathp = dirPathArray[AFSDIR_SERVER_THISCELL_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_ETC_DIR,
AFSDIR_THISCELL_FILE);
pathp = dirPathArray[AFSDIR_SERVER_RXKAD_KEYTAB_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_ETC_DIR, AFSDIR_RXKAD_KEYTAB_FILE);
pathp = dirPathArray[AFSDIR_SERVER_CELLSERVDB_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_ETC_DIR,
AFSDIR_CELLSERVDB_FILE);
pathp = dirPathArray[AFSDIR_SERVER_NOAUTH_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_NOAUTH_FILE);
pathp = dirPathArray[AFSDIR_SERVER_BUDBLOG_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_BUDBLOG_FILE);
pathp = dirPathArray[AFSDIR_SERVER_TAPECONFIG_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_BACKUP_DIR, AFSDIR_TAPECONFIG_FILE);
pathp = dirPathArray[AFSDIR_SERVER_KALOGDB_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_KALOGDB_FILE);
pathp = dirPathArray[AFSDIR_SERVER_KALOG_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_KALOG_FILE);
pathp = dirPathArray[AFSDIR_SERVER_KADB_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_DB_DIR, AFSDIR_KADB_FILE);
pathp = dirPathArray[AFSDIR_SERVER_NTPD_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_BIN_DIR, AFSDIR_NTPD_FILE);
pathp = dirPathArray[AFSDIR_SERVER_PRDB_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_DB_DIR, AFSDIR_PRDB_FILE);
pathp = dirPathArray[AFSDIR_SERVER_PTLOG_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_PTLOG_FILE);
pathp = dirPathArray[AFSDIR_SERVER_KCONF_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_ETC_DIR, AFSDIR_KCONF_FILE);
pathp = dirPathArray[AFSDIR_SERVER_VLDB_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_DB_DIR, AFSDIR_VLDB_FILE);
pathp = dirPathArray[AFSDIR_SERVER_VLOG_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_VLOG_FILE);
pathp = dirPathArray[AFSDIR_SERVER_CORELOG_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_CORE_FILE);
pathp = dirPathArray[AFSDIR_SERVER_SLVGLOG_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_SLVGLOG_FILE);
pathp = dirPathArray[AFSDIR_SERVER_SALSRVLOG_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_SALSRVLOG_FILE);
pathp = dirPathArray[AFSDIR_SERVER_SALVAGER_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_BIN_DIR,
AFSDIR_SALVAGER_FILE);
pathp = dirPathArray[AFSDIR_SERVER_SALSRV_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_BIN_DIR,
AFSDIR_SALSRV_FILE);
pathp = dirPathArray[AFSDIR_SERVER_SLVGLOCK_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_SLVGLOCK_FILE);
pathp = dirPathArray[AFSDIR_SERVER_KEY_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_ETC_DIR, AFSDIR_KEY_FILE);
pathp = dirPathArray[AFSDIR_SERVER_ULIST_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_ETC_DIR, AFSDIR_ULIST_FILE);
pathp = dirPathArray[AFSDIR_SERVER_BOZCONF_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_BOSCONFIG_DIR, AFSDIR_BOZCONF_FILE);
pathp = dirPathArray[AFSDIR_SERVER_BOZCONFNEW_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_BOSCONFIG_DIR,
AFSDIR_BOZCONFNEW_FILE);
pathp = dirPathArray[AFSDIR_SERVER_BOZLOG_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_BOZLOG_FILE);
pathp = dirPathArray[AFSDIR_SERVER_BOZINIT_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_BOSCONFIG_DIR, AFSDIR_BOZINIT_FILE);
pathp = dirPathArray[AFSDIR_SERVER_BOZRXBIND_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_BOSCONFIG_DIR, AFSDIR_BOZRXBIND_FILE);
pathp = dirPathArray[AFSDIR_SERVER_BOSVR_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_BOSSERVER_DIR, AFSDIR_BOSVR_FILE);
pathp = dirPathArray[AFSDIR_SERVER_VOLSERLOG_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_VOLSERLOG_FILE);
pathp = dirPathArray[AFSDIR_SERVER_ROOTVOL_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_ETC_DIR, AFSDIR_ROOTVOL_FILE);
pathp = dirPathArray[AFSDIR_SERVER_HOSTDUMP_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_HOSTDUMP_FILE);
pathp = dirPathArray[AFSDIR_SERVER_CLNTDUMP_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_CLNTDUMP_FILE);
pathp = dirPathArray[AFSDIR_SERVER_CBKDUMP_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_CBKDUMP_FILE);
pathp = dirPathArray[AFSDIR_SERVER_OLDSYSID_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_OLDSYSID_FILE);
pathp = dirPathArray[AFSDIR_SERVER_SYSID_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_SYSID_FILE);
pathp = dirPathArray[AFSDIR_SERVER_FILELOG_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_FILELOG_FILE);
pathp = dirPathArray[AFSDIR_SERVER_AUDIT_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_AUDIT_FILE);
pathp = dirPathArray[AFSDIR_SERVER_NETINFO_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_NETINFO_FILE);
pathp = dirPathArray[AFSDIR_SERVER_NETRESTRICT_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_NETRESTRICT_FILE);
pathp = dirPathArray[AFSDIR_SERVER_KRB_EXCL_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_ETC_DIR, AFSDIR_KRB_EXCL_FILE);
pathp = dirPathArray[AFSDIR_SERVER_FSSTATE_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_FSSTATE_FILE);
pathp = dirPathArray[AFSDIR_SERVER_OSDDB_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_DB_DIR, AFSDIR_OSDDB_FILE);
pathp = dirPathArray[AFSDIR_SERVER_OSDDBLOG_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_OSDDB_LOGNAME);
pathp = dirPathArray[AFSDIR_SERVER_RXOSDLOG_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_RXOSD_LOGNAME);
pathp = dirPathArray[AFSDIR_SERVER_RXOSD_FETCHQ_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOCAL_DIR, AFSDIR_RXOSD_FETCHQ_FILE);
pathp = dirPathArray[AFSDIR_SERVER_RECALL_MIGRATED_FILE_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_SERVER_BIN_DIR, AFSDIR_RECALL_MIGRATED_FILE_FILE);
pathp = dirPathArray[AFSDIR_SERVER_RECALLLOG_FILEPATH_ID];
AFSDIR_SERVER_FILEPATH(pathp, AFSDIR_LOGS_DIR, AFSDIR_RECALL_LOGNAME);
/* client file paths */
#ifdef AFS_NT40_ENV
strcpy(dirPathArray[AFSDIR_CLIENT_THISCELL_FILEPATH_ID],
"/NoUsrViceEtcThisCellFileOnWindows");
sprintf(dirPathArray[AFSDIR_CLIENT_CELLSERVDB_FILEPATH_ID], "%s/%s",
ntClientConfigDirShort, AFSDIR_CELLSERVDB_FILE_NTCLIENT);
strcpy(dirPathArray[AFSDIR_CLIENT_CELLALIAS_FILEPATH_ID],
"/NoCellAliasOnWindows");
#else
pathp = dirPathArray[AFSDIR_CLIENT_THISCELL_FILEPATH_ID];
AFSDIR_CLIENT_FILEPATH(pathp, AFSDIR_CLIENT_ETC_DIR,
AFSDIR_THISCELL_FILE);
pathp = dirPathArray[AFSDIR_CLIENT_CELLSERVDB_FILEPATH_ID];
AFSDIR_CLIENT_FILEPATH(pathp, AFSDIR_CLIENT_ETC_DIR,
AFSDIR_CELLSERVDB_FILE);
pathp = dirPathArray[AFSDIR_CLIENT_CELLALIAS_FILEPATH_ID];
AFSDIR_CLIENT_FILEPATH(pathp, AFSDIR_CLIENT_ETC_DIR,
AFSDIR_CELLALIAS_FILE);
#endif /* AFS_NT40_ENV */
pathp = dirPathArray[AFSDIR_CLIENT_NETINFO_FILEPATH_ID];
AFSDIR_CLIENT_FILEPATH(pathp, AFSDIR_CLIENT_ETC_DIR, AFSDIR_NETINFO_FILE);
pathp = dirPathArray[AFSDIR_CLIENT_NETRESTRICT_FILEPATH_ID];
AFSDIR_CLIENT_FILEPATH(pathp, AFSDIR_CLIENT_ETC_DIR,
AFSDIR_NETRESTRICT_FILE);
initFlag = 1; /* finished dirpath initialization */
return;
}