// Copyright (c) 1997-1999 Microsoft Corporation
//
// domain controller promotion wizard, Mark II
//
// 12-12-97 sburns



#include "headers.hxx"
#include "common.hpp"
#include "adpass.hpp"
#include "BadComputerNameDialog.hpp"
#include "CheckPortAvailability.hpp"
#include "ChildPage.hpp"
#include "CredentialsPage.hpp"
#include "ConfirmationPage.hpp"
#include "DemotePage.hpp"
#include "DynamicDnsPage.hpp"
#include "ConfigureDnsClientPage.hpp"
#include "DnsOnNetPage.hpp"
#include "FailurePage.hpp"
#include "finish.hpp"
#include "ForestPage.hpp"
#include "ForestVersionPage.hpp"
#include "GcConfirmationPage.hpp"
#include "NetbiosNamePage.hpp"
#include "NewDomainPage.hpp"
#include "NewSitePage.hpp"
#include "NonDomainNc.hpp"
#include "NonRfcComputerNameDialog.hpp"
#include "PathsPage.hpp"
#include "Paths2Page.hpp"
#include "PickSitePage.hpp"
#include "rasfixup.hpp"
#include "RebootDialog.hpp"
#include "ReplicaOrNewDomainPage.hpp"
#include "ReplicateFromMediaPage.hpp"
#include "ReplicaPage.hpp"
#include "ReplicaOrMemberPage.hpp"
#include "resource.h"
#include "safemode.hpp"
#include "state.hpp"
#include "InstallTcpIpPage.hpp"
#include "TreePage.hpp"
#include "WelcomePage.hpp"



HINSTANCE hResourceModuleHandle = 0;
const wchar_t* HELPFILE_NAME = 0;   // no context help available



// don't change this: it is also the name of a mutex that the net id ui
// uses to determine if dcpromo is running.

const wchar_t* RUNTIME_NAME = L"dcpromoui";

DWORD DEFAULT_LOGGING_OPTIONS =
         Log::OUTPUT_TO_FILE
      |  Log::OUTPUT_FUNCCALLS
      |  Log::OUTPUT_LOGS
      |  Log::OUTPUT_ERRORS
      |  Log::OUTPUT_HEADER;


// a system modal popup thingy
Popup popup(IDS_WIZARD_TITLE, true);

// this is the mutex that indicates the dcpromo is running.

HANDLE dcpromoRunningMutex = INVALID_HANDLE_VALUE;



// these are the valid exit codes returned from the dcpromo.exe process

enum ExitCode
{
   // the operation failed.

   EXIT_CODE_UNSUCCESSFUL = 0,

   // the operation succeeded

   EXIT_CODE_SUCCESSFUL = 1,

   // the operation succeeded, and the user opted not to have the wizard
   // restart the machine, either manually or by specifying
   // RebootOnSuccess=NoAndNoPromptEither in the answerfile

   EXIT_CODE_SUCCESSFUL_NO_REBOOT = 2,

   // the operation failed, but the machine needs to be rebooted anyway

   EXIT_CODE_UNSUCCESSFUL_NEEDS_REBOOT = 3
};



// Checks the platform and os version number.  Returns the resource ID of the
// string to present to the user if platform/os ver requirements are not met,
// or 0 if they are met.

