You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1322 lines
36 KiB
1322 lines
36 KiB
// Copyright (c) 2001 Microsoft Corporation
|
|
//
|
|
// File: ExpressRebootPage.cpp
|
|
//
|
|
// Synopsis: Defines the ExpressRebootPage that shows
|
|
// the progress of the changes being made to
|
|
// the server after the reboot fromt the
|
|
// express path
|
|
//
|
|
// History: 05/11/2001 JeffJon Created
|
|
|
|
|
|
#include "pch.h"
|
|
#include "resource.h"
|
|
|
|
#include "InstallationUnitProvider.h"
|
|
#include "ExpressRebootPage.h"
|
|
|
|
|
|
// Private window messages for updating the UI status
|
|
|
|
// For these messages the WPARAM is the operation that finished, and
|
|
// the LPARAM is the operation that is next
|
|
|
|
const UINT ExpressRebootPage::CYS_OPERATION_FINISHED_SUCCESS = WM_USER + 1001;
|
|
const UINT ExpressRebootPage::CYS_OPERATION_FINISHED_FAILED = WM_USER + 1002;
|
|
|
|
|
|
const UINT ExpressRebootPage::CYS_OPERATION_COMPLETE_SUCCESS = WM_USER + 1003;
|
|
const UINT ExpressRebootPage::CYS_OPERATION_COMPLETE_FAILED = WM_USER + 1004;
|
|
|
|
|
|
// This structure maps the four static controls that make up an operation
|
|
// together. The pageProgress array must be in the order the operations
|
|
// will take place so that the page can update appropriately when
|
|
// an CYS_OPERATION_FINISHED_* message is sent back to the page
|
|
|
|
typedef struct _PageProgressStruct
|
|
{
|
|
unsigned int currentIconControl;
|
|
unsigned int checkIconControl;
|
|
unsigned int errorIconControl;
|
|
unsigned int staticIconControl;
|
|
} PageProgressStruct;
|
|
|
|
PageProgressStruct pageOperationProgress[] =
|
|
{
|
|
{
|
|
IDC_IPADDRESS_CURRENT_STATIC,
|
|
IDC_IPADDRESS_CHECK_STATIC,
|
|
IDC_IPADDRESS_ERROR_STATIC,
|
|
IDC_IPADDRESS_STATIC
|
|
},
|
|
|
|
{
|
|
IDC_DHCP_CURRENT_STATIC,
|
|
IDC_DHCP_CHECK_STATIC,
|
|
IDC_DHCP_ERROR_STATIC,
|
|
IDC_DHCP_STATIC
|
|
},
|
|
|
|
{
|
|
IDC_AD_CURRENT_STATIC,
|
|
IDC_AD_CHECK_STATIC,
|
|
IDC_AD_ERROR_STATIC,
|
|
IDC_AD_STATIC
|
|
},
|
|
|
|
{
|
|
IDC_DNS_CURRENT_STATIC,
|
|
IDC_DNS_CHECK_STATIC,
|
|
IDC_DNS_ERROR_STATIC,
|
|
IDC_DNS_STATIC
|
|
},
|
|
|
|
{
|
|
IDC_FORWARDER_CURRENT_STATIC,
|
|
IDC_FORWARDER_CHECK_STATIC,
|
|
IDC_FORWARDER_ERROR_STATIC,
|
|
IDC_FORWARDER_STATIC
|
|
},
|
|
|
|
{
|
|
IDC_DHCP_SCOPE_CURRENT_STATIC,
|
|
IDC_DHCP_SCOPE_CHECK_STATIC,
|
|
IDC_DHCP_SCOPE_ERROR_STATIC,
|
|
IDC_DHCP_SCOPE_STATIC
|
|
},
|
|
|
|
{
|
|
IDC_AUTHORIZE_SCOPE_CURRENT_STATIC,
|
|
IDC_AUTHORIZE_SCOPE_CHECK_STATIC,
|
|
IDC_AUTHORIZE_SCOPE_ERROR_STATIC,
|
|
IDC_AUTHORIZE_SCOPE_STATIC
|
|
},
|
|
|
|
{
|
|
IDC_TAPI_CURRENT_STATIC,
|
|
IDC_TAPI_CHECK_STATIC,
|
|
IDC_TAPI_ERROR_STATIC,
|
|
IDC_TAPI_STATIC
|
|
},
|
|
|
|
{ 0, 0, 0, 0 }
|
|
};
|
|
|
|
bool
|
|
SetDNSForwarder(HANDLE logfileHandle)
|
|
{
|
|
LOG_FUNCTION(SetDNSForwarder);
|
|
|
|
bool result = true;
|
|
|
|
do
|
|
{
|
|
// First read the regky
|
|
|
|
DWORD forwarder = 0;
|
|
String autoForwarder;
|
|
|
|
bool forwarderResult = GetRegKeyValue(
|
|
CYS_FIRST_DC_REGKEY,
|
|
CYS_FIRST_DC_FORWARDER,
|
|
forwarder);
|
|
|
|
bool autoForwarderResult = GetRegKeyValue(
|
|
CYS_FIRST_DC_REGKEY,
|
|
CYS_FIRST_DC_AUTOFORWARDER,
|
|
autoForwarder);
|
|
|
|
if (forwarderResult &&
|
|
forwarder != 0)
|
|
{
|
|
DWORD forwarderInDisplayOrder = ConvertIPAddressOrder(forwarder);
|
|
|
|
LOG(String::format(
|
|
L"Setting forwarder from forwarder regkey: %1",
|
|
IPAddressToString(forwarderInDisplayOrder).c_str()));
|
|
|
|
DNS_STATUS error = ::DnssrvResetForwarders(
|
|
L"localhost",
|
|
1,
|
|
&forwarder,
|
|
DNS_DEFAULT_FORWARD_TIMEOUT,
|
|
DNS_DEFAULT_SLAVE);
|
|
|
|
if (error != 0)
|
|
{
|
|
LOG(String::format(
|
|
L"Failed to set the forwarder: error = 0x%1!x!",
|
|
error));
|
|
|
|
CYS_APPEND_LOG(String::load(IDS_EXPRESS_REBOOT_FORWARDER_FAILED));
|
|
|
|
result = false;
|
|
break;
|
|
}
|
|
|
|
CYS_APPEND_LOG(
|
|
String::format(
|
|
IDS_EXPRESS_REBOOT_FORWARDER_SUCCEEDED,
|
|
IPAddressToString(forwarderInDisplayOrder).c_str()));
|
|
}
|
|
else if (autoForwarderResult &&
|
|
!autoForwarder.empty())
|
|
{
|
|
LOG(String::format(
|
|
L"Setting forwarder from autoforwarder regkey: %1",
|
|
autoForwarder.c_str()));
|
|
|
|
// Now parse the forwarders string into a DWORD array
|
|
|
|
StringList forwardersList;
|
|
autoForwarder.tokenize(std::back_inserter(forwardersList));
|
|
|
|
DWORD count = 0;
|
|
DWORD* forwarderArray = StringIPListToDWORDArray(forwardersList, count);
|
|
if (forwarderArray)
|
|
{
|
|
DNS_STATUS error = ::DnssrvResetForwarders(
|
|
L"localhost",
|
|
count,
|
|
forwarderArray,
|
|
DNS_DEFAULT_FORWARD_TIMEOUT,
|
|
DNS_DEFAULT_SLAVE);
|
|
|
|
// Delete the memory returned from StringIPListToDWORDArray
|
|
|
|
delete[] forwarderArray;
|
|
forwarderArray = 0;
|
|
|
|
// Check for errors
|
|
|
|
if (error != 0)
|
|
{
|
|
LOG(String::format(
|
|
L"Failed to set the forwarder: error = 0x%1!x!",
|
|
error));
|
|
|
|
CYS_APPEND_LOG(String::load(IDS_EXPRESS_REBOOT_FORWARDER_FAILED));
|
|
|
|
result = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Since the regkey wasn't set that means we should try
|
|
// to take the forwarders from the NICs defined server list
|
|
|
|
IPAddressList forwarders;
|
|
InstallationUnitProvider::GetInstance().GetDNSInstallationUnit().GetForwarders(forwarders);
|
|
|
|
if (forwarders.empty())
|
|
{
|
|
LOG(L"No DNS servers set on any NIC");
|
|
|
|
CYS_APPEND_LOG(String::load(IDS_EXPRESS_REBOOT_FORWARDER_FAILED));
|
|
|
|
result = false;
|
|
break;
|
|
}
|
|
|
|
// This is an exception throwing new so there is no
|
|
// reason to check for NULL
|
|
|
|
DWORD forwardersCount = static_cast<DWORD>(forwarders.size());
|
|
DWORD* forwardersArray = new DWORD[forwardersCount];
|
|
|
|
// Copy the forwarders addresses into the array
|
|
|
|
for (DWORD idx = 0; idx < forwardersCount; ++idx)
|
|
{
|
|
// The IP address must be in network order (d.c.b.a) not in the UI
|
|
// order (a.b.c.d)
|
|
|
|
forwardersArray[idx] = ConvertIPAddressOrder(forwarders[idx]);
|
|
}
|
|
|
|
// Now set the forwarders in the DNS server
|
|
|
|
DNS_STATUS error = ::DnssrvResetForwarders(
|
|
L"localhost",
|
|
forwardersCount,
|
|
forwardersArray,
|
|
DNS_DEFAULT_FORWARD_TIMEOUT,
|
|
DNS_DEFAULT_SLAVE);
|
|
|
|
// Delete the allocated array
|
|
|
|
delete[] forwardersArray;
|
|
forwardersArray = 0;
|
|
|
|
// Check for errors
|
|
|
|
if (error != 0)
|
|
{
|
|
LOG(String::format(
|
|
L"Failed to set the forwarders: error = 0x%1!x!",
|
|
error));
|
|
|
|
CYS_APPEND_LOG(String::load(IDS_EXPRESS_REBOOT_FORWARDER_FAILED));
|
|
|
|
result = false;
|
|
break;
|
|
}
|
|
|
|
CYS_APPEND_LOG(
|
|
String::format(
|
|
IDS_EXPRESS_REBOOT_FORWARDER_SUCCEEDED,
|
|
IPAddressToString(ConvertIPAddressOrder(forwardersArray[0])).c_str()));
|
|
}
|
|
|
|
} while (false);
|
|
|
|
LOG_BOOL(result);
|
|
return result;
|
|
}
|
|
|
|
void _cdecl
|
|
wrapperThreadProc(void* p)
|
|
{
|
|
if (!p)
|
|
{
|
|
ASSERT(p);
|
|
return;
|
|
}
|
|
|
|
bool result = true;
|
|
|
|
ExpressRebootPage* page =
|
|
reinterpret_cast<ExpressRebootPage*>(p);
|
|
ASSERT(page);
|
|
|
|
HWND hwnd = page->GetHWND();
|
|
|
|
// Create the log file
|
|
|
|
bool logFileAvailable = false;
|
|
String logName;
|
|
HANDLE logfileHandle = AppendLogFile(
|
|
CYS_LOGFILE_NAME,
|
|
logName);
|
|
if (logfileHandle &&
|
|
logfileHandle != INVALID_HANDLE_VALUE)
|
|
{
|
|
LOG(String::format(L"New log file was created: %1", logName.c_str()));
|
|
logFileAvailable = true;
|
|
}
|
|
else
|
|
{
|
|
LOG(L"Unable to create the log file!!!");
|
|
logFileAvailable = false;
|
|
}
|
|
|
|
ExpressInstallationUnit& expressInstallationUnit =
|
|
InstallationUnitProvider::GetInstance().GetExpressInstallationUnit();
|
|
|
|
// NTRAID#NTBUG9-638337-2002/06/13-JeffJon
|
|
// Need to compare the IP address that was written to the registry
|
|
// to the current IP address to see if they are the same
|
|
|
|
String currentIPAddress;
|
|
|
|
NetworkInterface* localNIC =
|
|
State::GetInstance().GetLocalNICFromRegistry();
|
|
|
|
if (localNIC)
|
|
{
|
|
// Set the static text for the IP Address
|
|
|
|
currentIPAddress =
|
|
localNIC->GetStringIPAddress(0);
|
|
}
|
|
|
|
String attemptedIPAddress = page->GetIPAddressString();
|
|
|
|
if (attemptedIPAddress.icompare(currentIPAddress) == 0)
|
|
{
|
|
LOG(L"The current IP address and the IP address from the registry match");
|
|
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_FINISHED_SUCCESS,
|
|
(WPARAM)ExpressRebootPage::CYS_OPERATION_SET_STATIC_IP,
|
|
(LPARAM)ExpressRebootPage::CYS_OPERATION_SERVER_DHCP);
|
|
}
|
|
else
|
|
{
|
|
// Since the IP addresses didn't match we have to show the error
|
|
// Most likely this was caused by another machine coming up on the
|
|
// network with the same IP as we set before the reboot.
|
|
|
|
LOG(L"Failed to set the static IP address.");
|
|
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_FINISHED_FAILED,
|
|
(WPARAM)ExpressRebootPage::CYS_OPERATION_SET_STATIC_IP,
|
|
(LPARAM)ExpressRebootPage::CYS_OPERATION_SERVER_DHCP);
|
|
}
|
|
|
|
if (!page->WasDHCPInstallAttempted() ||
|
|
InstallationUnitProvider::GetInstance().
|
|
GetDHCPInstallationUnit().IsServiceInstalled())
|
|
{
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_FINISHED_SUCCESS,
|
|
(WPARAM)ExpressRebootPage::CYS_OPERATION_SERVER_DHCP,
|
|
(LPARAM)ExpressRebootPage::CYS_OPERATION_SERVER_AD);
|
|
}
|
|
else
|
|
{
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_FINISHED_FAILED,
|
|
(WPARAM)ExpressRebootPage::CYS_OPERATION_SERVER_DHCP,
|
|
(LPARAM)ExpressRebootPage::CYS_OPERATION_SERVER_AD);
|
|
|
|
if (result)
|
|
{
|
|
expressInstallationUnit.SetExpressRoleResult(
|
|
ExpressInstallationUnit::EXPRESS_DHCP_INSTALL_FAILURE);
|
|
}
|
|
result = false;
|
|
}
|
|
|
|
// Verify the machine is a DC
|
|
|
|
// Check to see if DCPromo was successful in making this a DC
|
|
|
|
if (State::GetInstance().IsDC())
|
|
{
|
|
CYS_APPEND_LOG(String::load(IDS_LOG_DCPROMO_REBOOT_SUCCEEDED));
|
|
|
|
// Log the new domain name
|
|
|
|
CYS_APPEND_LOG(String::load(IDS_EXPRESS_SERVER_AD));
|
|
CYS_APPEND_LOG(
|
|
String::format(
|
|
IDS_EXPRESS_AD_DOMAIN_NAME,
|
|
State::GetInstance().GetDomainDNSName().c_str()));
|
|
|
|
CYS_APPEND_LOG(
|
|
String::format(
|
|
IDS_EXPRESS_AD_NETBIOS_NAME,
|
|
State::GetInstance().GetDomainNetbiosName().c_str()));
|
|
|
|
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_FINISHED_SUCCESS,
|
|
(WPARAM)ExpressRebootPage::CYS_OPERATION_SERVER_AD,
|
|
(LPARAM)ExpressRebootPage::CYS_OPERATION_SERVER_DNS);
|
|
}
|
|
else
|
|
{
|
|
LOG(L"DCPromo failed on reboot");
|
|
|
|
CYS_APPEND_LOG(String::load(IDS_LOG_DCPROMO_REBOOT_FAILED));
|
|
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_FINISHED_FAILED,
|
|
(WPARAM)ExpressRebootPage::CYS_OPERATION_SERVER_AD,
|
|
(LPARAM)ExpressRebootPage::CYS_OPERATION_SERVER_DNS);
|
|
|
|
// Only override the role result if it hasn't already been set
|
|
|
|
if (result)
|
|
{
|
|
expressInstallationUnit.SetExpressRoleResult(
|
|
ExpressInstallationUnit::EXPRESS_AD_FAILURE);
|
|
}
|
|
result = false;
|
|
}
|
|
|
|
// DNS is now the current operation, check to see if it is installed
|
|
|
|
if (InstallationUnitProvider::GetInstance().
|
|
GetDNSInstallationUnit().IsServiceInstalled())
|
|
{
|
|
CYS_APPEND_LOG(String::load(IDS_EXPRESS_REBOOT_DNS_SERVER_SUCCEEDED));
|
|
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_FINISHED_SUCCESS,
|
|
(WPARAM)ExpressRebootPage::CYS_OPERATION_SERVER_DNS,
|
|
(LPARAM)ExpressRebootPage::CYS_OPERATION_SET_DNS_FORWARDER);
|
|
|
|
if (page->SetForwarder())
|
|
{
|
|
// Now wait for the service to start before trying to set the forwarders
|
|
|
|
NTService serviceObject(CYS_DNS_SERVICE_NAME);
|
|
|
|
HRESULT hr = serviceObject.WaitForServiceState(SERVICE_RUNNING);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
|
|
if (SetDNSForwarder(logfileHandle))
|
|
{
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_FINISHED_SUCCESS,
|
|
(WPARAM)ExpressRebootPage::CYS_OPERATION_SET_DNS_FORWARDER,
|
|
(LPARAM)ExpressRebootPage::CYS_OPERATION_ACTIVATE_DHCP_SCOPE);
|
|
}
|
|
else
|
|
{
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_FINISHED_FAILED,
|
|
(WPARAM)ExpressRebootPage::CYS_OPERATION_SET_DNS_FORWARDER,
|
|
(LPARAM)ExpressRebootPage::CYS_OPERATION_ACTIVATE_DHCP_SCOPE);
|
|
|
|
expressInstallationUnit.SetExpressRoleResult(
|
|
ExpressInstallationUnit::EXPRESS_DNS_FORWARDER_FAILURE);
|
|
|
|
result = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG(L"The DNS service never started!");
|
|
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_FINISHED_FAILED,
|
|
(WPARAM)ExpressRebootPage::CYS_OPERATION_SET_DNS_FORWARDER,
|
|
(LPARAM)ExpressRebootPage::CYS_OPERATION_ACTIVATE_DHCP_SCOPE);
|
|
|
|
expressInstallationUnit.SetExpressRoleResult(
|
|
ExpressInstallationUnit::EXPRESS_DNS_FORWARDER_FAILURE);
|
|
|
|
result = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CYS_APPEND_LOG(String::load(IDS_EXPRESS_REBOOT_LOG_NO_FORWARDER));
|
|
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_FINISHED_SUCCESS,
|
|
(WPARAM)ExpressRebootPage::CYS_OPERATION_SET_DNS_FORWARDER,
|
|
(LPARAM)ExpressRebootPage::CYS_OPERATION_ACTIVATE_DHCP_SCOPE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CYS_APPEND_LOG(String::load(IDS_EXPRESS_REBOOT_DNS_SERVER_FAILED));
|
|
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_FINISHED_FAILED,
|
|
(WPARAM)ExpressRebootPage::CYS_OPERATION_SERVER_DNS,
|
|
(LPARAM)ExpressRebootPage::CYS_OPERATION_SET_DNS_FORWARDER);
|
|
|
|
// If the DNS service isn't installed there is no way to set a
|
|
// forwarder
|
|
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_FINISHED_FAILED,
|
|
(WPARAM)ExpressRebootPage::CYS_OPERATION_SET_DNS_FORWARDER,
|
|
(LPARAM)ExpressRebootPage::CYS_OPERATION_ACTIVATE_DHCP_SCOPE);
|
|
|
|
// Only override the role result if it hasn't already been set
|
|
|
|
if (result)
|
|
{
|
|
expressInstallationUnit.SetExpressRoleResult(
|
|
ExpressInstallationUnit::EXPRESS_DNS_SERVER_FAILURE);
|
|
}
|
|
result = false;
|
|
}
|
|
|
|
// Verify DHCP scope activation
|
|
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_FINISHED_SUCCESS,
|
|
(WPARAM)ExpressRebootPage::CYS_OPERATION_ACTIVATE_DHCP_SCOPE,
|
|
(LPARAM)ExpressRebootPage::CYS_OPERATION_AUTHORIZE_DHCP_SERVER);
|
|
|
|
// Authorize the DHCP server
|
|
|
|
String dnsName = Win::GetComputerNameEx(ComputerNameDnsFullyQualified);
|
|
|
|
if (page->WasDHCPInstallAttempted())
|
|
{
|
|
if (InstallationUnitProvider::GetInstance().GetDHCPInstallationUnit().AuthorizeDHCPServer(dnsName))
|
|
{
|
|
LOG(L"DHCP server successfully authorized");
|
|
|
|
CYS_APPEND_LOG(String::load(IDS_LOG_DHCP_AUTHORIZATION_SUCCEEDED));
|
|
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_FINISHED_SUCCESS,
|
|
(WPARAM)ExpressRebootPage::CYS_OPERATION_AUTHORIZE_DHCP_SERVER,
|
|
(LPARAM)ExpressRebootPage::CYS_OPERATION_CREATE_TAPI_PARTITION);
|
|
}
|
|
else
|
|
{
|
|
LOG(L"DHCP scope authorization failed");
|
|
|
|
String failureMessage = String::load(IDS_LOG_DHCP_AUTHORIZATION_FAILED);
|
|
CYS_APPEND_LOG(failureMessage);
|
|
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_FINISHED_FAILED,
|
|
(WPARAM)ExpressRebootPage::CYS_OPERATION_AUTHORIZE_DHCP_SERVER,
|
|
(LPARAM)ExpressRebootPage::CYS_OPERATION_CREATE_TAPI_PARTITION);
|
|
|
|
// Only override the role result if it hasn't already been set
|
|
|
|
if (result)
|
|
{
|
|
expressInstallationUnit.SetExpressRoleResult(
|
|
ExpressInstallationUnit::EXPRESS_DHCP_ACTIVATION_FAILURE);
|
|
}
|
|
result = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_FINISHED_SUCCESS,
|
|
(WPARAM)ExpressRebootPage::CYS_OPERATION_AUTHORIZE_DHCP_SERVER,
|
|
(LPARAM)ExpressRebootPage::CYS_OPERATION_CREATE_TAPI_PARTITION);
|
|
}
|
|
|
|
// Do TAPI config
|
|
|
|
HRESULT hr =
|
|
InstallationUnitProvider::GetInstance().
|
|
GetExpressInstallationUnit().DoTapiConfig(
|
|
State::GetInstance().GetDomainDNSName());
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LOG(L"TAPI config succeeded");
|
|
|
|
CYS_APPEND_LOG(String::load(IDS_LOG_TAPI_CONFIG_SUCCEEDED));
|
|
CYS_APPEND_LOG(
|
|
String::format(
|
|
IDS_LOG_TAPI_CONFIG_SUCCEEDED_FORMAT,
|
|
dnsName.c_str()));
|
|
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_FINISHED_SUCCESS,
|
|
(WPARAM)ExpressRebootPage::CYS_OPERATION_CREATE_TAPI_PARTITION,
|
|
(LPARAM)ExpressRebootPage::CYS_OPERATION_END);
|
|
}
|
|
else
|
|
{
|
|
LOG(L"TAPI config failed");
|
|
|
|
CYS_APPEND_LOG(
|
|
String::format(
|
|
IDS_LOG_TAPI_CONFIG_FAILED_FORMAT,
|
|
hr));
|
|
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_FINISHED_FAILED,
|
|
(WPARAM)ExpressRebootPage::CYS_OPERATION_CREATE_TAPI_PARTITION,
|
|
(LPARAM)ExpressRebootPage::CYS_OPERATION_END);
|
|
|
|
// Only override the role result if it hasn't already been set
|
|
|
|
if (result)
|
|
{
|
|
expressInstallationUnit.SetExpressRoleResult(
|
|
ExpressInstallationUnit::EXPRESS_TAPI_FAILURE);
|
|
}
|
|
|
|
result = false;
|
|
}
|
|
|
|
// Close the log file
|
|
|
|
Win::CloseHandle(logfileHandle);
|
|
|
|
if (result)
|
|
{
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_COMPLETE_SUCCESS,
|
|
0,
|
|
0);
|
|
}
|
|
else
|
|
{
|
|
Win::SendMessage(
|
|
hwnd,
|
|
ExpressRebootPage::CYS_OPERATION_COMPLETE_FAILED,
|
|
0,
|
|
0);
|
|
}
|
|
}
|
|
|
|
static PCWSTR EXPRESS_REBOOT_PAGE_HELP = L"cys.chm::/typical_setup.htm";
|
|
|
|
ExpressRebootPage::ExpressRebootPage()
|
|
:
|
|
dhcpInstallAttempted(true),
|
|
setForwarder(true),
|
|
threadDone(false),
|
|
CYSWizardPage(
|
|
IDD_EXPRESS_REBOOT_PAGE,
|
|
IDS_EXPRESS_REBOOT_TITLE,
|
|
IDS_EXPRESS_REBOOT_SUBTITLE,
|
|
EXPRESS_REBOOT_PAGE_HELP)
|
|
{
|
|
LOG_CTOR(ExpressRebootPage);
|
|
}
|
|
|
|
|
|
|
|
ExpressRebootPage::~ExpressRebootPage()
|
|
{
|
|
LOG_DTOR(ExpressRebootPage);
|
|
}
|
|
|
|
|
|
void
|
|
ExpressRebootPage::OnInit()
|
|
{
|
|
LOG_FUNCTION(ExpressRebootPage::OnInit);
|
|
|
|
CYSWizardPage::OnInit();
|
|
|
|
// Since this page can be started directly
|
|
// we have to be sure to set the wizard title
|
|
|
|
Win::PropSheet_SetTitle(
|
|
Win::GetParent(hwnd),
|
|
0,
|
|
String::load(IDS_WIZARD_TITLE));
|
|
|
|
ClearOperationStates();
|
|
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
IDC_EXPRESS_CONFIG_DONE_STATIC),
|
|
false);
|
|
|
|
// Set the range and step size for the progress bar
|
|
|
|
Win::SendMessage(
|
|
Win::GetDlgItem(hwnd, IDC_CONFIG_PROGRESS),
|
|
PBM_SETRANGE,
|
|
0,
|
|
MAKELPARAM(CYS_OPERATION_SET_STATIC_IP, CYS_OPERATION_END));
|
|
|
|
Win::SendMessage(
|
|
Win::GetDlgItem(hwnd, IDC_CONFIG_PROGRESS),
|
|
PBM_SETSTEP,
|
|
(WPARAM)1,
|
|
0);
|
|
|
|
// Set the state object so that CYS doesn't run again
|
|
|
|
// State::GetInstance().SetRerunWizard(false);
|
|
|
|
// Initialize the state object so we can get the info to put
|
|
// in the UI
|
|
|
|
State::GetInstance().RetrieveMachineConfigurationInformation(
|
|
0,
|
|
false,
|
|
IDS_RETRIEVE_NIC_INFO,
|
|
IDS_RETRIEVE_OS_INFO,
|
|
IDS_LOCAL_AREA_CONNECTION,
|
|
IDS_DETECTING_SETTINGS_FORMAT);
|
|
|
|
// NTRAID#NTBUG9-638337-2002/06/13-JeffJon
|
|
// We need to display the IP address that was written to the
|
|
// registry before the reboot because the "local NIC" IP
|
|
// address may have been changed if a machine was brought
|
|
// up on the network with a duplicate IP address while we
|
|
// were rebooting.
|
|
|
|
if (!GetRegKeyValue(
|
|
CYS_FIRST_DC_REGKEY,
|
|
CYS_FIRST_DC_STATIC_IP,
|
|
ipaddressString,
|
|
HKEY_LOCAL_MACHINE))
|
|
{
|
|
LOG(L"Failed to read the regkey for the static IP address.");
|
|
}
|
|
|
|
String ipaddressStaticText = String::format(
|
|
IDS_EXPRESS_REBOOT_IPADDRESS,
|
|
ipaddressString.c_str());
|
|
|
|
Win::SetDlgItemText(
|
|
hwnd,
|
|
IDC_IPADDRESS_STATIC,
|
|
ipaddressStaticText);
|
|
|
|
// Set the static text for the DNS Forwarder
|
|
|
|
String forwarderStaticText;
|
|
String autoForwardersText;
|
|
|
|
DWORD forwarder = 0;
|
|
|
|
bool forwarderResult = GetRegKeyValue(
|
|
CYS_FIRST_DC_REGKEY,
|
|
CYS_FIRST_DC_FORWARDER,
|
|
forwarder);
|
|
|
|
bool autoForwarderResult = GetRegKeyValue(
|
|
CYS_FIRST_DC_REGKEY,
|
|
CYS_FIRST_DC_AUTOFORWARDER,
|
|
autoForwardersText);
|
|
|
|
if (forwarderResult)
|
|
{
|
|
// We were able to read the fowarder regkey so the user
|
|
// must have seen the DNS Forwarder page before the reboot
|
|
|
|
if (forwarder != 0)
|
|
{
|
|
// The user entered an IP address on the DNS Forwarder page
|
|
// before the reboot
|
|
|
|
DWORD forwarderInDisplayOrder = ConvertIPAddressOrder(forwarder);
|
|
|
|
forwarderStaticText = String::format(
|
|
IDS_EXPRESS_REBOOT_FORWARDER,
|
|
IPAddressToString(forwarderInDisplayOrder).c_str());
|
|
|
|
LOG(String::format(
|
|
L"Read forwarders from forwarder key: %1",
|
|
forwarderStaticText.c_str()));
|
|
}
|
|
else
|
|
{
|
|
// The user chose not to forward when prompted on the DNS Forwarder
|
|
// page before the reboot
|
|
|
|
forwarderStaticText = String::load(IDS_EXPRESS_REBOOT_NO_FORWARDER);
|
|
setForwarder = false;
|
|
}
|
|
}
|
|
else if (autoForwarderResult &&
|
|
!autoForwardersText.empty())
|
|
{
|
|
forwarderStaticText = String::format(
|
|
IDS_EXPRESS_REBOOT_FORWARDER,
|
|
autoForwardersText.c_str());
|
|
|
|
LOG(String::format(
|
|
L"Read forwarders from autoforwarder key: %1",
|
|
autoForwardersText.c_str()));
|
|
}
|
|
else
|
|
{
|
|
LOG(L"Failed to read both the forwarders and autoforwarders key, using local NIC settings instead");
|
|
|
|
// Get the DNS servers from the NICs
|
|
|
|
IPAddressList forwarders;
|
|
InstallationUnitProvider::GetInstance().GetDNSInstallationUnit().GetForwarders(forwarders);
|
|
|
|
if (!forwarders.empty())
|
|
{
|
|
// Format the IP addresses into a string for display
|
|
// each IP address is separated by a space
|
|
|
|
String ipList;
|
|
for (IPAddressList::iterator itr = forwarders.begin();
|
|
itr != forwarders.end();
|
|
++itr)
|
|
{
|
|
if (!ipList.empty())
|
|
{
|
|
ipList += L" ";
|
|
}
|
|
|
|
ipList += String::format(
|
|
L"%1",
|
|
IPAddressToString(*itr).c_str());
|
|
}
|
|
|
|
forwarderStaticText = String::format(
|
|
IDS_EXPRESS_REBOOT_FORWARDER,
|
|
ipList.c_str());
|
|
}
|
|
else
|
|
{
|
|
forwarderStaticText = String::load(IDS_EXPRESS_REBOOT_NO_FORWARDER);
|
|
setForwarder = false;
|
|
}
|
|
}
|
|
|
|
Win::SetDlgItemText(
|
|
hwnd,
|
|
IDC_FORWARDER_STATIC,
|
|
forwarderStaticText);
|
|
|
|
SetDHCPStatics();
|
|
|
|
// Start up another thread that will perform the operations
|
|
// and post messages back to the page to update the UI
|
|
|
|
_beginthread(wrapperThreadProc, 0, this);
|
|
}
|
|
|
|
bool
|
|
ExpressRebootPage::OnSetActive()
|
|
{
|
|
LOG_FUNCTION(ExpressRebootPage::OnSetActive);
|
|
|
|
// Disable all the wizard buttons until the other
|
|
// thread is finished
|
|
|
|
if (threadDone)
|
|
{
|
|
Win::PropSheet_SetWizButtons(
|
|
Win::GetParent(hwnd),
|
|
PSWIZB_NEXT);
|
|
}
|
|
else
|
|
{
|
|
Win::PropSheet_SetWizButtons(
|
|
Win::GetParent(hwnd),
|
|
0);
|
|
}
|
|
|
|
// Disable the cancel button and the X in the upper
|
|
// right corner
|
|
|
|
SetCancelState(false);
|
|
|
|
return true;
|
|
}
|
|
|
|
void
|
|
ExpressRebootPage::SetCancelState(bool enable) const
|
|
{
|
|
LOG_FUNCTION(ExpressRebootPage::SetCancelState);
|
|
|
|
// Set the state of the button
|
|
|
|
Win::EnableWindow(
|
|
Win::GetDlgItem(
|
|
Win::GetParent(hwnd),
|
|
IDCANCEL),
|
|
enable);
|
|
|
|
|
|
// Set the state of the X in the upper right corner
|
|
|
|
HMENU menu = GetSystemMenu(GetParent(hwnd), FALSE);
|
|
|
|
if (menu)
|
|
{
|
|
if (enable)
|
|
{
|
|
EnableMenuItem(
|
|
menu,
|
|
SC_CLOSE,
|
|
MF_BYCOMMAND | MF_ENABLED);
|
|
}
|
|
else
|
|
{
|
|
EnableMenuItem(
|
|
menu,
|
|
SC_CLOSE,
|
|
MF_BYCOMMAND | MF_GRAYED);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
ExpressRebootPage::SetDHCPStatics()
|
|
{
|
|
LOG_FUNCTION(ExpressRebootPage::SetDHCPStatics);
|
|
|
|
DWORD dhcpInstalled = 0;
|
|
bool regResult = GetRegKeyValue(
|
|
CYS_FIRST_DC_REGKEY,
|
|
CYS_FIRST_DC_DHCP_SERVERED,
|
|
dhcpInstalled,
|
|
HKEY_LOCAL_MACHINE);
|
|
|
|
if (regResult && !dhcpInstalled)
|
|
{
|
|
dhcpInstallAttempted = false;
|
|
|
|
// Set the static text so that users know we didn't install DHCP
|
|
|
|
Win::SetDlgItemText(
|
|
hwnd,
|
|
IDC_DHCP_STATIC,
|
|
String::load(IDS_EXPRESS_DHCP_NOT_REQUIRED));
|
|
|
|
Win::SetDlgItemText(
|
|
hwnd,
|
|
IDC_DHCP_SCOPE_STATIC,
|
|
String::load(IDS_EXPRESS_DHCP_SCOPE_NONE));
|
|
|
|
Win::SetDlgItemText(
|
|
hwnd,
|
|
IDC_AUTHORIZE_SCOPE_STATIC,
|
|
String::load(IDS_EXPRESS_DHCP_NO_AUTHORIZATION));
|
|
}
|
|
else
|
|
{
|
|
dhcpInstallAttempted = true;
|
|
|
|
// Set the static text for the DHCP scopes to authorize
|
|
|
|
String start;
|
|
|
|
if (!GetRegKeyValue(
|
|
CYS_FIRST_DC_REGKEY,
|
|
CYS_FIRST_DC_SCOPE_START,
|
|
start))
|
|
|
|
{
|
|
LOG(L"Failed to get the start scope regkey");
|
|
}
|
|
|
|
String end;
|
|
|
|
if (!GetRegKeyValue(
|
|
CYS_FIRST_DC_REGKEY,
|
|
CYS_FIRST_DC_SCOPE_END,
|
|
end))
|
|
{
|
|
LOG(L"Failed to get the end scope regkey");
|
|
}
|
|
|
|
String authorizedScopesText = String::format(
|
|
IDS_EXPRESS_REBOOT_DHCP_SCOPE,
|
|
start.c_str(),
|
|
end.c_str());
|
|
|
|
Win::SetDlgItemText(
|
|
hwnd,
|
|
IDC_DHCP_SCOPE_STATIC,
|
|
authorizedScopesText);
|
|
}
|
|
}
|
|
|
|
bool
|
|
ExpressRebootPage::OnMessage(
|
|
UINT message,
|
|
WPARAM wparam,
|
|
LPARAM lparam)
|
|
{
|
|
// LOG_FUNCTION(ExpressRebootPage::OnMessage);
|
|
|
|
bool result = false;
|
|
|
|
CYS_OPERATION_TYPES finishedOperation = static_cast<CYS_OPERATION_TYPES>(wparam);
|
|
CYS_OPERATION_TYPES nextOperation = static_cast<CYS_OPERATION_TYPES>(lparam);
|
|
|
|
switch (message)
|
|
{
|
|
case CYS_OPERATION_FINISHED_SUCCESS:
|
|
SetOperationState(
|
|
OPERATION_STATE_FINISHED_SUCCESS,
|
|
finishedOperation,
|
|
nextOperation);
|
|
|
|
result = true;
|
|
break;
|
|
|
|
case CYS_OPERATION_FINISHED_FAILED:
|
|
SetOperationState(
|
|
OPERATION_STATE_FINISHED_FAILED,
|
|
finishedOperation,
|
|
nextOperation);
|
|
|
|
result = true;
|
|
break;
|
|
|
|
case CYS_OPERATION_COMPLETE_SUCCESS:
|
|
{
|
|
// enable the Next button
|
|
|
|
Win::PropSheet_SetWizButtons(
|
|
Win::GetParent(hwnd),
|
|
PSWIZB_NEXT);
|
|
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
IDC_EXPRESS_CONFIG_DONE_STATIC),
|
|
true);
|
|
|
|
result = true;
|
|
threadDone = true;
|
|
|
|
InstallationUnitProvider::GetInstance().
|
|
GetExpressInstallationUnit().SetInstallResult(INSTALL_SUCCESS);
|
|
}
|
|
break;
|
|
|
|
case CYS_OPERATION_COMPLETE_FAILED:
|
|
{
|
|
// enable the Next button
|
|
|
|
Win::PropSheet_SetWizButtons(
|
|
Win::GetParent(hwnd),
|
|
PSWIZB_NEXT);
|
|
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
IDC_EXPRESS_CONFIG_DONE_STATIC),
|
|
true);
|
|
|
|
result = true;
|
|
threadDone = true;
|
|
|
|
InstallationUnitProvider::GetInstance().
|
|
GetExpressInstallationUnit().SetInstallResult(INSTALL_FAILURE);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
result =
|
|
CYSWizardPage::OnMessage(
|
|
message,
|
|
wparam,
|
|
lparam);
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void
|
|
ExpressRebootPage::SetOperationState(
|
|
OperationStateType state,
|
|
CYS_OPERATION_TYPES currentOperation,
|
|
CYS_OPERATION_TYPES nextOperation)
|
|
{
|
|
LOG_FUNCTION(ExpressRebootPage::SetOperationState);
|
|
|
|
switch (state)
|
|
{
|
|
case OPERATION_STATE_UNKNOWN:
|
|
if (currentOperation < CYS_OPERATION_END)
|
|
{
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
pageOperationProgress[currentOperation].currentIconControl),
|
|
SW_HIDE);
|
|
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
pageOperationProgress[currentOperation].checkIconControl),
|
|
SW_HIDE);
|
|
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
pageOperationProgress[currentOperation].errorIconControl),
|
|
SW_HIDE);
|
|
}
|
|
|
|
if (nextOperation < CYS_OPERATION_END)
|
|
{
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
pageOperationProgress[nextOperation].currentIconControl),
|
|
SW_HIDE);
|
|
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
pageOperationProgress[nextOperation].checkIconControl),
|
|
SW_HIDE);
|
|
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
pageOperationProgress[nextOperation].errorIconControl),
|
|
SW_HIDE);
|
|
}
|
|
break;
|
|
|
|
case OPERATION_STATE_FINISHED_SUCCESS:
|
|
if (currentOperation < CYS_OPERATION_END)
|
|
{
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
pageOperationProgress[currentOperation].currentIconControl),
|
|
SW_HIDE);
|
|
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
pageOperationProgress[currentOperation].errorIconControl),
|
|
SW_HIDE);
|
|
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
pageOperationProgress[currentOperation].checkIconControl),
|
|
SW_SHOW);
|
|
}
|
|
|
|
if (nextOperation < CYS_OPERATION_END)
|
|
{
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
pageOperationProgress[nextOperation].checkIconControl),
|
|
SW_HIDE);
|
|
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
pageOperationProgress[nextOperation].errorIconControl),
|
|
SW_HIDE);
|
|
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
pageOperationProgress[nextOperation].currentIconControl),
|
|
SW_SHOW);
|
|
|
|
}
|
|
|
|
// Update the progress bar
|
|
|
|
Win::SendMessage(
|
|
Win::GetDlgItem(hwnd, IDC_CONFIG_PROGRESS),
|
|
PBM_STEPIT,
|
|
0,
|
|
0);
|
|
|
|
break;
|
|
|
|
case OPERATION_STATE_FINISHED_FAILED:
|
|
if (currentOperation < CYS_OPERATION_END)
|
|
{
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
pageOperationProgress[currentOperation].currentIconControl),
|
|
SW_HIDE);
|
|
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
pageOperationProgress[currentOperation].checkIconControl),
|
|
SW_HIDE);
|
|
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
pageOperationProgress[currentOperation].errorIconControl),
|
|
SW_SHOW);
|
|
}
|
|
|
|
if (nextOperation < CYS_OPERATION_END)
|
|
{
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
pageOperationProgress[nextOperation].checkIconControl),
|
|
SW_HIDE);
|
|
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
pageOperationProgress[nextOperation].errorIconControl),
|
|
SW_HIDE);
|
|
|
|
Win::ShowWindow(
|
|
Win::GetDlgItem(
|
|
hwnd,
|
|
pageOperationProgress[nextOperation].currentIconControl),
|
|
SW_SHOW);
|
|
}
|
|
|
|
// Update the progress bar
|
|
|
|
Win::SendMessage(
|
|
Win::GetDlgItem(hwnd, IDC_CONFIG_PROGRESS),
|
|
PBM_STEPIT,
|
|
0,
|
|
0);
|
|
|
|
break;
|
|
|
|
default:
|
|
// Right now I am not handling the CYS_OPERATION_COMPLETED_* messages
|
|
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
void
|
|
ExpressRebootPage::ClearOperationStates()
|
|
{
|
|
LOG_FUNCTION(ExpressRebootPage::ClearOperationStates);
|
|
|
|
SetOperationState(
|
|
OPERATION_STATE_UNKNOWN,
|
|
CYS_OPERATION_SET_STATIC_IP,
|
|
CYS_OPERATION_SERVER_DHCP);
|
|
|
|
SetOperationState(
|
|
OPERATION_STATE_UNKNOWN,
|
|
CYS_OPERATION_SERVER_AD,
|
|
CYS_OPERATION_SERVER_DNS);
|
|
|
|
SetOperationState(
|
|
OPERATION_STATE_UNKNOWN,
|
|
CYS_OPERATION_SET_DNS_FORWARDER,
|
|
CYS_OPERATION_ACTIVATE_DHCP_SCOPE);
|
|
|
|
SetOperationState(
|
|
OPERATION_STATE_UNKNOWN,
|
|
CYS_OPERATION_AUTHORIZE_DHCP_SERVER,
|
|
CYS_OPERATION_CREATE_TAPI_PARTITION);
|
|
}
|
|
|
|
int
|
|
ExpressRebootPage::Validate()
|
|
{
|
|
LOG_FUNCTION(ExpressRebootPage::Validate);
|
|
|
|
int nextPage = IDD_FINISH_PAGE;
|
|
|
|
return nextPage;
|
|
}
|
|
|
|
String
|
|
ExpressRebootPage::GetIPAddressString() const
|
|
{
|
|
LOG_FUNCTION(ExpressRebootPage::GetIPAddressString);
|
|
|
|
String result = ipaddressString;
|
|
|
|
LOG(result);
|
|
|
|
return result;
|
|
}
|