1391 lines
37 KiB
C++
1391 lines
37 KiB
C++
// Copyright (c) 1997-1999 Microsoft Corporation
|
|
//
|
|
// DS API wrappers
|
|
//
|
|
// 12-16-97 sburns
|
|
|
|
|
|
|
|
#include "headers.hxx"
|
|
#include "ds.hpp"
|
|
#include "resource.h"
|
|
#include "state.hpp"
|
|
#include "common.hpp"
|
|
#include "ProgressDialog.hpp"
|
|
|
|
|
|
|
|
// CODEWORK: remove the exception throwing architecture.
|
|
|
|
|
|
|
|
DS::Error::Error(HRESULT hr_, int summaryResID)
|
|
:
|
|
Win::Error(hr_, summaryResID)
|
|
{
|
|
}
|
|
|
|
|
|
|
|
DS::Error::Error(HRESULT hr_, const String& msg, const String& sum)
|
|
:
|
|
Win::Error(hr_, msg, sum)
|
|
{
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
DS::IsDomainNameInUse(const String& domainName)
|
|
{
|
|
LOG_FUNCTION(DS::IsDomainNameInUse);
|
|
ASSERT(!domainName.empty());
|
|
|
|
bool result = false;
|
|
if (!domainName.empty())
|
|
{
|
|
HRESULT hr = MyNetValidateName(domainName, ::NetSetupNonExistentDomain);
|
|
if (hr == Win32ToHresult(ERROR_DUP_NAME))
|
|
{
|
|
result = true;
|
|
}
|
|
}
|
|
|
|
LOG(
|
|
String::format(
|
|
L"The domain name %1 %2 in use.",
|
|
domainName.c_str(),
|
|
result ? L"is" : L"is NOT"));
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
DS::DisjoinDomain()
|
|
throw (DS::Error)
|
|
{
|
|
LOG_FUNCTION(DS::DisjoinDomain);
|
|
|
|
// make 1st attempt assuming that the current user has account
|
|
// deletion priv on the domain.
|
|
|
|
LOG(L"Calling NetUnjoinDomain (w/ account delete)");
|
|
|
|
HRESULT hr =
|
|
Win32ToHresult(
|
|
::NetUnjoinDomain(
|
|
0, // this server
|
|
0, // current account,
|
|
0, // current password
|
|
NETSETUP_ACCT_DELETE));
|
|
|
|
LOG_HRESULT(hr);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
// make another attempt, not removing the computer account
|
|
|
|
LOG(L"Calling NetUnjoinDomain again, w/o account delete");
|
|
|
|
hr = Win32ToHresult(::NetUnjoinDomain(0, 0, 0, 0));
|
|
|
|
LOG_HRESULT(hr);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// the unjoin was successful, but the computer account was
|
|
// left behind.
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
throw DS::Error(hr, IDS_DISJOIN_DOMAIN_FAILED);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
void
|
|
DS::JoinDomain(
|
|
const String& domainDNSName,
|
|
const String& dcName,
|
|
const String& userName,
|
|
const EncodedString& password,
|
|
const String& userDomainName)
|
|
throw (DS::Error)
|
|
{
|
|
LOG_FUNCTION(DS::JoinDomain);
|
|
ASSERT(!domainDNSName.empty());
|
|
ASSERT(!userName.empty());
|
|
|
|
// password may be empty
|
|
|
|
ULONG flags =
|
|
NETSETUP_JOIN_DOMAIN
|
|
| NETSETUP_ACCT_CREATE
|
|
| NETSETUP_DOMAIN_JOIN_IF_JOINED
|
|
| NETSETUP_ACCT_DELETE;
|
|
|
|
String massagedUserName = MassageUserName(userDomainName, userName);
|
|
String domain = domainDNSName;
|
|
|
|
if (!dcName.empty())
|
|
{
|
|
domain += L"\\" + dcName;
|
|
}
|
|
|
|
WCHAR* cleartext = password.GetDecodedCopy();
|
|
|
|
HRESULT hr =
|
|
MyNetJoinDomain(
|
|
domain.c_str(),
|
|
massagedUserName.c_str(),
|
|
cleartext,
|
|
flags);
|
|
|
|
::ZeroMemory(cleartext, sizeof(WCHAR) * password.GetLength());
|
|
delete[] cleartext;
|
|
|
|
LOG_HRESULT(hr);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
State& state = State::GetInstance();
|
|
state.SetOperationResultsMessage(
|
|
String::format(IDS_UNABLE_TO_JOIN_DOMAIN, domainDNSName.c_str()));
|
|
|
|
throw DS::Error(hr, IDS_JOIN_DOMAIN_FAILED);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
MyDsRoleCancel(DSROLE_SERVEROP_HANDLE& handle)
|
|
{
|
|
LOG(L"Calling DsRoleCancel");
|
|
LOG(L"lpServer : (null)");
|
|
|
|
DWORD status = ::DsRoleCancel(0, handle);
|
|
|
|
LOG(String::format(L"Error 0x%1!X! (!0 => error)", status));
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
MyDsRoleGetDcOperationProgress(
|
|
DSROLE_SERVEROP_HANDLE& handle,
|
|
DSROLE_SERVEROP_STATUS*& status)
|
|
{
|
|
// LOG(L"Calling DsRoleGetDcOperationProgress");
|
|
|
|
status = 0;
|
|
DWORD err = ::DsRoleGetDcOperationProgress(0, handle, &status);
|
|
|
|
// LOG(
|
|
// String::format(
|
|
// L"Error 0x%1!X! (!0 => error, 0x%2!X! = ERROR_IO_PENDING)",
|
|
// err,
|
|
// ERROR_IO_PENDING));
|
|
|
|
// if (status)
|
|
// {
|
|
// LOG(
|
|
// String::format(
|
|
// L"OperationStatus : 0x%1!X!",
|
|
// status->OperationStatus));
|
|
// LOG(status->CurrentOperationDisplayString);
|
|
// }
|
|
|
|
// DWORD err = ERROR_IO_PENDING;
|
|
// status = new DSROLE_SERVEROP_STATUS;
|
|
// status->CurrentOperationDisplayString = L"proceeding";
|
|
// status->OperationStatus = 0;
|
|
|
|
return err;
|
|
}
|
|
|
|
|
|
|
|
void
|
|
DoProgressLoop(
|
|
DSROLE_SERVEROP_HANDLE& handle,
|
|
ProgressDialog& progressDialog)
|
|
throw (DS::Error)
|
|
{
|
|
LOG_FUNCTION(DoProgressLoop);
|
|
|
|
State& state = State::GetInstance();
|
|
|
|
if (state.GetOperation() == State::DEMOTE)
|
|
{
|
|
// not cancelable -- turn off the cancel button.
|
|
|
|
progressDialog.UpdateButton(String());
|
|
}
|
|
else
|
|
{
|
|
// turn on the cancel button.
|
|
|
|
progressDialog.UpdateButton(IDS_PROGRESS_CANCEL);
|
|
}
|
|
|
|
DWORD netErr = 0;
|
|
bool criticalComplete = false;
|
|
bool buttonUpdatedToFinishLater = false;
|
|
String lastMessage;
|
|
ProgressDialog::WaitCode cancelButton;
|
|
|
|
do
|
|
{
|
|
// wait 1500ms or for the user to hit cancel
|
|
|
|
cancelButton = progressDialog.WaitForButton(1500);
|
|
|
|
// get the current status of the operation
|
|
|
|
DSROLE_SERVEROP_STATUS* status = 0;
|
|
netErr = MyDsRoleGetDcOperationProgress(handle, status);
|
|
|
|
if (netErr != ERROR_SUCCESS && netErr != ERROR_IO_PENDING)
|
|
{
|
|
// operation complete
|
|
|
|
break;
|
|
}
|
|
|
|
if (!status)
|
|
{
|
|
LOG(L"Operation status not returned!");
|
|
ASSERT(false);
|
|
continue;
|
|
}
|
|
|
|
// update the message display
|
|
|
|
String message = status->CurrentOperationDisplayString;
|
|
if (message != lastMessage)
|
|
{
|
|
progressDialog.UpdateText(message);
|
|
lastMessage = message;
|
|
}
|
|
|
|
// save the status flags for later use.
|
|
|
|
ULONG statusFlags = status->OperationStatus;
|
|
|
|
::DsRoleFreeMemory(status);
|
|
|
|
do
|
|
{
|
|
if (cancelButton != ProgressDialog::PRESSED)
|
|
{
|
|
break;
|
|
}
|
|
|
|
// if we make it here, user pressed the cancel button
|
|
|
|
LOG(L"DoProgressLoop: handling cancel");
|
|
|
|
ASSERT(state.GetOperation() != State::DEMOTE);
|
|
|
|
if (criticalComplete)
|
|
{
|
|
// inform the user that the install is done, and that they're
|
|
// cancelling the non-critical replication.
|
|
|
|
popup.Info(
|
|
progressDialog.GetHWND(),
|
|
String::load(IDS_CANCEL_NON_CRITICAL_REPLICATION));
|
|
|
|
// this should return ERROR_SUCCESS, and the promotion will
|
|
// be considered complete.
|
|
|
|
progressDialog.UpdateText(IDS_CANCELLING_REPLICATION);
|
|
netErr = MyDsRoleCancel(handle);
|
|
|
|
// fall out of the inner, then the outer, loop. Then we will
|
|
// get the operation results, which should indicate that the
|
|
// promotion is complete, and non-critical replication was
|
|
// canceled.
|
|
|
|
break;
|
|
}
|
|
|
|
// Still doing promote, verify that the user really wants to roll
|
|
// back to server state.
|
|
|
|
if (
|
|
popup.MessageBox(
|
|
progressDialog.GetHWND(),
|
|
String::load(IDS_CANCEL_PROMOTE),
|
|
MB_YESNO | MB_ICONWARNING) == IDYES)
|
|
{
|
|
// this should return ERROR_SUCCESS, and the promotion will
|
|
// be rolled back.
|
|
|
|
progressDialog.UpdateText(IDS_CANCELLING);
|
|
netErr = MyDsRoleCancel(handle);
|
|
|
|
// fall out of the inner, then the outer, loop. Then we will
|
|
// get the operation results, which should indicate that the
|
|
// promotion was cancelled as a failure code. We handle this
|
|
// failure code in the same manner as all others.
|
|
|
|
break;
|
|
}
|
|
|
|
// user decided to press on. reset the cancel button
|
|
|
|
progressDialog.UpdateButton(IDS_PROGRESS_CANCEL);
|
|
buttonUpdatedToFinishLater = false;
|
|
}
|
|
while (0);
|
|
|
|
criticalComplete =
|
|
criticalComplete
|
|
|| statusFlags & DSROLE_CRITICAL_OPERATIONS_COMPLETED;
|
|
|
|
if (criticalComplete)
|
|
{
|
|
if (cancelButton == ProgressDialog::PRESSED)
|
|
{
|
|
// we add this message without actually checking the operation
|
|
// results flags because for all we know, the replication will
|
|
// finish before we get around to checking. It is still correct
|
|
// to say the the replication has stopped, and will start after
|
|
// reboot. This is always the case.
|
|
|
|
state.AddFinishMessage(
|
|
String::load(IDS_NON_CRITICAL_REPLICATION_CANCELED));
|
|
}
|
|
else
|
|
{
|
|
if (!buttonUpdatedToFinishLater)
|
|
{
|
|
progressDialog.UpdateButton(IDS_FINISH_REPLICATION_LATER);
|
|
buttonUpdatedToFinishLater = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
while (netErr == ERROR_IO_PENDING);
|
|
|
|
progressDialog.UpdateButton(String());
|
|
buttonUpdatedToFinishLater = false;
|
|
|
|
LOG(L"Progress loop complete.");
|
|
|
|
if (netErr == ERROR_SUCCESS)
|
|
{
|
|
// we successfully endured the wait. let's see how it turned out.
|
|
|
|
DSROLE_SERVEROP_RESULTS* results;
|
|
|
|
LOG(L"Calling DsRoleGetDcOperationResults");
|
|
|
|
netErr = ::DsRoleGetDcOperationResults(0, handle, &results);
|
|
|
|
LOG(String::format(L"Error 0x%1!X! (!0 => error)", netErr));
|
|
|
|
if (netErr == ERROR_SUCCESS)
|
|
{
|
|
// we got the results
|
|
|
|
ASSERT(results);
|
|
if (results)
|
|
{
|
|
LOG(L"Operation results:");
|
|
LOG(
|
|
String::format(
|
|
L"OperationStatus : 0x%1!X! !0 => error",
|
|
results->OperationStatus));
|
|
LOG(
|
|
String::format(
|
|
L"DisplayString : %1",
|
|
results->OperationStatusDisplayString));
|
|
LOG(
|
|
String::format(
|
|
L"ServerInstalledSite : %1",
|
|
results->ServerInstalledSite));
|
|
LOG(
|
|
String::format(
|
|
L"OperationResultsFlags: 0x%1!X!",
|
|
results->OperationResultsFlags));
|
|
|
|
netErr = results->OperationStatus;
|
|
|
|
// here, netErr will be some error code if the promote was
|
|
// cancelled and successfully rolled back. Since it may be
|
|
// possible that the cancel was too late (e.g. the user took
|
|
// too long to confirm the cancel), the promote may have
|
|
// finished. If that's the case, tell the user that the cancel
|
|
// failed.
|
|
|
|
if (
|
|
netErr == ERROR_SUCCESS
|
|
&& cancelButton == ProgressDialog::PRESSED)
|
|
{
|
|
// the promote finished, and the cancel button was pressed.
|
|
|
|
if (!criticalComplete) // 363590
|
|
{
|
|
// we didn't find out if the non-critical replication phase
|
|
// started. So the cancel button still said 'Cancel', and
|
|
// yet, the operation finished. so, this means that the
|
|
// promote simply completed before the cancel was received.
|
|
|
|
popup.Info(
|
|
progressDialog.GetHWND(),
|
|
IDS_CANCEL_TOO_LATE);
|
|
}
|
|
}
|
|
|
|
String message =
|
|
results->OperationStatusDisplayString
|
|
? results->OperationStatusDisplayString
|
|
: L"";
|
|
String site =
|
|
results->ServerInstalledSite
|
|
? results->ServerInstalledSite
|
|
: L"";
|
|
|
|
progressDialog.UpdateText(message);
|
|
|
|
if (!site.empty())
|
|
{
|
|
state.SetInstalledSite(site);
|
|
}
|
|
if (!message.empty())
|
|
{
|
|
state.SetOperationResultsMessage(message);
|
|
}
|
|
|
|
state.SetOperationResultsFlags(results->OperationResultsFlags);
|
|
|
|
if (
|
|
results->OperationResultsFlags
|
|
& DSROLE_NON_FATAL_ERROR_OCCURRED)
|
|
{
|
|
state.AddFinishMessage(
|
|
String::load(IDS_NON_FATAL_ERRORS_OCCURRED));
|
|
}
|
|
if (
|
|
(results->OperationResultsFlags
|
|
& DSROLE_NON_CRITICAL_REPL_NOT_FINISHED)
|
|
&& cancelButton != ProgressDialog::PRESSED )
|
|
{
|
|
// cancel not pressed and critial replication bombed
|
|
|
|
state.AddFinishMessage(
|
|
String::load(IDS_NON_CRITICAL_REPL_FAILED));
|
|
}
|
|
if (
|
|
results->OperationResultsFlags
|
|
& DSROLE_IFM_RESTORED_DATABASE_FILES_MOVED)
|
|
{
|
|
LOG(L"restored files were moved");
|
|
|
|
if (netErr != ERROR_SUCCESS)
|
|
{
|
|
// only need to mention this in the case of a fatal failure;
|
|
// e.g. don't add this finish text if non-fatal errors
|
|
// occurred.
|
|
// NTRAID#NTBUG9-330378-2001/02/28-sburns
|
|
|
|
state.AddFinishMessage(
|
|
String::load(IDS_MUST_RESTORE_IFM_FILES_AGAIN));
|
|
}
|
|
}
|
|
|
|
::DsRoleFreeMemory(results);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (netErr != ERROR_SUCCESS)
|
|
{
|
|
// couldn't get progress updates, or couldn't get results,
|
|
// or result was a failure
|
|
|
|
throw DS::Error(Win32ToHresult(netErr), IDS_SET_ROLE_AS_DC_FAILED);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void
|
|
EmptyFolder(const String& path)
|
|
throw (DS::Error)
|
|
{
|
|
LOG_FUNCTION2(EmptyFolder, path);
|
|
ASSERT(!path.empty());
|
|
|
|
// check for files/subfolders once again (we checked the first time on
|
|
// validating the path), in case something has written to the folder
|
|
// since we validated it last.
|
|
|
|
if (!FS::IsFolderEmpty(path))
|
|
{
|
|
// nuke the files in the directory
|
|
|
|
LOG(String::format(L"Emptying %1", path.c_str()));
|
|
|
|
String wild = path;
|
|
|
|
if (wild[wild.length() - 1] != L'\\')
|
|
{
|
|
wild += L"\\";
|
|
}
|
|
|
|
wild += L"*.*";
|
|
|
|
FS::Iterator iter(
|
|
wild,
|
|
FS::Iterator::INCLUDE_FILES
|
|
| FS::Iterator::RETURN_FULL_PATHS);
|
|
|
|
HRESULT hr = S_OK;
|
|
String current;
|
|
|
|
while ((hr = iter.GetCurrent(current)) == S_OK)
|
|
{
|
|
LOG(String::format(L"Deleting %1", current.c_str()));
|
|
|
|
hr = Win::DeleteFile(current);
|
|
if (FAILED(hr))
|
|
{
|
|
int msgId = IDS_EMPTY_DIR_FAILED;
|
|
|
|
if (hr == Win32ToHresult(ERROR_ACCESS_DENIED))
|
|
{
|
|
msgId = IDS_EMPTY_DIR_FAILED_ACCESS_DENIED;
|
|
}
|
|
|
|
throw
|
|
DS::Error(
|
|
S_OK, // so as not to trigger credentials dialog
|
|
String::format(
|
|
msgId,
|
|
GetErrorMessage(hr).c_str(),
|
|
path.c_str()),
|
|
String::load(IDS_ERROR_PREPARING_OPERATION));
|
|
}
|
|
|
|
hr = iter.Increment();
|
|
BREAK_ON_FAILED_HRESULT(hr);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
HRESULT
|
|
SetupPaths()
|
|
{
|
|
LOG_FUNCTION(SetupPaths);
|
|
|
|
State& state = State::GetInstance();
|
|
String dbPath = state.GetDatabasePath();
|
|
String logPath = state.GetLogPath();
|
|
String sysvolPath = state.GetSYSVOLPath();
|
|
|
|
ASSERT(!dbPath.empty());
|
|
ASSERT(!logPath.empty());
|
|
ASSERT(!sysvolPath.empty());
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
do
|
|
{
|
|
if (FS::PathExists(dbPath))
|
|
{
|
|
EmptyFolder(dbPath);
|
|
}
|
|
else
|
|
{
|
|
hr = FS::CreateFolder(dbPath);
|
|
BREAK_ON_FAILED_HRESULT(hr);
|
|
}
|
|
|
|
if (FS::PathExists(logPath))
|
|
{
|
|
EmptyFolder(logPath);
|
|
}
|
|
else
|
|
{
|
|
hr = FS::CreateFolder(logPath);
|
|
BREAK_ON_FAILED_HRESULT(hr);
|
|
}
|
|
|
|
if (FS::PathExists(sysvolPath))
|
|
{
|
|
EmptyFolder(sysvolPath);
|
|
}
|
|
else
|
|
{
|
|
hr = FS::CreateFolder(sysvolPath);
|
|
BREAK_ON_FAILED_HRESULT(hr);
|
|
}
|
|
}
|
|
while (0);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
// Sets the promotion flags based on options set in the unattended execution
|
|
// answerfile.
|
|
//
|
|
// state - IN reference to the global State object
|
|
//
|
|
// flags - IN/OUT promote API flags, may be modified on exit
|
|
|
|
void
|
|
SetAnswerFilePromoteFlags(
|
|
State& state,
|
|
ULONG& flags)
|
|
{
|
|
LOG_FUNCTION(SetAnswerFilePromoteFlags);
|
|
|
|
if (state.UsingAnswerFile())
|
|
{
|
|
// set flags based on unattended execution options
|
|
|
|
// if the safe mode admin password is not specified, then we set a
|
|
// flag to cause the promote APIs to copy the current local admin
|
|
// password.
|
|
|
|
EncodedString safeModePassword = state.GetSafeModeAdminPassword();
|
|
|
|
if (safeModePassword.IsEmpty() && state.RunHiddenUnattended())
|
|
{
|
|
// user did not supply a safemode password, and he did not have
|
|
// an opportunity to do so (if the wizard went interactive)
|
|
|
|
if (!state.IsSafeModeAdminPwdOptionPresent())
|
|
{
|
|
// the safe mode pwd key is not present in the answerfile
|
|
|
|
flags |= DSROLE_DC_DEFAULT_REPAIR_PWD;
|
|
}
|
|
}
|
|
|
|
String option =
|
|
state.GetAnswerFileOption(State::OPTION_CRITICAL_REPLICATION_ONLY);
|
|
if (option.icompare(State::VALUE_YES) == 0)
|
|
{
|
|
flags |= DSROLE_DC_CRITICAL_REPLICATION_ONLY;
|
|
}
|
|
}
|
|
|
|
LOG(String::format(L"0x%1!X!", flags));
|
|
}
|
|
|
|
|
|
|
|
void
|
|
DS::CreateReplica(ProgressDialog& progressDialog, bool invokeForUpgrade)
|
|
throw (DS::Error)
|
|
{
|
|
LOG_FUNCTION(DS::CreateReplica);
|
|
|
|
State& state = State::GetInstance();
|
|
|
|
String domain = state.GetReplicaDomainDNSName();
|
|
String dbPath = state.GetDatabasePath();
|
|
String logPath = state.GetLogPath();
|
|
String sysvolPath = state.GetSYSVOLPath();
|
|
String site = state.GetSiteName();
|
|
String username = state.GetUsername();
|
|
String replicationDc = state.GetReplicationPartnerDC();
|
|
String sourcePath = state.GetReplicationSourcePath();
|
|
bool useSourcePath = state.ReplicateFromMedia();
|
|
|
|
EncodedString syskey = state.GetSyskey();
|
|
EncodedString safeModePassword = state.GetSafeModeAdminPassword();
|
|
EncodedString password = state.GetPassword();
|
|
|
|
bool useCurrentUserCreds = username.empty();
|
|
ULONG flags =
|
|
DSROLE_DC_FORCE_TIME_SYNC
|
|
| DSROLE_DC_CREATE_TRUST_AS_REQUIRED;
|
|
|
|
if (invokeForUpgrade)
|
|
{
|
|
flags |= DSROLE_DC_DOWNLEVEL_UPGRADE;
|
|
}
|
|
if (state.GetDomainControllerReinstallFlag())
|
|
{
|
|
flags |= DSROLE_DC_ALLOW_DC_REINSTALL;
|
|
}
|
|
|
|
SetAnswerFilePromoteFlags(state, flags);
|
|
|
|
if (useSourcePath)
|
|
{
|
|
if (state.GetRestoreGc())
|
|
{
|
|
flags |= DSROLE_DC_REQUEST_GC;
|
|
}
|
|
}
|
|
|
|
ASSERT(!domain.empty());
|
|
|
|
if (!useCurrentUserCreds)
|
|
{
|
|
String user_domain = state.GetUserDomainName();
|
|
username = MassageUserName(user_domain, username);
|
|
}
|
|
|
|
HRESULT hr = S_OK;
|
|
do
|
|
{
|
|
hr = SetupPaths();
|
|
BREAK_ON_FAILED_HRESULT(hr);
|
|
|
|
LOG(L"Calling DsRoleDcAsReplica");
|
|
LOG( L"lpServer : (null)");
|
|
LOG(String::format(L"lpDnsDomainName : %1", domain.c_str()));
|
|
LOG(String::format(L"lpReplicaServer : %1", replicationDc.empty() ? L"(null)" : replicationDc.c_str()));
|
|
LOG(String::format(L"lpSiteName : %1", site.empty() ? L"(null)" : site.c_str()));
|
|
LOG(String::format(L"lpDsDatabasePath : %1", dbPath.c_str()));
|
|
LOG(String::format(L"lpDsLogPath : %1", logPath.c_str()));
|
|
LOG(String::format(L"lpRestorePath : %1", useSourcePath ? sourcePath.c_str() : L"(null)"));
|
|
LOG(String::format(L"lpSystemVolumeRootPath : %1", sysvolPath.c_str()));
|
|
LOG(String::format(L"lpAccount : %1", useCurrentUserCreds ? L"(null)" : username.c_str()));
|
|
LOG(String::format(L"Options : 0x%1!X!", flags));
|
|
|
|
WCHAR* safeModePasswordCopy = 0;
|
|
if (!safeModePassword.IsEmpty())
|
|
{
|
|
safeModePasswordCopy = safeModePassword.GetDecodedCopy();
|
|
}
|
|
|
|
WCHAR* passwordCopy = 0;
|
|
if (!useCurrentUserCreds)
|
|
{
|
|
passwordCopy = password.GetDecodedCopy();
|
|
}
|
|
|
|
// The api wants to scribble over the syskey, so we make a copy for
|
|
// it to do so.
|
|
|
|
WCHAR* syskeyCopy = 0;
|
|
if (useSourcePath && !syskey.IsEmpty())
|
|
{
|
|
syskeyCopy = syskey.GetDecodedCopy();
|
|
}
|
|
|
|
DSROLE_SERVEROP_HANDLE handle = 0;
|
|
hr =
|
|
Win32ToHresult(
|
|
::DsRoleDcAsReplica(
|
|
0, // this server
|
|
domain.c_str(),
|
|
|
|
// possibly empty, e.g. if we didn't join a domain...
|
|
|
|
replicationDc.empty() ? 0 : replicationDc.c_str(),
|
|
site.empty() ? 0 : site.c_str(),
|
|
dbPath.c_str(),
|
|
logPath.c_str(),
|
|
useSourcePath ? sourcePath.c_str() : 0,
|
|
sysvolPath.c_str(),
|
|
syskeyCopy,
|
|
(useCurrentUserCreds ? 0 : username.c_str()),
|
|
passwordCopy,
|
|
safeModePasswordCopy,
|
|
flags,
|
|
&handle));
|
|
|
|
if (safeModePasswordCopy)
|
|
{
|
|
::ZeroMemory(
|
|
safeModePasswordCopy,
|
|
sizeof(WCHAR) * safeModePassword.GetLength());
|
|
delete[] safeModePasswordCopy;
|
|
}
|
|
|
|
if (passwordCopy)
|
|
{
|
|
::ZeroMemory(passwordCopy, sizeof(WCHAR) * password.GetLength());
|
|
delete[] passwordCopy;
|
|
}
|
|
|
|
// the copy of the syskey has already been scribbled on, so just
|
|
// delete it.
|
|
|
|
delete[] syskeyCopy;
|
|
|
|
BREAK_ON_FAILED_HRESULT(hr);
|
|
|
|
DoProgressLoop(handle, progressDialog);
|
|
}
|
|
while (0);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
throw DS::Error(hr, IDS_SET_ROLE_AS_DC_FAILED);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void
|
|
DS::CreateNewDomain(ProgressDialog& progressDialog)
|
|
throw (DS::Error)
|
|
{
|
|
LOG_FUNCTION(DS::CreateNewDomain);
|
|
|
|
State& state = State::GetInstance();
|
|
|
|
String domain = state.GetNewDomainDNSName();
|
|
String flatName = state.GetNewDomainNetbiosName();
|
|
String site = state.GetSiteName();
|
|
String dbPath = state.GetDatabasePath();
|
|
String logPath = state.GetLogPath();
|
|
String sysvolPath = state.GetSYSVOLPath();
|
|
String parent = state.GetParentDomainDnsName();
|
|
String username = state.GetUsername();
|
|
|
|
EncodedString password = state.GetPassword();
|
|
EncodedString safeModePassword = state.GetSafeModeAdminPassword();
|
|
EncodedString adminPassword = state.GetAdminPassword();
|
|
|
|
State::Operation operation = state.GetOperation();
|
|
bool useParent =
|
|
( operation == State::TREE
|
|
|| operation == State::CHILD);
|
|
bool useCurrentUserCreds = username.empty();
|
|
|
|
ULONG flags =
|
|
DSROLE_DC_CREATE_TRUST_AS_REQUIRED
|
|
| DSROLE_DC_FORCE_TIME_SYNC;
|
|
|
|
if (state.GetDomainReinstallFlag())
|
|
{
|
|
flags |= DSROLE_DC_ALLOW_DOMAIN_REINSTALL;
|
|
}
|
|
|
|
if (state.GetDomainControllerReinstallFlag())
|
|
{
|
|
flags |= DSROLE_DC_ALLOW_DC_REINSTALL;
|
|
}
|
|
|
|
if (operation == State::TREE)
|
|
{
|
|
flags |= DSROLE_DC_TRUST_AS_ROOT;
|
|
|
|
ASSERT(!parent.empty());
|
|
}
|
|
|
|
SetAnswerFilePromoteFlags(state, flags);
|
|
|
|
if (state.ShouldAllowAnonymousAccess())
|
|
{
|
|
flags |= DSROLE_DC_ALLOW_ANONYMOUS_ACCESS;
|
|
}
|
|
|
|
if (operation == State::FOREST)
|
|
{
|
|
flags |= DSROLE_DC_NO_NET;
|
|
|
|
ASSERT(!site.empty());
|
|
}
|
|
|
|
#ifdef DBG
|
|
|
|
else if (operation == State::CHILD)
|
|
{
|
|
ASSERT(!parent.empty());
|
|
}
|
|
|
|
ASSERT(!domain.empty());
|
|
ASSERT(!flatName.empty());
|
|
|
|
// parent may be empty
|
|
|
|
#endif
|
|
|
|
if (!useCurrentUserCreds)
|
|
{
|
|
String userDomain = state.GetUserDomainName();
|
|
username = MassageUserName(userDomain, username);
|
|
}
|
|
|
|
HRESULT hr = S_OK;
|
|
do
|
|
{
|
|
hr = SetupPaths();
|
|
BREAK_ON_FAILED_HRESULT(hr);
|
|
|
|
LOG(L"Calling DsRoleDcAsDc");
|
|
LOG( L"lpServer : (null)");
|
|
LOG(String::format(L"lpDnsDomainName : %1", domain.c_str()));
|
|
LOG(String::format(L"lpFlatDomainName : %1", flatName.c_str()));
|
|
LOG(String::format(L"lpSiteName : %1", site.empty() ? L"(null)" : site.c_str()));
|
|
LOG(String::format(L"lpDsDatabasePath : %1", dbPath.c_str()));
|
|
LOG(String::format(L"lpDsLogPath : %1", logPath.c_str()));
|
|
LOG(String::format(L"lpSystemVolumeRootPath : %1", sysvolPath.c_str()));
|
|
LOG(String::format(L"lpParentDnsDomainName : %1", useParent ? parent.c_str() : L"(null)"));
|
|
LOG( L"lpParentServer : (null)");
|
|
LOG(String::format(L"lpAccount : %1", useCurrentUserCreds ? L"(null)" : username.c_str()));
|
|
LOG(String::format(L"Options : 0x%1!X!", flags));
|
|
|
|
WCHAR* safeModePasswordCopy = 0;
|
|
if (!safeModePassword.IsEmpty())
|
|
{
|
|
safeModePasswordCopy = safeModePassword.GetDecodedCopy();
|
|
}
|
|
|
|
WCHAR* adminPasswordCopy = 0;
|
|
if (!adminPassword.IsEmpty())
|
|
{
|
|
adminPasswordCopy = adminPassword.GetDecodedCopy();
|
|
}
|
|
|
|
WCHAR* passwordCopy = 0;
|
|
if (!useCurrentUserCreds)
|
|
{
|
|
passwordCopy = password.GetDecodedCopy();
|
|
}
|
|
|
|
DSROLE_SERVEROP_HANDLE handle = 0;
|
|
hr =
|
|
Win32ToHresult(
|
|
DsRoleDcAsDc(
|
|
0, // this server
|
|
domain.c_str(),
|
|
flatName.c_str(),
|
|
adminPasswordCopy,
|
|
site.empty() ? 0 : site.c_str(),
|
|
dbPath.c_str(),
|
|
logPath.c_str(),
|
|
sysvolPath.c_str(),
|
|
(useParent ? parent.c_str() : 0),
|
|
0, // let API pick a server
|
|
(useCurrentUserCreds ? 0 : username.c_str()),
|
|
passwordCopy,
|
|
safeModePasswordCopy,
|
|
flags,
|
|
&handle));
|
|
BREAK_ON_FAILED_HRESULT(hr);
|
|
|
|
if (safeModePasswordCopy)
|
|
{
|
|
::ZeroMemory(
|
|
safeModePasswordCopy,
|
|
sizeof(WCHAR) * safeModePassword.GetLength());
|
|
delete[] safeModePasswordCopy;
|
|
}
|
|
|
|
if (adminPasswordCopy)
|
|
{
|
|
::ZeroMemory(
|
|
adminPasswordCopy,
|
|
sizeof(WCHAR) * adminPassword.GetLength());
|
|
delete[] adminPasswordCopy;
|
|
}
|
|
|
|
if (passwordCopy)
|
|
{
|
|
::ZeroMemory(passwordCopy, sizeof(WCHAR) * password.GetLength());
|
|
delete[] passwordCopy;
|
|
}
|
|
|
|
DoProgressLoop(handle, progressDialog);
|
|
}
|
|
while (0);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
throw DS::Error(hr, IDS_SET_ROLE_AS_DC_FAILED);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void
|
|
DS::UpgradeBDC(ProgressDialog& progressDialog)
|
|
throw (DS::Error)
|
|
{
|
|
LOG_FUNCTION(DS::UpgradeBDC);
|
|
|
|
// seems non-intuitive to abort the upgrade to do the upgrade, but here
|
|
// the abort removes dcpromo autostart, and turns the machine into a
|
|
// standalone server. Then we proceed to make it a replica.
|
|
|
|
DS::AbortBDCUpgrade(true);
|
|
DS::CreateReplica(progressDialog, true);
|
|
}
|
|
|
|
|
|
|
|
void
|
|
DS::UpgradePDC(ProgressDialog& progressDialog)
|
|
throw (DS::Error)
|
|
{
|
|
LOG_FUNCTION(DS::UpgradePDC);
|
|
|
|
State& state = State::GetInstance();
|
|
ASSERT(state.GetRunContext() == State::PDC_UPGRADE);
|
|
|
|
String domain = state.GetNewDomainDNSName();
|
|
String site = state.GetSiteName();
|
|
String dbPath = state.GetDatabasePath();
|
|
String logPath = state.GetLogPath();
|
|
String sysvolPath = state.GetSYSVOLPath();
|
|
String parent = state.GetParentDomainDnsName();
|
|
String username = state.GetUsername();
|
|
|
|
EncodedString password = state.GetPassword();
|
|
EncodedString safeModePassword = state.GetSafeModeAdminPassword();
|
|
|
|
State::Operation operation = state.GetOperation();
|
|
bool useParent =
|
|
( operation == State::TREE
|
|
|| operation == State::CHILD);
|
|
bool useCurrentUserCreds = username.empty();
|
|
|
|
ULONG flags = DSROLE_DC_CREATE_TRUST_AS_REQUIRED;
|
|
|
|
if (state.GetDomainReinstallFlag())
|
|
{
|
|
flags |= DSROLE_DC_ALLOW_DOMAIN_REINSTALL;
|
|
}
|
|
|
|
if (state.GetDomainControllerReinstallFlag())
|
|
{
|
|
flags |= DSROLE_DC_ALLOW_DC_REINSTALL;
|
|
}
|
|
|
|
if (state.GetSetForestVersionFlag())
|
|
{
|
|
flags |= DSROLE_DC_SET_FOREST_CURRENT;
|
|
}
|
|
|
|
if (operation == State::TREE)
|
|
{
|
|
flags |= DSROLE_DC_TRUST_AS_ROOT | DSROLE_DC_FORCE_TIME_SYNC;
|
|
ASSERT(!parent.empty());
|
|
}
|
|
else if (operation == State::CHILD)
|
|
{
|
|
flags |= DSROLE_DC_FORCE_TIME_SYNC;
|
|
ASSERT(!parent.empty());
|
|
}
|
|
|
|
SetAnswerFilePromoteFlags(state, flags);
|
|
|
|
if (state.ShouldAllowAnonymousAccess())
|
|
{
|
|
flags |= DSROLE_DC_ALLOW_ANONYMOUS_ACCESS;
|
|
}
|
|
|
|
#ifdef DBG
|
|
ASSERT(!domain.empty());
|
|
|
|
// parent may be empty
|
|
|
|
if (operation == State::FOREST)
|
|
{
|
|
ASSERT(!site.empty());
|
|
}
|
|
#endif
|
|
|
|
if (!useCurrentUserCreds)
|
|
{
|
|
String userDomain = state.GetUserDomainName();
|
|
username = MassageUserName(userDomain, username);
|
|
}
|
|
|
|
HRESULT hr = S_OK;
|
|
do
|
|
{
|
|
hr = SetupPaths();
|
|
BREAK_ON_FAILED_HRESULT(hr);
|
|
|
|
LOG(L"Calling DsRoleUpgradeDownlevelServer");
|
|
LOG(String::format(L"lpDnsDomainName : %1", domain.c_str()));
|
|
LOG(String::format(L"lpSiteName : %1", site.empty() ? L"(null)" : site.c_str()));
|
|
LOG(String::format(L"lpDsDatabasePath : %1", dbPath.c_str()));
|
|
LOG(String::format(L"lpDsLogPath : %1", logPath.c_str()));
|
|
LOG(String::format(L"lpSystemVolumeRootPath : %1", sysvolPath.c_str()));
|
|
LOG(String::format(L"lpParentDnsDomainName : %1", useParent ? parent.c_str() : L"(null)"));
|
|
LOG( L"lpParentServer : (null)");
|
|
LOG(String::format(L"lpAccount : %1", useCurrentUserCreds ? L"(null)" : username.c_str()));
|
|
LOG(String::format(L"Options : 0x%1!X!", flags));
|
|
|
|
WCHAR* safeModePasswordCopy = 0;
|
|
if (!safeModePassword.IsEmpty())
|
|
{
|
|
safeModePasswordCopy = safeModePassword.GetDecodedCopy();
|
|
}
|
|
|
|
WCHAR* passwordCopy = 0;
|
|
if (!useCurrentUserCreds)
|
|
{
|
|
passwordCopy = password.GetDecodedCopy();
|
|
}
|
|
|
|
DSROLE_SERVEROP_HANDLE handle = 0;
|
|
hr =
|
|
Win32ToHresult(
|
|
::DsRoleUpgradeDownlevelServer(
|
|
domain.c_str(),
|
|
site.empty() ? 0 : site.c_str(),
|
|
dbPath.c_str(),
|
|
logPath.c_str(),
|
|
sysvolPath.c_str(),
|
|
(useParent ? parent.c_str() : 0),
|
|
0, // let API pick a server
|
|
(useCurrentUserCreds ? 0 : username.c_str()),
|
|
passwordCopy,
|
|
safeModePasswordCopy,
|
|
flags,
|
|
&handle));
|
|
BREAK_ON_FAILED_HRESULT(hr);
|
|
|
|
if (safeModePasswordCopy)
|
|
{
|
|
::ZeroMemory(
|
|
safeModePasswordCopy,
|
|
sizeof(WCHAR) * safeModePassword.GetLength());
|
|
delete[] safeModePasswordCopy;
|
|
}
|
|
|
|
if (passwordCopy)
|
|
{
|
|
::ZeroMemory(passwordCopy, sizeof(WCHAR) * password.GetLength());
|
|
delete[] passwordCopy;
|
|
}
|
|
|
|
DoProgressLoop(handle, progressDialog);
|
|
}
|
|
while (0);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
throw DS::Error(hr, IDS_UPGRADE_DC_FAILED);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void
|
|
DS::DemoteDC(ProgressDialog& progressDialog)
|
|
throw (DS::Error)
|
|
{
|
|
LOG_FUNCTION(DS::DemoteDC);
|
|
|
|
State& state = State::GetInstance();
|
|
|
|
String username = state.GetUsername();
|
|
bool useCurrentUserCreds = username.empty();
|
|
bool isLastDc = state.IsLastDCInDomain();
|
|
EncodedString adminPassword= state.GetAdminPassword();
|
|
EncodedString password = state.GetPassword();
|
|
|
|
if (!useCurrentUserCreds)
|
|
{
|
|
String userDomain = state.GetUserDomainName();
|
|
username = MassageUserName(userDomain, username);
|
|
}
|
|
|
|
ULONG options = DSROLE_DC_CREATE_TRUST_AS_REQUIRED;
|
|
if (isLastDc)
|
|
{
|
|
options |= DSROLE_DC_DELETE_PARENT_TRUST;
|
|
}
|
|
|
|
LOG(L"Calling DsRoleDemoteDc");
|
|
LOG( L"lpServer : (null)");
|
|
LOG( L"lpDnsDomainName : (null)");
|
|
LOG(String::format(L"ServerRole : %1", isLastDc ? L"DsRoleServerStandalone" : L"DsRoleServerMember"));
|
|
LOG(String::format(L"lpAccount : %1", useCurrentUserCreds ? L"(null)" : username.c_str()));
|
|
LOG(String::format(L"Options : 0x%1!X!", options));
|
|
LOG(String::format(L"fLastDcInDomain : %1", isLastDc ? L"true" : L"false"));
|
|
|
|
WCHAR* adminPasswordCopy = 0;
|
|
if (!adminPassword.IsEmpty())
|
|
{
|
|
adminPasswordCopy = adminPassword.GetDecodedCopy();
|
|
}
|
|
|
|
WCHAR* passwordCopy = 0;
|
|
if (!useCurrentUserCreds)
|
|
{
|
|
passwordCopy = password.GetDecodedCopy();
|
|
}
|
|
|
|
DSROLE_SERVEROP_HANDLE handle = 0;
|
|
HRESULT hr =
|
|
Win32ToHresult(
|
|
::DsRoleDemoteDc(
|
|
0, // this server
|
|
0, // "default" domain hosted by this server
|
|
isLastDc ? DsRoleServerStandalone : DsRoleServerMember,
|
|
(useCurrentUserCreds ? 0 : username.c_str()),
|
|
passwordCopy,
|
|
options,
|
|
isLastDc ? TRUE : FALSE,
|
|
adminPasswordCopy,
|
|
&handle));
|
|
LOG_HRESULT(hr);
|
|
|
|
if (adminPasswordCopy)
|
|
{
|
|
::ZeroMemory(
|
|
adminPasswordCopy,
|
|
sizeof(WCHAR) * adminPassword.GetLength());
|
|
delete[] adminPasswordCopy;
|
|
}
|
|
|
|
if (passwordCopy)
|
|
{
|
|
::ZeroMemory(passwordCopy, sizeof(WCHAR) * password.GetLength());
|
|
delete[] passwordCopy;
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
DoProgressLoop(handle, progressDialog);
|
|
}
|
|
else
|
|
{
|
|
throw DS::Error(hr, IDS_DEMOTE_DC_FAILED);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void
|
|
DS::AbortBDCUpgrade(bool abortForReplica)
|
|
throw (DS::Error)
|
|
{
|
|
LOG_FUNCTION(DS::AbortBDCUpgrade);
|
|
|
|
State& state = State::GetInstance();
|
|
ASSERT(state.GetRunContext() == State::BDC_UPGRADE);
|
|
|
|
String username = state.GetUsername();
|
|
bool useCurrentUserCreds = username.empty();
|
|
|
|
EncodedString adminPassword = state.GetAdminPassword();
|
|
EncodedString password = state.GetPassword();
|
|
|
|
if (!useCurrentUserCreds)
|
|
{
|
|
String userDomain = state.GetUserDomainName();
|
|
username = MassageUserName(userDomain, username);
|
|
}
|
|
|
|
ULONG options =
|
|
abortForReplica ? DSROLEP_ABORT_FOR_REPLICA_INSTALL : 0;
|
|
|
|
LOG(L"Calling DsRoleAbortDownlevelServerUpgrade");
|
|
LOG(String::format(L"lpAccount : %1", useCurrentUserCreds ? L"(null)" : username.c_str()));
|
|
LOG(String::format(L"Options : 0x%1!X!", options));
|
|
|
|
WCHAR* adminPasswordCopy = 0;
|
|
if (!adminPassword.IsEmpty())
|
|
{
|
|
adminPasswordCopy = adminPassword.GetDecodedCopy();
|
|
}
|
|
|
|
WCHAR* passwordCopy = 0;
|
|
if (!useCurrentUserCreds)
|
|
{
|
|
passwordCopy = password.GetDecodedCopy();
|
|
}
|
|
|
|
HRESULT hr =
|
|
Win32ToHresult(
|
|
::DsRoleAbortDownlevelServerUpgrade(
|
|
adminPasswordCopy,
|
|
(useCurrentUserCreds ? 0 : username.c_str()),
|
|
passwordCopy,
|
|
options));
|
|
LOG_HRESULT(hr);
|
|
|
|
if (adminPasswordCopy)
|
|
{
|
|
::ZeroMemory(
|
|
adminPasswordCopy,
|
|
sizeof(WCHAR) * adminPassword.GetLength());
|
|
delete[] adminPasswordCopy;
|
|
}
|
|
|
|
if (passwordCopy)
|
|
{
|
|
::ZeroMemory(passwordCopy, sizeof(WCHAR) * password.GetLength());
|
|
delete[] passwordCopy;
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
throw DS::Error(hr, IDS_ABORT_UPGRADE_FAILED);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
DS::PriorServerRole
|
|
DS::GetPriorServerRole(bool& isUpgrade)
|
|
{
|
|
LOG_FUNCTION(DS::GetPriorServerRole);
|
|
|
|
isUpgrade = false;
|
|
DSROLE_UPGRADE_STATUS_INFO* info = 0;
|
|
|
|
HRESULT hr = MyDsRoleGetPrimaryDomainInformation(0, info);
|
|
if (SUCCEEDED(hr) && info)
|
|
{
|
|
isUpgrade =
|
|
( (info->OperationState & DSROLE_UPGRADE_IN_PROGRESS)
|
|
? true
|
|
: false );
|
|
DSROLE_SERVER_STATE state = info->PreviousServerState;
|
|
|
|
::DsRoleFreeMemory(info);
|
|
|
|
switch (state)
|
|
{
|
|
case DsRoleServerPrimary:
|
|
{
|
|
return PDC;
|
|
}
|
|
case DsRoleServerBackup:
|
|
{
|
|
return BDC;
|
|
}
|
|
case DsRoleServerUnknown:
|
|
default:
|
|
{
|
|
return UNKNOWN;
|
|
}
|
|
}
|
|
}
|
|
|
|
return UNKNOWN;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|