unsigned
CheckPlatform()
{
   LOG_FUNCTION(CheckPlatform);

   unsigned retval = 0;

   Computer::Role role = State::GetInstance().GetComputer().GetRole();
   switch (role)
   {
      case Computer::STANDALONE_WORKSTATION:
      case Computer::MEMBER_WORKSTATION:
      {
         retval = IDS_WORKSTATION_NOT_SUPPORTED;
         break;
      }
      case Computer::STANDALONE_SERVER:
      case Computer::MEMBER_SERVER:
      case Computer::PRIMARY_CONTROLLER:
      case Computer::BACKUP_CONTROLLER:
      {
         // check OS version

         OSVERSIONINFOEX info;
         memset(&info, 0, sizeof(info));
         HRESULT hr = Win::GetVersionEx(info);
         BREAK_ON_FAILED_HRESULT(hr);

         if (
            
            // require an NT-based OS
            
               info.dwPlatformId != VER_PLATFORM_WIN32_NT

            // require Whistler (version 5.1)
               
            || !(info.dwMajorVersion == 5 && info.dwMinorVersion == 1))
         {
            retval = IDS_NT51_REQUIRED;
            break;   
         }

         if (info.wSuiteMask & VER_SUITE_BLADE)
         {
            // machine is a web blade.  Don't allow promotion.
            // NTRAID#NTBUG9-195265-2001/04/03-sburns
            
            retval = IDS_WEB_BLADE_NOT_SUPPORTED;
            break;
         }

         break;
      }
      default:
      {
         ASSERT(false);
         break;
      }
   }

   return retval;
}



// Checks the role change state of the machine.  Returns the resource ID of
// the string to present to the user if the state is such that another role
// change cannot be attempted, or 0 if a role change attempt may proceed.

unsigned
CheckRoleChangeState()
{
   LOG_FUNCTION(CheckRoleChangeState);

   unsigned retval = 0;

   // check to see if a role change has taken place, or is in progress.

   DSROLE_OPERATION_STATE_INFO* info = 0;
   HRESULT hr = MyDsRoleGetPrimaryDomainInformation(0, info);
   if (SUCCEEDED(hr) && info)
   {
      switch (info->OperationState)
      {
         case DsRoleOperationIdle:
         {
            // do nothing
            break;
         }
         case DsRoleOperationActive:
         {
            // a role change operation is underway
            retval = IDS_ROLE_CHANGE_IN_PROGRESS;
            break;
         }
         case DsRoleOperationNeedReboot:
         {
            // a role change has already taken place, need to reboot before
            // attempting another.
            retval = IDS_ROLE_CHANGE_NEEDS_REBOOT;
            break;
         }
         default:
         {
            ASSERT(false);
            break;
         }
      }

      ::DsRoleFreeMemory(info);
   }

   return retval;
}



// Checks for the presence of at least 1 logical drive formatted with NTFS5.
// Returns the resource ID of the string to present to the user if no such
// drive is found (which implies that the user will not be able to pick a
// sysvol path that is formatted w/ NTFS5, which implies that proceeding would
// be a waste of time.

unsigned
CheckForNtfs5()
{
   LOG_FUNCTION(CheckForNtfs5);

   if (GetFirstNtfs5HardDrive().empty())
   {
      return IDS_NO_NTFS5_DRIVES;
   }

   return 0;
}



// Checks if the machine is running in safeboot mode.  You can run dcpromo
// while in safeboot mode.

unsigned
CheckSafeBootMode()
{
   LOG_FUNCTION(CheckSafeBootMode);

   static const String
      SAFEBOOT_KEY(L"System\\CurrentControlSet\\Control\\Safeboot\\Option");

   do
   {
      RegistryKey key;

      HRESULT hr = key.Open(HKEY_LOCAL_MACHINE, SAFEBOOT_KEY);
      BREAK_ON_FAILED_HRESULT(hr);

      DWORD mode = 0;
      hr = key.GetValue(L"OptionValue", mode);

      if (mode)
      {
         return IDS_SAFEBOOT_MODE;
      }
   }
   while (0);

   return 0;
}



unsigned
CheckCertService()
{
   LOG_FUNCTION(CheckCertService);

   // If not a downlevel DC upgrade, then refuse to run until cert service
   // is removed.  356399
   
   State::RunContext context = State::GetInstance().GetRunContext();
   if (context != State::BDC_UPGRADE && context != State::PDC_UPGRADE)
   {
      if (NTService(L"CertSvc").IsInstalled())
      {
         return IDS_CERT_SERVICE_IS_INSTALLED;
      }
   }

   return 0;
}



