src/WINNT/afssvrcfg/afscfg.cpp

   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 /*
  11  * INCLUDES _________________________________________________________________
  12  *
  13  */
  14
  15 extern "C" {
  16 #include <afs/param.h>
  17 #include <afs/stds.h>
  18 }
  19
  20 #include "afscfg.h"
  21 #include "resource.h"
  22 #include "graphics.h"
  23 #include <string.h>
  24 #include "get_cur_config.h"
  25 #include "partition_utils.h"
  26 extern "C" {
  27 #include <afs\dirpath.h>
  28 #include <afs\afs_clientAdmin.h>
  29 }
  30
  31
  32 /*
  33  * DEFINITIONS _________________________________________________________________
  34  *
  35  */
  36
  37
  38 /*
  39  * PROTOTYPES _________________________________________________________________
  40  *
  41  */
  42 static void SetConfigDefaults();
  43 static void RunCfgTool();
  44 static void RunWizard();
  45 static void CloseLibHandles(BOOL bExiting = FALSE);
  46
  47 void RegisterWizardHelp();
  48 void RegisterConfigToolHelp();
  49
  50 // These are the prototypes for the dialog procs of each wizard page.
  51 BOOL CALLBACK IntroPageDlgProc(HWND hRHS, UINT msg, WPARAM wp, LPARAM lp);
  52 BOOL CALLBACK InfoPageDlgProc(HWND hwndDlg, UINT msg, WPARAM wp, LPARAM lp);
  53 BOOL CALLBACK InfoPage2DlgProc(HWND hRHS, UINT msg, WPARAM wp, LPARAM lp);
  54 BOOL CALLBACK FileServerPageDlgProc(HWND hwndDlg, UINT msg, WPARAM wp, LPARAM lp);
  55 BOOL CALLBACK DBServerPageDlgProc(HWND hwndDlg, UINT msg, WPARAM wp, LPARAM lp);
  56 BOOL CALLBACK BackupPageDlgProc(HWND hwndDlg, UINT msg, WPARAM wp, LPARAM lp);
  57 BOOL CALLBACK PartitionPageDlgProc(HWND hwndDlg, UINT msg, WPARAM wp, LPARAM lp);
  58 BOOL CALLBACK RootAfsPageDlgProc(HWND hwndDlg, UINT msg, WPARAM wp, LPARAM lp);
  59 BOOL CALLBACK ReplicationPageDlgProc(HWND hwndDlg, UINT msg, WPARAM wp, LPARAM lp);
  60 BOOL CALLBACK SysControlPageDlgProc(HWND hwndDlg, UINT msg, WPARAM wp, LPARAM lp);
  61 BOOL CALLBACK ConfigServerPageDlgProc(HWND hwndDlg, UINT msg, WPARAM wp, LPARAM lp);
  62
  63
  64 static WIZARD_STATE g_aStates[] = {
  65     { sidSTEP_ONE,              IDD_INTRO_PAGE,                                 (DLGPROC)IntroPageDlgProc, 0 },
  66     { sidSTEP_TWO,              IDD_INFO_PAGE,                                  (DLGPROC)InfoPageDlgProc, 0 },
  67     { sidSTEP_THREE,    IDD_INFO_PAGE2_FIRST_SERVER,    (DLGPROC)InfoPage2DlgProc, 0 },
  68         { sidSTEP_FOUR,         IDD_INFO_PAGE2_NOT_FIRST_SERVER,(DLGPROC)InfoPage2DlgProc, 0 },
  69     { sidSTEP_FIVE,             IDD_FILE_SERVER_PAGE,                   (DLGPROC)FileServerPageDlgProc, 0 },
  70     { sidSTEP_SIX,              IDD_DB_SERVER_PAGE,                             (DLGPROC)DBServerPageDlgProc, 0 },
  71         { sidSTEP_SEVEN,        IDD_BACKUP_SERVER_PAGE,                 (DLGPROC)BackupPageDlgProc, 0 },
  72     { sidSTEP_EIGHT,    IDD_PARTITION_PAGE,                             (DLGPROC)PartitionPageDlgProc, 0 },
  73         { sidSTEP_NINE,         IDD_ROOT_VOLUMES_PAGE,                  (DLGPROC)RootAfsPageDlgProc, 0 },
  74         { sidSTEP_TEN,          IDD_REPLICATION_PAGE,                   (DLGPROC)ReplicationPageDlgProc, 0 },
  75         { sidSTEP_ELEVEN,       IDD_SYS_CONTROL_PAGE,                   (DLGPROC)SysControlPageDlgProc, 0 },
  76         { sidSTEP_TWELVE,       IDD_CONFIG_SERVER_PAGE,                 (DLGPROC)ConfigServerPageDlgProc, 0 }
  77 };
  78
  79 size_t g_nNumStates = sizeof(g_aStates) / sizeof(g_aStates[0]);
  80
  81
  82 // Res ID's of text descriptions of each state
  83 UINT g_StateDesc[] = {
  84         IDS_INTRO_PAGE,
  85         IDS_INFO_PAGE,
  86         IDS_INFO_PAGE2,
  87         IDS_INFO_PAGE2,
  88         IDS_FS_PAGE,
  89         IDS_DB_PAGE,
  90         IDS_BK_PAGE,
  91         IDS_PARTITION_PAGE,
  92         IDS_ROOT_AFS_PAGE,
  93         IDS_REP_PAGE,
  94         IDS_SC_PAGE,
  95         IDS_CONFIG_PAGE
  96 };
  97
  98
  99
 100 /*
 101  * EXPORTED VARIABLES _________________________________________________________________
 102  *
 103  */
 104 LPWIZARD g_pWiz = NULL;
 105 LPPROPSHEET g_pSheet = NULL;
 106
 107 CFG_DATA g_CfgData;
 108
 109 void *g_hToken = 0;
 110 void *g_hCell = 0;
 111 void *g_hClient = 0;
 112 void *g_hServer = 0;
 113
 114 static void *hClientCell = 0;
 115
 116 LOGFILE g_LogFile;
 117
 118
 119
 120 /*
 121  * EXPORTED FUNCTIONS _________________________________________________________________
 122  *
 123  */
 124 int WINAPI WinMain (HINSTANCE hInst, HINSTANCE hPrev, LPSTR pszCmdLineA, int nCmdShow)
 125 {
 126         afs_status_t nStatus;
 127
 128         TaLocale_LoadCorrespondingModule (hInst);
 129
 130         // Tell the applib our application's name
 131         TCHAR szAppName[cchRESOURCE];
 132         AfsAppLib_SetAppName(GetResString(GetAppTitleID(), szAppName));
 133
 134         // Open the admin libraries
 135         int nResult = afsclient_Init(&nStatus);
 136         if (!nResult) {
 137                 ShowError(0, nStatus, IDS_CANT_INIT_ADMIN_LIBS);
 138                 return 0;
 139         }
 140
 141         // Open the log file
 142         char szLogPath[MAX_PATH];
 143         sprintf(szLogPath, "%s\\%s", AFSDIR_SERVER_LOGS_DIRPATH, LOG_FILE_NAME);
 144         if (!g_LogFile.Open(szLogPath))
 145                 ShowError(0, 0, IDS_CANT_OPEN_LOG_FILE);
 146
 147         // Register the help file with the applib's help system
 148         AfsAppLib_RegisterHelpFile(TEXT("TaAfsCfg.hlp"));
 149
 150     /* Start up sockets */
 151     WSADATA WSAjunk;
 152     WSAStartup(0x0101, &WSAjunk);
 153
 154         memset(&g_CfgData, 0, sizeof(CFG_DATA));
 155
 156         // Get this machine's local name
 157         char szLocalName[sizeof(g_CfgData.szLocalName) / sizeof(TCHAR)];
 158     if (gethostname(szLocalName, sizeof(szLocalName)) != 0) {
 159                 ShowError(GetFocus(), WSAGetLastError(), IDS_ERROR_LOCAL_HOST_NAME);
 160                 return 0;
 161         }
 162     CopyAnsiToString(g_CfgData.szLocalName, szLocalName);
 163
 164         // Turn the local name into a host name
 165     struct hostent *pHostEnt = gethostbyname(szLocalName);
 166     if (!pHostEnt) {
 167                 ShowError(GetFocus(), WSAGetLastError(), IDS_ERROR_HOST_NAME);
 168                 return 0;
 169         }
 170     CopyAnsiToString(g_CfgData.szHostname, pHostEnt->h_name, sizeof(g_CfgData.szHostname));
 171
 172         RegisterFastListClass();
 173
 174         // Get current config status
 175         BOOL bCanceled = FALSE;
 176         DWORD dwStatus = GetCurrentConfig(NULL, bCanceled);
 177         if (dwStatus || bCanceled) {
 178                 if (!bCanceled)
 179                 ShowError(GetFocus(), dwStatus, IDS_CONFIG_CHECK_FAILED);
 180                 return 0;
 181         }
 182
 183     // Check the version of the client.  It must be at least 35.
 184     if (g_CfgData.nClientVersion < 35) {
 185         int nMajor, nMinor;
 186         nMajor = g_CfgData.nClientVersion / 10;
 187         nMinor = g_CfgData.nClientVersion - (nMajor * 10);
 188         g_LogFile.Write("The version of the AFS Client on this machine (%d.%d) is too old to run the server.  The Client must be at least version 3.5.\r\n", nMajor, nMinor);
 189                 ErrorDialog(0, IDS_ERROR_CLIENT_VERSION);
 190         return 0;
 191     }
 192
 193         // Run the appropriate interface
 194         if ((strstr(_strlwr(pszCmdLineA), "wizard") != 0))
 195                 RunWizard();
 196         else
 197                 RunCfgTool();
 198
 199         FreePartitionTable();
 200
 201         // Disconnect from the config and admin libraries
 202         CloseLibHandles(TRUE);
 203
 204         return 0;
 205 }
 206
 207 /*
 208  *      This is a dialog proc that is shared by all of the wizard pages.  It
 209  *      handles things that are common to all of them.  Each page also has its
 210  *      own dialog proc.
 211  */
 212 BOOL CALLBACK WizStep_Common_DlgProc(HWND hRHS, UINT msg, WPARAM wp, LPARAM lp)
 213 {
 214         // Get the dialog's resource ID
 215         int nIDD = GetWindowLong(hRHS, GWL_ID);
 216
 217         if (AfsAppLib_HandleHelp(nIDD, hRHS, msg, wp, lp))
 218                 return TRUE;
 219
 220         switch (msg) {
 221                 case WM_INITDIALOG:     MakeBold(hRHS, IDC_TITLE);
 222                                                         RedrawGraphic();
 223                                                         break;
 224
 225                 case WM_COMMAND:
 226                         switch (LOWORD(wp)) {
 227                                 case IDCANCEL:
 228                                         QueryCancelWiz();
 229                                         return TRUE;
 230                         }
 231                         break;
 232         }
 233
 234         return FALSE;
 235 }
 236
 237 BOOL QueryCancelWiz()
 238 {
 239         int nChoice = Message(MB_YESNO, IDS_WIZARD_APP_TITLE, IDS_CANCEL_DESC);
 240         if (nChoice == IDYES) {
 241                 g_LogFile.Write("User has chosen to cancel the program.\r\n");
 242                 if (g_pWiz)
 243                         g_pWiz->Show(FALSE);
 244                 return TRUE;
 245         }
 246
 247         return FALSE;
 248 }
 249
 250
 251 /*
 252  *  Accessor functions for the g_CfgData variable.  There are versions
 253  *  for both TCHARs and char *'s.
 254  */
 255 TCHAR GetDeviceName()           { return g_CfgData.chDeviceName; }
 256 LPTSTR GetPartitionName()       { return g_CfgData.szPartitionName; }
 257 LPTSTR GetHostName()            { return g_CfgData.szHostname; }
 258 LPTSTR GetSysControlMachine()   { return g_CfgData.szSysControlMachine; }
 259 LPTSTR GetCellName()            { return g_CfgData.szCellName; }
 260 LPTSTR GetServerPW()            { return g_CfgData.szServerPW; }
 261 LPTSTR GetAdminName()           { return g_CfgData.szAdminName; }
 262 LPTSTR GetAdminPW()             { return g_CfgData.szAdminPW; }
 263 LPTSTR GetAdminUID()            { return g_CfgData.szAdminUID; }
 264 LPTSTR GetLocalName()           { return g_CfgData.szLocalName; }
 265 LPTSTR GetHostname()            { return g_CfgData.szHostname; }
 266 LPTSTR GetCellServDbHostname()  { return g_CfgData.szCellServDbHostname; }
 267 LPTSTR GetClientCellName()      { return g_CfgData.szClientCellName; }
 268 LPTSTR GetSalvageLogFileName()  { return g_CfgData.szSalvageLogFileName; }
 269
 270 LPTSTR GetClientNetbiosName()
 271 {
 272     static TCHAR szValue[MAX_MACHINE_NAME_LEN + 1];
 273
 274     lstrcpy(szValue, g_CfgData.szLocalName);
 275
 276     szValue[11] = TEXT('\0');
 277
 278     for (LPTSTR pch = szValue; *pch != TEXT('\0'); pch++) {
 279         if (*pch == TEXT('.')) {
 280             *pch = TEXT('\0');
 281             break;
 282         }
 283     }
 284     lstrcat(szValue, TEXT("-AFS"));
 285
 286     return szValue;
 287 }
 288
 289 char GetDeviceNameA()
 290 {
 291     static char szValueA[2];
 292
 293     TCHAR devName[2] = TEXT("X");
 294     devName[0] = g_CfgData.chDeviceName;
 295
 296     CopyStringToAnsi(szValueA, devName);
 297
 298     return szValueA[0];
 299 }
 300
 301 char *GetPartitionNameA()
 302 {
 303     static char szValueA[MAX_PARTITION_NAME_LEN + 1];
 304
 305     CopyStringToAnsi(szValueA, g_CfgData.szPartitionName);
 306
 307     return szValueA;
 308 }
 309
 310 char *GetSysControlMachineA()
 311 {
 312     static char szValueA[MAX_MACHINE_NAME_LEN + 1];
 313
 314     CopyStringToAnsi(szValueA, g_CfgData.szSysControlMachine);
 315
 316     return szValueA;
 317 }
 318
 319 char *GetCellNameA()
 320 {
 321     static char szValueA[MAX_CELL_NAME_LEN + 1];
 322
 323     CopyStringToAnsi(szValueA, g_CfgData.szCellName);
 324
 325     return szValueA;
 326 }
 327
 328 char *GetServerPWA()
 329 {
 330     static char szValueA[MAX_SERVER_PW_LEN + 1];
 331
 332     CopyStringToAnsi(szValueA, g_CfgData.szServerPW);
 333
 334     return szValueA;
 335 }
 336
 337 char *GetAdminNameA()
 338 {
 339     static char szValueA[MAX_ADMIN_NAME_LEN + 1];
 340
 341     CopyStringToAnsi(szValueA, g_CfgData.szAdminName);
 342
 343     return szValueA;
 344 }
 345
 346 char *GetAdminPWA()
 347 {
 348     static char szValueA[MAX_ADMIN_PW_LEN + 1];
 349
 350     CopyStringToAnsi(szValueA, g_CfgData.szAdminPW);
 351
 352     return szValueA;
 353 }
 354
 355 char *GetAdminUIDA()
 356 {
 357     static char szValueA[MAX_UID_LEN + 1];
 358
 359     CopyStringToAnsi(szValueA, g_CfgData.szAdminUID);
 360
 361     return szValueA;
 362 }
 363
 364 char *GetLocalNameA()
 365 {
 366     static char szValueA[MAX_MACHINE_NAME_LEN + 1];
 367
 368     CopyStringToAnsi(szValueA, g_CfgData.szLocalName);
 369
 370     return szValueA;
 371 }
 372
 373 char *GetHostnameA()
 374 {
 375     static char szValueA[MAX_MACHINE_NAME_LEN + 1];
 376
 377     CopyStringToAnsi(szValueA, g_CfgData.szHostname);
 378
 379     return szValueA;
 380 }
 381
 382 char *GetCellServDbHostnameA()
 383 {
 384     static char szValueA[MAX_MACHINE_NAME_LEN + 1];
 385
 386     CopyStringToAnsi(szValueA, g_CfgData.szCellServDbHostname);
 387
 388     return szValueA;
 389 }
 390
 391 char *GetClientCellNameA()
 392 {
 393     static char szValueA[MAX_CELL_NAME_LEN + 1];
 394
 395     CopyStringToAnsi(szValueA, g_CfgData.szClientCellName);
 396
 397     return szValueA;
 398 }
 399
 400 char *GetClientNetbiosNameA()
 401 {
 402     static char szValueA[MAX_MACHINE_NAME_LEN + 1];
 403     char *dotp;
 404
 405     CopyStringToAnsi(szValueA, g_CfgData.szLocalName);
 406
 407     szValueA[11] = '\0';
 408
 409     if ((dotp = strchr(szValueA, '.')) != NULL) {
 410         *dotp = '\0';
 411     }
 412     strcat(szValueA, "-AFS");
 413
 414     return szValueA;
 415 }
 416
 417 char *GetSalvageLogFileNameA()
 418 {
 419     static char szValueA[_MAX_PATH];
 420
 421     CopyStringToAnsi(szValueA, g_CfgData.szSalvageLogFileName);
 422
 423     return szValueA;
 424 }
 425
 426
 427 BOOL GetLibHandles(afs_status_t *pStatus)
 428 {
 429         ASSERT(g_CfgData.szHostname[0]);
 430
 431         int nResult;
 432
 433         // ************************* NOTE ********************************
 434         // * You MUST have already determined whether or not the host
 435         // * and client config info is valid before calling this function.
 436         // ***************************************************************
 437
 438         // This function can be called at any time to get handles to the cell and
 439         // the config library.  It will try to get the most powerful handle to the
 440         // cell that it can, and then use that to open the config library.  If the
 441         // libraries are already open, it will close them first.  Two handles to
 442         // the config library will be opened, one to the server to be configured,
 443         // and one to the client machine we are configuring from.
 444
 445         // There are two types of cell handles, NULL and Standard.  A null handle
 446         // can make calls to any server except DB servers.  We need this primarily
 447         // to talk to the bos server to determine the machine's current configuration,
 448         // and to configure the client information if it is not already.  A standard
 449         // handle can talk to any server.  Standard handles can be either authenticated
 450         // or unauthenticated.
 451
 452         // Close all current handles
 453         CloseLibHandles();
 454
 455         g_LogFile.Write("Getting handles to the cell and the config library.\r\n");
 456
 457     if (!hClientCell) {
 458         // Start by getting a null cell handle and using it to open the client
 459         // connection to the config library.
 460         g_LogFile.Write("Opening a NULL cell handle to use with the client config library handle.\r\n");
 461         nResult = afsclient_NullCellOpen(&hClientCell, pStatus);
 462         if (!nResult) {
 463             g_LogFile.Write("Failed to open a NULL cell handle: %lx.\r\n", (unsigned long)*pStatus);
 464                 return FALSE;
 465         }
 466
 467         // Get the client handle.  We never need a better handle than this
 468         // for the client, and so this handle will never be upgraded.
 469         g_LogFile.Write("Getting config handle for the client.\r\n");
 470         if (!cfg_HostOpen(hClientCell, GetHostnameA(), &g_hClient, pStatus)) {
 471             g_LogFile.Write("Failed to get config handle:  %lx.\r\n", (unsigned long)*pStatus);
 472                 return FALSE;
 473         }
 474     }
 475
 476         // Now we need to get the most powerful cell handle that we can and use it
 477         // to open the config library for the server.
 478
 479         // If the client info is valid and we know what cell the server should be in,
 480         // and the client has that cell in its CellServDB, then we can get a Standard cell
 481         // handle.  However there is an exception: if this is the first server in the
 482         // cell then there may not yet be an authentication server to talk to.  In that
 483         // case we use a null cell handle.
 484     if (g_CfgData.bValidClientInfo &&   // Client config is valid
 485         g_CfgData.szCellName[0] &&      // We have a cell name
 486         (!g_CfgData.bFirstServer || g_CfgData.bAuthServerRunning))  // Auth server is running
 487     {
 488                 g_LogFile.Write("Opening a non-NULL cell handle to use with the server config library handle.\r\n");
 489
 490         // Do we have the user info necessary to authenticate?
 491         BOOL bHaveUserInfo = g_CfgData.szAdminName[0] && g_CfgData.szAdminPW[0];
 492
 493                 // Open a standard cell handle.  szAdminName and szAdminPW will either be NULL, or
 494                 // if they have been entered by the user, will be the admin name and password strings.
 495                 if ((!g_CfgData.bFirstServer || g_CfgData.bAdminPrincipalCreated) && bHaveUserInfo) {
 496                         g_LogFile.Write("Getting tokens in cell %s for user '%s'.\r\n", GetCellNameA(), GetAdminNameA());
 497                         nResult = afsclient_TokenGetNew(GetCellNameA(), GetAdminNameA(), GetAdminPWA(), &g_hToken, pStatus);
 498                 } else {
 499                         g_LogFile.Write("Getting unauthenticated tokens for cell '%s'.\r\n", GetCellNameA());
 500                         nResult = afsclient_TokenGetNew(GetCellNameA(), "", "", &g_hToken, pStatus);
 501                 }
 502
 503                 if (!nResult) {
 504                         g_LogFile.Write("Failed to get tokens for the specified cell:  %lx.\r\n", (unsigned long)*pStatus);
 505                         return FALSE;
 506                 }
 507
 508                 // If the admin name and password are NULL, then this will be an unauthenticated
 509                 // connection to the cell.
 510                 g_LogFile.Write("Getting cell handle for cell %s.\r\n", GetCellNameA());
 511                 nResult = afsclient_CellOpen(GetCellNameA(), g_hToken, &g_hCell, pStatus);
 512                 if (!nResult) {
 513             g_LogFile.Write("Failed to open the cell:  %lx.\r\n", (unsigned long)*pStatus);
 514                         return FALSE;
 515                 }
 516         } else {
 517         g_LogFile.Write("Opening a NULL cell handle to use with the server config library handle.\r\n");
 518         nResult = afsclient_NullCellOpen(&g_hCell, pStatus);
 519         if (!nResult) {
 520             g_LogFile.Write("Failed to open a NULL cell handle:  %lx.\r\n", (unsigned long)*pStatus);
 521                 return FALSE;
 522         }
 523     }
 524
 525         // Get the server handle
 526         g_LogFile.Write("Getting config library handle for the server.\r\n");
 527         if (!cfg_HostOpen(g_hCell, GetHostnameA(), &g_hServer, pStatus)) {
 528         g_LogFile.Write("Failed to get config library handle for the server:  %lx.\r\n", (unsigned long)*pStatus);
 529                 return FALSE;
 530         }
 531
 532         return TRUE;
 533 }
 534
 535 BOOL GetHandles(HWND hParentDlg)
 536 {
 537     afs_status_t nStatus;
 538
 539     if (!GetLibHandles(&nStatus)) {
 540         ShowError(hParentDlg, nStatus, IDS_GET_TOKENS_ERROR);
 541         g_CfgData.szAdminPW[0] = 0;
 542         return FALSE;
 543     }
 544
 545     return TRUE;
 546 }
 547
 548
 549 /*
 550  * Static FUNCTIONS _________________________________________________________________
 551  *
 552  */
 553 static void CloseLibHandles(BOOL bExiting)
 554 {
 555      afs_status_t nStatus;
 556
 557         // We will close them in the reverse order of their creation.
 558
 559         if (g_hServer) {
 560                 cfg_HostClose(g_hServer, &nStatus);
 561                 g_hServer = 0;
 562         }
 563
 564         if (g_hCell) {
 565                 afsclient_CellClose(g_hCell, &nStatus);
 566                 g_hCell = 0;
 567         }
 568
 569         if (g_hToken) {
 570                 afsclient_TokenClose(g_hToken, &nStatus);
 571                 g_hToken = 0;
 572         }
 573
 574     // Only close the client cfg and cell handles if we are exiting.
 575         if (bExiting) {
 576         if (g_hClient) {
 577                 cfg_HostClose(g_hClient, &nStatus);
 578                 g_hClient = 0;
 579         }
 580
 581         if (hClientCell) {
 582                 afsclient_CellClose(hClientCell, &nStatus);
 583                 hClientCell = 0;
 584         }
 585     }
 586 }
 587
 588 static void SetConfigDefaults()
 589 {
 590         if (g_CfgData.bWizard) {
 591                 if (g_CfgData.configFS == CS_NULL)
 592                         g_CfgData.configFS = CS_CONFIGURE;
 593
 594                 if (g_CfgData.configDB == CS_NULL)
 595                         g_CfgData.configDB = CS_CONFIGURE;
 596
 597                 if (g_CfgData.configBak == CS_NULL)
 598                         g_CfgData.configBak = CS_CONFIGURE;
 599
 600                 if (g_CfgData.configPartition == CS_NULL)
 601                         g_CfgData.configPartition = CS_CONFIGURE;
 602
 603                 if (g_CfgData.configRootVolumes == CS_NULL)
 604                         g_CfgData.configRootVolumes = CS_CONFIGURE;
 605
 606                 if (g_CfgData.configRep == CS_NULL)
 607                         g_CfgData.configRep = CS_CONFIGURE;
 608
 609                 if (g_CfgData.configSCS == CS_NULL)
 610                         g_CfgData.configSCS = CS_DONT_CONFIGURE;
 611
 612                 if (g_CfgData.configSCC == CS_NULL)
 613                         g_CfgData.configSCC = CS_DONT_CONFIGURE;
 614         }
 615
 616         lstrcpy(g_CfgData.szAdminName, TEXT("admin"));
 617         lstrcpy(g_CfgData.szAdminUID, TEXT("0"));
 618
 619         g_CfgData.bUseNextUid = TRUE;
 620 }
 621
 622
 623 // Prototypes for each property page's dialog proc
 624 BOOL CALLBACK PartitionsPageDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
 625 BOOL CALLBACK ServicesPageDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
 626
 627 static void RunCfgTool()
 628 {
 629         // If the client info is invalid, then the config tool cannot run.  Inform the user and
 630         // ask if they want to run the wizard instead.
 631         if (!g_CfgData.bValidClientInfo) {
 632                 int nChoice = MsgBox(0, IDS_NEED_CLIENT_INFO, GetAppTitleID(), MB_YESNO | MB_ICONSTOP);
 633                 if (nChoice == IDYES)
 634                         RunWizard();
 635                 return;
 636         }
 637
 638         // If the server info is invalid, then the config tool cannot run.  The Wizard must be run
 639         // to initially configure the server.  Inform the user and ask if they want to run the wizard instead.
 640         if (!g_CfgData.bValidServerInfo) {
 641                 int nChoice = MsgBox(0, IDS_NEED_SERVER_INFO, GetAppTitleID(), MB_OKCANCEL | MB_ICONEXCLAMATION);
 642                 if (nChoice == IDOK)
 643                         RunWizard();
 644                 return;
 645         }
 646
 647         g_CfgData.bWizard = FALSE;
 648
 649         SetConfigDefaults();
 650
 651         RegisterConfigToolHelp();
 652
 653         // Create the prop sheet
 654         g_pSheet = PropSheet_Create(IDS_CFG_TOOL_APP_TITLE, TRUE);
 655
 656         // Add the pages
 657         PropSheet_AddTab(g_pSheet, IDS_PARTITIONS_PAGE_TITLE, IDD_PARTITIONS_PAGE, (DLGPROC)PartitionsPageDlgProc, 0, TRUE, TRUE);
 658         PropSheet_AddTab(g_pSheet, IDS_SERVICES_PAGE_TITLE, IDD_SERVICES_PAGE, (DLGPROC)ServicesPageDlgProc, 0, TRUE);
 659
 660         // Let the user see it
 661         PropSheet_ShowModal(g_pSheet);
 662 }
 663
 664 static void RunWizard()
 665 {
 666         g_CfgData.bWizard = TRUE;
 667
 668     SetConfigDefaults();
 669
 670         RegisterWizardHelp();
 671
 672         g_pWiz = new WIZARD;
 673         g_pWiz->SetDialogTemplate(IDD_WIZARD, IDC_WIZARD_LEFTPANE, IDC_WIZARD_RIGHTPANE, IDBACK, IDNEXT);
 674         g_pWiz->SetGraphic(IDB_GRAPHIC_16, IDB_GRAPHIC_256);
 675         g_pWiz->SetStates(g_aStates, g_nNumStates);
 676         g_pWiz->SetGraphicCallback(PaintPageGraphic);
 677
 678         g_pWiz->SetState(sidSTEP_ONE);
 679         g_pWiz->Show();
 680
 681         delete g_pWiz;
 682
 683         g_pWiz = 0;
 684 }
 685