unsigned
CheckWindirSpace()
{
   LOG_FUNCTION(CheckWindirSpace);

   // if you change this, change the error message resource too.

   static const unsigned WINDIR_MIN_SPACE_MB = 20;

   String windir = Win::GetSystemWindowsDirectory();

   if (!CheckDiskSpace(windir, 20))
   {
      return IDS_WINDIR_LOW_SPACE;
   }

   return 0;
}



// NTRAID#NTBUG9-199759-2000/10/27-sburns

unsigned
CheckComputerWasRenamedAndNeedsReboot()
{
   LOG_FUNCTION(CheckComputerWasRenamedAndNeedsReboot);

   if (ComputerWasRenamedAndNeedsReboot())
   {
      return IDS_NAME_CHANGE_NEEDS_REBOOT;
   }

   return 0;
}



// Start the Network Identification UI (aka Computer Name UI).  After calling
// this function, the app must not initiate a role change.  It should
// terminate.

void
LaunchNetId()
{
   LOG_FUNCTION(LaunchNetId);
   ASSERT(dcpromoRunningMutex != INVALID_HANDLE_VALUE);

   // net id ui attempts acquisition of our mutex to determine if we are
   // running.  So, before starting the net id ui, we need to close the
   // mutex.  Otherwise, we would create a race condition between the start of
   // the net id ui and the closure of this app.  (And yes, cynical reader, I
   // did think of that before actually encountering a problem.)

   do
   {
      Win::CloseHandle(dcpromoRunningMutex);

      // It would be extraordinarily unlikely, but in case the mutex close
      // fails, we're gonna start the net id ui anyway and risk the race
      // condition.

      String sys32Folder = Win::GetSystemDirectory();

      String commandLine =
         String::format(
            IDS_LAUNCH_NETID_COMMAND_LINE,
            sys32Folder.c_str());

      PROCESS_INFORMATION procInfo;
      ::ZeroMemory(&procInfo, sizeof(procInfo));

      STARTUPINFO startup;
      ::ZeroMemory(&startup, sizeof(startup));

      LOG(L"Calling CreateProcess");
      LOG(commandLine);

      HRESULT hr =
         Win::CreateProcess(
            commandLine,
            0,
            0,
            false, 
            0,
            0,
            String(),
            startup,
            procInfo);
      BREAK_ON_FAILED_HRESULT(hr);

      Win::CloseHandle(procInfo.hThread);
      Win::CloseHandle(procInfo.hProcess);
   }
   while (0);
}
   


// Return false if the local machine's dns hostname is bad, also pop up an
// error dialog.  Return true if the name is OK.  A bad name is one we believe
// will have problems being registered in DNS after a promotion.  The user
// must fix a bad name before proceeding.

bool
IsComputerNameOk()
{
   LOG_FUNCTION(IsComputerNameOk);

   bool result = true;

   do
   {
      State::RunContext context = State::GetInstance().GetRunContext();
      if (
            context == State::BDC_UPGRADE
         || context == State::PDC_UPGRADE
         || context == State::NT5_DC
         || !IsTcpIpInstalled() )
      {
         // If the machine is already a DC, then we don't worry about the name.
         // 
         // If the machine is a downlevel DC undergoing upgrade, then the name
         // can't be changed until dcpromo is complete.  So, we say nothing now,
         // but remind the user to rename the machine in the Finish Page.
         //
         // If TCP/IP is not installed, then the machine has no hostname
         // to check.  In this case, we will check for that with the
         // InstallTcpIpPage

         ASSERT(result == true);
        
         break;
      }

      // Then check the computer name to ensure that it can be registered in
      // DNS.

      String hostname =
         Win::GetComputerNameEx(::ComputerNamePhysicalDnsHostname);

      DNS_STATUS status =
         MyDnsValidateName(hostname, ::DnsNameHostnameLabel);

      switch (status)
      {
         case DNS_ERROR_NON_RFC_NAME:
         {
            INT_PTR dlgResult = 
               NonRfcComputerNameDialog(hostname).ModalExecute(0);

            switch (dlgResult)
            {
               case NonRfcComputerNameDialog::CONTINUE:
               {
                  // continue on with the non-rfc name

                  ASSERT(result == true);
                     
                  break;
               }
               default:
               {
                  // close the wizard and rename.

                  result = false;

                  // after calling this, we must not allow any promote
                  // operation.  We will fall out of this function, then
                  // end the app.

                  LaunchNetId();
                  break;
               }
            }

            break;
         }
         case DNS_ERROR_NUMERIC_NAME:
         {
            result = false;

            String message =
               String::format(
                  IDS_COMPUTER_NAME_IS_NUMERIC,
                  hostname.c_str());

            BadComputerNameDialog(message).ModalExecute(0);

            break;
         }
         case DNS_ERROR_INVALID_NAME_CHAR:
         case ERROR_INVALID_NAME:
         {
            result = false;

            String message =
               String::format(
                  IDS_COMPUTER_NAME_HAS_BAD_CHARS,
                  hostname.c_str());

            BadComputerNameDialog(message).ModalExecute(0);
            
            break;
         }
         case ERROR_SUCCESS:
         default:
         {
               
            break;
         }
      }
   }
   while (0);

   LOG(result ? L"true" : L"false");

   return result;
}
      


// NTRAID#NTBUG9-346120-2001/04/04-sburns

ExitCode
HandleRebootCases()
{
   LOG_FUNCTION(HandleRebootCases);
   
   // There are two possible reasons for needing to reboot the machine:
   // the operation was successful, or the operation failed, but in the
   // attempt the machine's joined state changed.

   State& state = State::GetInstance();

   ExitCode exitCode =
         (state.GetOperationResultsCode() == State::SUCCESS)
      ?  EXIT_CODE_SUCCESSFUL
      :  EXIT_CODE_UNSUCCESSFUL_NEEDS_REBOOT;

   switch (exitCode)
   {
      case EXIT_CODE_SUCCESSFUL:
      {
         if (state.RunHiddenUnattended())
         {
            String option =
               state.GetAnswerFileOption(State::OPTION_REBOOT);
            if (option.icompare(State::VALUE_YES) == 0)
            {
               ASSERT(exitCode == EXIT_CODE_SUCCESSFUL);
               HRESULT hr = Reboot();
               if (FAILED(hr))
               {
                  popup.Error(
                     Win::GetDesktopWindow(),
                     hr,
                     IDS_CANT_REBOOT);
               }
               break;
            }
            else if (option.icompare(State::VALUE_NO_DONT_PROMPT) == 0)
            {
               // user opted not to reboot the machine via answerfile
         
               LOG(L"Not rebooting, and not prompting either");

               exitCode = EXIT_CODE_SUCCESSFUL_NO_REBOOT;   
               break;
            }
         }

         RebootDialog dlg(false);
         if (dlg.ModalExecute(0))
         {
            // user opted to reboot the machine
      
            HRESULT hr = Reboot();

            ASSERT(SUCCEEDED(hr));
            ASSERT(exitCode == EXIT_CODE_SUCCESSFUL);
         }
         else
         {
            // user opted not to reboot the machine
      
            exitCode = EXIT_CODE_SUCCESSFUL_NO_REBOOT;
         }
         break;
      }
      case EXIT_CODE_UNSUCCESSFUL_NEEDS_REBOOT:
      {
         // If the operation failed, then the wizard has gone into interactive
         // mode.
         
         RebootDialog dlg(true);
         if (dlg.ModalExecute(0))
         {
            // user opted to reboot the machine

            exitCode = EXIT_CODE_UNSUCCESSFUL;
            HRESULT hr = Reboot();

            ASSERT(SUCCEEDED(hr));
         }
         else
         {
            // user opted not to reboot the machine
      
            ASSERT(exitCode == EXIT_CODE_UNSUCCESSFUL_NEEDS_REBOOT);
         }
         
         break;
      }
      default:
      {
         ASSERT(false);
         break;
      }
   }

   return exitCode;
}



ExitCode
RunWizard()
{
   LOG_FUNCTION(RunWizard);

   // this is necessary to use the hotlink-style static text control.
// // 
// //    BOOL b = LinkWindow_RegisterClass();
// //    ASSERT(b);

   Wizard wiz(
      IDS_WIZARD_TITLE,
      IDB_BANNER16,
      IDB_BANNER256,
      IDB_WATERMARK16,
      IDB_WATERMARK256);

   // Welcome must be first
   
   wiz.AddPage(new WelcomePage());

   // These are not in any particular order...
   
   wiz.AddPage(new AdminPasswordPage());
   wiz.AddPage(new ChildPage());
   wiz.AddPage(new ConfigureDnsClientPage());
   wiz.AddPage(new ConfirmationPage());
   wiz.AddPage(new CredentialsPage());
   wiz.AddPage(new DemotePage());
   wiz.AddPage(new DnsOnNetPage());
   wiz.AddPage(new DynamicDnsPage());
   wiz.AddPage(new FailurePage());
   wiz.AddPage(new FinishPage());
   wiz.AddPage(new ForestPage());
   wiz.AddPage(new ForestVersionPage());
   wiz.AddPage(new GcConfirmationPage());
   wiz.AddPage(new InstallTcpIpPage());
   wiz.AddPage(new NetbiosNamePage());
   wiz.AddPage(new NewDomainPage());
   wiz.AddPage(new NewSitePage());
   wiz.AddPage(new Paths2Page());
   wiz.AddPage(new PathsPage());
   wiz.AddPage(new PickSitePage());
   wiz.AddPage(new RASFixupPage());
   wiz.AddPage(new ReplicaOrMemberPage());
   wiz.AddPage(new ReplicaOrNewDomainPage());
   wiz.AddPage(new ReplicaPage());
   wiz.AddPage(new ReplicateFromMediaPage());
   wiz.AddPage(new SafeModePasswordPage());
   wiz.AddPage(new TreePage());

   ExitCode exitCode = EXIT_CODE_UNSUCCESSFUL;

   switch (wiz.ModalExecute(Win::GetDesktopWindow()))
   {
      case -1:
      {
         popup.Error(
            Win::GetDesktopWindow(),
            E_FAIL,
            IDS_PROP_SHEET_FAILED);
         break;
      }
      case ID_PSREBOOTSYSTEM:
      {
         exitCode = HandleRebootCases();
         break;
      }
      default:
      {
         // do nothing.
         break;
      }
   }

   return exitCode;
}



// NTRAID#NTBUG9-350777-2001/04/24-sburns

bool
ShouldCancelBecauseMachineIsAppServer()
{
   LOG_FUNCTION(ShouldCancelBecauseMachineIsAppServer);

   bool result = false;
   
   do
   {
      State& state = State::GetInstance();
      State::RunContext context = state.GetRunContext();
      if (context == State::NT5_DC)
      {
         // already a DC: nothing to gripe about.
         
         break;
      }
      
      OSVERSIONINFOEX info;
      ::ZeroMemory(&info, sizeof(info));
      HRESULT hr = Win::GetVersionEx(info);
      BREAK_ON_FAILED_HRESULT(hr);

      // you're running app server if you're running terminal server and
      // not single user terminal server.
      
      bool isAppServer =
            (info.wSuiteMask & VER_SUITE_TERMINAL)
         && !(info.wSuiteMask & VER_SUITE_SINGLEUSERTS);

      if (isAppServer)
      {
         // warn the user that promotion will whack the ts policy settings

         LOG(L"machine has app server installed");

         if (!state.RunHiddenUnattended())
         {
            if (
               popup.MessageBox(
                  Win::GetDesktopWindow(),
                  IDS_APP_SERVER_WARNING,
                  MB_OKCANCEL) == IDCANCEL)
            {
               // user wishes to bail out.
            
               result = true;
               break;
            }
         }
      }
   }
   while (0);

   LOG_BOOL(result);

   return result;
}              

   

ExitCode
Start()
{
   LOG_FUNCTION(Start);

   ExitCode exitCode = EXIT_CODE_UNSUCCESSFUL;
   unsigned id = 0;
   do
   {
      // do the admin check first of all, cause others may fail for non-admin
      // 292749

      id = IsCurrentUserAdministrator() ? 0 : IDS_NOT_ADMIN;
      if (id)
      {
         break;
      }

      // If cert service is installed, we will probably break it on promote
      // or demote.
      // 324653

      id = CheckCertService();
      if (id)
      {
         break;
      }

      id = CheckSafeBootMode();
      if (id)
      {
         break;
      }

      // do the role change check before the platform check, as the platform
      // check may be unreliable after a demote.

      id = CheckRoleChangeState();
      if (id)
      {
         break;
      }

      id = CheckPlatform();
      if (id)
      {
         break;
      }

      id = CheckForNtfs5();
      if (id)
      {
         break;
      }

      id = CheckWindirSpace();
      if (id)
      {
         break;
      }

      id = CheckComputerWasRenamedAndNeedsReboot();
      if (id)
      {
         break;
      }
   }
   while(0);

   do
   {
      if (id)
      {
         popup.Error(
            Win::GetDesktopWindow(),
            String::load(id));
         break;
      }

      if (!IsComputerNameOk())
      {
         break;
      }

      if (ShouldCancelBecauseMachineIsAppServer())
      {
         break;
      }
      
      // NTRAID#NTBUG9-129955-2000/11/02-sburns left commented out until
      // PM decides what the real fix to this bug is.
      
      // if (!AreRequiredPortsAvailable())
      // {
      //    break;
      // }

      // there's always one more thing to check.  120143

      if (IsLastReplicaOfNonDomainNamingContexts())
      {
         break;
      }

      exitCode = RunWizard();
   }
   while (0);

   LOG(String::format(L"exitCode = %1!d!", static_cast<int>(exitCode)));
   
   return exitCode;
}



void
ShowCommandLineHelp()
{
   // CODEWORK: replace this with WinHelp, someday

   popup.MessageBox(Win::GetDesktopWindow(), IDS_COMMAND_LINE_HELP, MB_OK);
}



int WINAPI
WinMain(
   HINSTANCE   hInstance,
   HINSTANCE   /* hPrevInstance */ ,
   PSTR        /* lpszCmdLine */ ,
   int         /* nCmdShow */)
{
   hResourceModuleHandle = hInstance;

   ExitCode exitCode = EXIT_CODE_UNSUCCESSFUL;

   HRESULT hr = Win::CreateMutex(0, true, RUNTIME_NAME, dcpromoRunningMutex);
   if (hr == Win32ToHresult(ERROR_ALREADY_EXISTS))
   {
      popup.Error(Win::GetDesktopWindow(), IDS_ALREADY_RUNNING);
   }
   else
   {
      hr = ::CoInitialize(0);
      ASSERT(SUCCEEDED(hr));

      // change structure instance name so as not to accidentally offend
      // the sensibilities of the delicate reader.
      // NTRAID#NTBUG9-382719-2001/05/01-sburns
      
      INITCOMMONCONTROLSEX init_structure_not_to_contain_a_naughty_word;
      init_structure_not_to_contain_a_naughty_word.dwSize =
         sizeof(init_structure_not_to_contain_a_naughty_word);      
      init_structure_not_to_contain_a_naughty_word.dwICC  =
         ICC_ANIMATE_CLASS | ICC_USEREX_CLASSES;

      BOOL init =
         ::InitCommonControlsEx(&init_structure_not_to_contain_a_naughty_word);
      ASSERT(init);
         
      State::Init();

      if (State::GetInstance().NeedsCommandLineHelp())
      {
         ShowCommandLineHelp();
      }
      else
      {
         exitCode = Start();
      }

      State::Destroy();
   }

   return static_cast<int>(exitCode);
}