able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/snapin/dnsmgr/zonewiz.cpp

2691 lines
75 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
//
// Copyright (C) Microsoft Corporation, 1998 - 1999
//
// File: zonewiz.cpp
//
//--------------------------------------------------------------------------
#include "preDNSsn.h"
#include <SnapBase.h>
#include "resource.h"
#include "dnsutil.h"
#include "DNSSnap.h"
#include "snapdata.h"
#include "server.h"
#include "domain.h"
#include "record.h"
#include "zone.h"
#include "ZoneWiz.h"
#include "browser.h"
#ifdef DEBUG_ALLOCATOR
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#endif
#define N_ZONEWIZ_TYPES 4
#define N_ZONEWIZ_TYPES_PRIMARY 0
#define N_ZONEWIZ_TYPES_DS_PRIMARY 1
#define N_ZONEWIZ_TYPES_SECONDARY 2
#define N_ZONEWIZ_TYPES_STUB 3
///////////////////////////////////////////////////////////////////////////////
// CDNSCreateZoneInfo
CDNSCreateZoneInfo::CDNSCreateZoneInfo()
{
m_bPrimary = TRUE;
m_bForward = m_bWasForward = TRUE;
m_bIsStub = FALSE;
m_storageType = useADS;
m_ipMastersArray = NULL;
m_nMastersCount = 0;
m_bLocalListOfMasters = FALSE;
m_nDynamicUpdate = ZONE_UPDATE_OFF;
#ifdef USE_NDNC
m_replType = none;
#endif
}
CDNSCreateZoneInfo::~CDNSCreateZoneInfo()
{
ResetIpArr();
}
void CDNSCreateZoneInfo::ResetIpArr()
{
if (m_ipMastersArray != NULL)
{
ASSERT(m_nMastersCount > 0);
delete[] m_ipMastersArray;
m_ipMastersArray = NULL;
m_nMastersCount = 0;
}
}
void CDNSCreateZoneInfo::SetIpArr(PIP_ADDRESS ipMastersArray, DWORD nMastersCount)
{
ResetIpArr();
m_nMastersCount = nMastersCount;
if (m_nMastersCount > 0)
{
ASSERT(ipMastersArray != NULL);
m_ipMastersArray = new IP_ADDRESS[m_nMastersCount];
memcpy(m_ipMastersArray, ipMastersArray, sizeof(IP_ADDRESS)*nMastersCount);
}
}
const CDNSCreateZoneInfo& CDNSCreateZoneInfo::operator=(const CDNSCreateZoneInfo& info)
{
m_bPrimary = info.m_bPrimary;
m_bForward = info.m_bForward;
m_bIsStub = info.m_bIsStub;
m_szZoneName = info.m_szZoneName;
m_szZoneStorage = info.m_szZoneStorage;
m_storageType = info.m_storageType;
SetIpArr(info.m_ipMastersArray, info.m_nMastersCount);
m_bLocalListOfMasters = info.m_bLocalListOfMasters;
m_bWasForward = info.m_bWasForward;
m_nDynamicUpdate = info.m_nDynamicUpdate;
return *this;
}
///////////////////////////////////////////////////////////////////////////////
// CDNSZoneWizardHolder
CDNSZoneWizardHolder::CDNSZoneWizardHolder(CComponentDataObject* pComponentData)
: CPropertyPageHolderBase(NULL, NULL, pComponentData)
{
m_bAutoDelete = FALSE; // use on the stack or embedded
m_forceContextHelpButton = forceOff;
m_pZoneInfo = &m_zoneInfo;
// default settings for zone creation
m_bKnowZoneLookupType = FALSE;
m_bKnowZoneLookupTypeEx = FALSE;
m_bServerPage = FALSE;
m_bFinishPage = TRUE;
m_nNextToPage = 0;
m_nBackToPage = 0;
}
void CDNSZoneWizardHolder::Initialize(CDNSServerNode* pServerNode, // might be null,
BOOL bServerPage, BOOL bFinishPage)
{
m_bServerPage = bServerPage;
m_bFinishPage = bFinishPage;
if (pServerNode != NULL)
SetServerNode(pServerNode);
// page creation
// add start page only if not embedded in other wizard
if (pServerNode != NULL)
{
m_pStartPage = new CDNSZoneWiz_StartPropertyPage;
ASSERT(m_pStartPage != NULL);
AddPageToList((CPropertyPageBase*)m_pStartPage);
}
// if there is no server context and we are not embedded,
// then add first page to pick the server
if (pServerNode == NULL && m_bServerPage)
{
m_pTargetServerPage = new CDNSZoneWiz_SelectServerPropertyPage;
ASSERT(m_pTargetServerPage != NULL);
AddPageToList((CPropertyPageBase*)m_pTargetServerPage);
}
// add the page to select primary or secondary zone
m_pReplicationTypePage = new CDNSZoneWiz_ZoneTypePropertyPage;
ASSERT(m_pReplicationTypePage != NULL);
AddPageToList((CPropertyPageBase*)m_pReplicationTypePage);
// page for lookup type (fwd/rev) on primary only
m_pZoneLookupPage = new CDNSZoneWiz_ZoneLookupPropertyPage;
ASSERT(m_pZoneLookupPage != NULL);
AddPageToList((CPropertyPageBase*)m_pZoneLookupPage);
// pages for zone name on primary only
m_pFwdZoneNamePage = new CDNSZoneWiz_FwdZoneNamePropertyPage;
ASSERT(m_pFwdZoneNamePage != NULL);
AddPageToList((CPropertyPageBase*)m_pFwdZoneNamePage);
m_pRevZoneNamePage = new CDNSZoneWiz_RevZoneNamePropertyPage;
ASSERT(m_pRevZoneNamePage != NULL);
AddPageToList((CPropertyPageBase*)m_pRevZoneNamePage);
// page for masters on secondary only
m_pMastersPage = new CDNSZoneWiz_MastersPropertyPage;
AddPageToList((CPropertyPageBase*)m_pMastersPage);
ASSERT(m_pMastersPage != NULL);
//
// page for dynamic update on primary only
//
m_pDynamicPage = new CDNSZoneWiz_DynamicPropertyPage;
AddPageToList((CPropertyPageBase*)m_pDynamicPage);
ASSERT(m_pDynamicPage != NULL);
// storage page, common
m_pStoragePage = new CDNSZoneWiz_StoragePropertyPage;
AddPageToList((CPropertyPageBase*)m_pStoragePage);
ASSERT(m_pStoragePage != NULL);
#ifdef USE_NDNC
// AD replication page, only for Whistler servers
m_pADReplPage = new CDNSZoneWiz_ADReplicationPropertyPage;
AddPageToList((CPropertyPageBase*)m_pADReplPage);
ASSERT(m_pADReplPage != NULL);
#endif // USE_NDNC
// finish page, common
if (m_bFinishPage)
{
m_pFinishPage = new CDNSZoneWiz_FinishPropertyPage;
AddPageToList((CPropertyPageBase*)m_pFinishPage);
ASSERT(m_pFinishPage != NULL);
}
}
void CDNSZoneWizardHolder::PreSetZoneLookupType(BOOL bForward)
{
m_bKnowZoneLookupType = TRUE;
m_bKnowZoneLookupTypeEx = FALSE;
m_pZoneInfo->m_bForward = bForward;
}
void CDNSZoneWizardHolder::PreSetZoneLookupTypeEx(BOOL bForward, UINT nZoneType, BOOL bADIntegrated)
{
m_bKnowZoneLookupTypeEx = TRUE;
m_pZoneInfo->m_bForward = bForward;
if (bADIntegrated)
{
m_pZoneInfo->m_storageType = CDNSCreateZoneInfo::useADS;
}
else
{
m_pZoneInfo->m_storageType = CDNSCreateZoneInfo::newFile;
}
if (nZoneType != (UINT)-1)
{
switch (nZoneType)
{
case DNS_ZONE_TYPE_PRIMARY:
m_pZoneInfo->m_bPrimary = TRUE;
m_pZoneInfo->m_bIsStub = FALSE;
break;
case DNS_ZONE_TYPE_SECONDARY:
m_pZoneInfo->m_bPrimary = FALSE;
m_pZoneInfo->m_bIsStub = FALSE;
break;
case DNS_ZONE_TYPE_STUB:
m_pZoneInfo->m_bPrimary = FALSE;
m_pZoneInfo->m_bIsStub = TRUE;
break;
default:
ASSERT(FALSE);
break;
}
}
}
void CDNSZoneWizardHolder::SetContextPages(UINT nNextToPage, UINT nBackToPage)
{
m_nNextToPage = nNextToPage;
m_nBackToPage = nBackToPage;
}
UINT CDNSZoneWizardHolder::GetFirstEntryPointPageID()
{
if (m_bKnowZoneLookupTypeEx)
{
if (m_pZoneInfo->m_bForward)
{
return CDNSZoneWiz_FwdZoneNamePropertyPage::IDD;
}
else
{
return CDNSZoneWiz_RevZoneNamePropertyPage::IDD;
}
}
return CDNSZoneWiz_ZoneTypePropertyPage::IDD;
}
UINT CDNSZoneWizardHolder::GetLastEntryPointPageID()
{
if (m_pZoneInfo->m_storageType == CDNSCreateZoneInfo::useADS)
{
//
// if DS primary or secondary, skip storage page
//
if (m_pZoneInfo->m_bIsStub)
{
//
// AD-integrated Stub zone
//
return CDNSZoneWiz_MastersPropertyPage::IDD;
}
else
{
if (m_pZoneInfo->m_bForward)
{
//
// AD-integrated Fwd lookup zone
//
return CDNSZoneWiz_DynamicPropertyPage::IDD;
}
else
{
//
// AD-integrated Rev lookup zone
//
return CDNSZoneWiz_DynamicPropertyPage::IDD;
}
}
}
else
{
//
// File based zones
//
if (m_pZoneInfo->m_bIsStub)
{
//
// File based stub zone
//
return CDNSZoneWiz_MastersPropertyPage::IDD;
}
else if (m_pZoneInfo->m_bPrimary)
{
//
// standard primary
//
return CDNSZoneWiz_DynamicPropertyPage::IDD;
}
else
{
//
// Secondary zone
//
return CDNSZoneWiz_MastersPropertyPage::IDD;
}
}
return CDNSZoneWiz_StoragePropertyPage::IDD;
}
DNS_STATUS CDNSZoneWizardHolder::CreateZoneHelper(CDNSServerNode* pServerNode,
CDNSCreateZoneInfo* pZoneInfo,
CComponentDataObject* pComponentData)
{
ASSERT(pServerNode != NULL);
ASSERT(pZoneInfo != NULL);
ASSERT(pComponentData != NULL);
BOOL bLoadExisting = TRUE;
if (pZoneInfo->m_bPrimary)
{
BOOL bUseADS = pZoneInfo->m_storageType == CDNSCreateZoneInfo::useADS;
if (!bUseADS)
bLoadExisting = pZoneInfo->m_storageType == CDNSCreateZoneInfo::importFile;
UINT nDynamicUpdate = pZoneInfo->m_nDynamicUpdate;
#ifdef USE_NDNC
return pServerNode->CreatePrimaryZone(
pZoneInfo->m_szZoneName,
pZoneInfo->m_szZoneStorage,
bLoadExisting,
pZoneInfo->m_bForward,
bUseADS,
nDynamicUpdate,
pComponentData,
pZoneInfo->m_replType,
pZoneInfo->m_szCustomReplName);
#else
return pServerNode->CreatePrimaryZone(
pZoneInfo->m_szZoneName,
pZoneInfo->m_szZoneStorage,
bLoadExisting,
pZoneInfo->m_bForward,
bUseADS,
nDynamicUpdate,
pComponentData);
#endif // USE_NDNC
}
else if (pZoneInfo->m_bIsStub)
{
BOOL bUseADS = pZoneInfo->m_storageType == CDNSCreateZoneInfo::useADS;
if (!bUseADS)
{
bLoadExisting = pZoneInfo->m_storageType == CDNSCreateZoneInfo::importFile;
}
#ifdef USE_NDNC
return pServerNode->CreateStubZone(pZoneInfo->m_szZoneName,
pZoneInfo->m_szZoneStorage,
bLoadExisting,
bUseADS,
pZoneInfo->m_bForward,
pZoneInfo->m_ipMastersArray,
pZoneInfo->m_nMastersCount,
pZoneInfo->m_bLocalListOfMasters,
pComponentData,
pZoneInfo->m_replType,
pZoneInfo->m_szCustomReplName);
#else
return pServerNode->CreateStubZone(pZoneInfo->m_szZoneName,
pZoneInfo->m_szZoneStorage,
bLoadExisting,
bUseADS,
pZoneInfo->m_bForward,
pZoneInfo->m_ipMastersArray,
pZoneInfo->m_nMastersCount,
pZoneInfo->m_bLocalListOfMasters,
pComponentData);
#endif // USE_NDNC
}
else // secondary
{
ASSERT(pZoneInfo->m_storageType != CDNSCreateZoneInfo::useADS);
bLoadExisting = pZoneInfo->m_storageType == CDNSCreateZoneInfo::importFile;
return pServerNode->CreateSecondaryZone(
pZoneInfo->m_szZoneName,
pZoneInfo->m_szZoneStorage,
bLoadExisting,
pZoneInfo->m_bForward,
pZoneInfo->m_ipMastersArray,
pZoneInfo->m_nMastersCount,
pComponentData);
}
}
BOOL CDNSZoneWizardHolder::CreateZone()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
CDNSServerNode* pServerNode = GetServerNode();
ASSERT(pServerNode != NULL);
ASSERT(GetComponentData() != NULL);
USES_CONVERSION;
DNS_STATUS err = CreateZoneHelper(pServerNode, m_pZoneInfo, GetComponentData());
if (err != 0)
{
if (err == DNS_ERROR_DP_NOT_ENLISTED ||
err == DNS_ERROR_DP_DOES_NOT_EXIST)
{
CString szErr;
if (m_pZoneInfo->m_replType == domain)
{
szErr.Format(IDS_ERRMSG_NO_NDNC_DOMAIN_FORMAT, UTF8_TO_W(pServerNode->GetDomainName()));
}
else if (m_pZoneInfo->m_replType == forest)
{
szErr.Format(IDS_ERRMSG_NO_NDNC_FOREST_FORMAT, UTF8_TO_W(pServerNode->GetForestName()));
}
else
{
ASSERT(FALSE);
}
DNSMessageBox(szErr, MB_OK | MB_ICONERROR);
}
else
{
DNSErrorDialog(err, IDS_MSG_ZWIZ_FAIL);
}
}
/* else
{
CString szMsg, szFmt;
szFmt.LoadString(IDS_MSG_ZWIZ_SUCCESS);
szMsg.Format((LPCTSTR)szFmt, (LPCTSTR)m_pZoneInfo->m_szZoneName);
DNSMessageBox(szMsg);
}
*/
return err == 0;
}
///////////////////////////////////////////////////////////////////////////////
// CDNSZoneWiz_StartPropertyPage
CDNSZoneWiz_StartPropertyPage::CDNSZoneWiz_StartPropertyPage()
: CPropertyPageBase(CDNSZoneWiz_StartPropertyPage::IDD)
{
InitWiz97(TRUE,0,0);
}
BOOL CDNSZoneWiz_StartPropertyPage::OnInitDialog()
{
CPropertyPageBase::OnInitDialog();
SetBigBoldFont(m_hWnd, IDC_STATIC_WELCOME);
return TRUE;
}
BOOL CDNSZoneWiz_StartPropertyPage::OnSetActive()
{
GetHolder()->SetWizardButtonsFirst(TRUE);
return TRUE;
}
//////////////////////////////////////////////////////////////////////////
// CDNSZoneWiz_SelectServerPropertyPage
CDNSZoneWiz_SelectServerPropertyPage::CDNSZoneWiz_SelectServerPropertyPage()
: CPropertyPageBase(CDNSZoneWiz_SelectServerPropertyPage::IDD)
{
InitWiz97(FALSE,IDS_ZWIZ_SELECT_SERVER_TITLE,IDS_ZWIZ_SELECT_SERVER_SUBTITLE);
}
BEGIN_MESSAGE_MAP(CDNSZoneWiz_SelectServerPropertyPage, CPropertyPageBase)
ON_LBN_SELCHANGE(IDC_SERVERS_LIST, OnListboxSelChange)
END_MESSAGE_MAP()
void CDNSZoneWiz_SelectServerPropertyPage::OnListboxSelChange()
{
GetHolder()->SetWizardButtonsFirst(GetServerListBox()->GetCurSel() != -1);
}
BOOL CDNSZoneWiz_SelectServerPropertyPage::OnSetActive()
{
GetHolder()->SetWizardButtonsFirst(GetServerListBox()->GetCurSel() != -1);
return CPropertyPageBase::OnSetActive();
}
LRESULT CDNSZoneWiz_SelectServerPropertyPage::OnWizardNext()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
CListBox* pServerListBox = GetServerListBox();
int nSel = pServerListBox->GetCurSel();
ASSERT((nSel >= 0) && (nSel < pServerListBox->GetCount()));
CDNSServerNode* pServerNode = (CDNSServerNode*)pServerListBox->GetItemData(nSel);
pHolder->SetServerNode(pServerNode);
return CPropertyPageBase::OnWizardNext();
}
BOOL CDNSZoneWiz_SelectServerPropertyPage::OnInitDialog()
{
CPropertyPageBase::OnInitDialog();
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
ASSERT(pHolder->GetServerNode() == NULL);
ASSERT(pHolder->GetComponentData() != NULL);
CDNSRootData* pRootData = (CDNSRootData*)pHolder->GetComponentData()->GetRootData();
ASSERT(pRootData != NULL);
CListBox* pServerListBox = GetServerListBox();
ASSERT(pServerListBox != NULL);
POSITION pos;
CNodeList* pChildList = pRootData->GetContainerChildList();
int k = 0;
// fill in the listbox
for (pos = pChildList->GetHeadPosition(); pos != NULL; )
{
CDNSServerNode* pServerNode = (CDNSServerNode*)pChildList->GetNext(pos);
pServerListBox->InsertString(k, pServerNode->GetDisplayName());
pServerListBox->SetItemData(k,(DWORD_PTR)pServerNode);
k++;
}
ASSERT(k > 0); // we have to have at least a server in the list
ASSERT(pServerListBox->GetCount() == k);
// select the first item, if any
pServerListBox->SetCurSel((pServerListBox->GetCount() > 0) ? 0 : -1);
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
BOOL CDNSZoneWiz_SelectServerPropertyPage::OnKillActive()
{
#ifdef _DEBUG
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
CDNSServerNode* pServerNode = pHolder->GetServerNode();
ASSERT(pServerNode != NULL);
#endif
return CPropertyPage::OnKillActive();
}
//////////////////////////////////////////////////////////////////////////
// CDNSZoneWiz_ZoneTypePropertyPage
CDNSZoneWiz_ZoneTypePropertyPage::CDNSZoneWiz_ZoneTypePropertyPage()
: CPropertyPageBase(CDNSZoneWiz_ZoneTypePropertyPage::IDD)
{
InitWiz97(FALSE,IDS_ZWIZ_ZONE_TYPE_TITLE,IDS_ZWIZ_ZONE_TYPE_SUBTITLE);
}
BEGIN_MESSAGE_MAP(CDNSZoneWiz_ZoneTypePropertyPage, CPropertyPageBase)
ON_BN_CLICKED(IDC_RADIO_PRIMARY_ZONE, OnRadioChange)
ON_BN_CLICKED(IDC_RADIO_STUB, OnRadioChange)
ON_BN_CLICKED(IDC_RADIO_SECONDARY,OnRadioChange)
ON_BN_CLICKED(IDC_ADINT_CHECK, OnRadioChange)
END_MESSAGE_MAP()
void CDNSZoneWiz_ZoneTypePropertyPage::OnRadioChange()
{
if (SendDlgItemMessage(IDC_RADIO_SECONDARY, BM_GETCHECK, 0, 0) == BST_CHECKED)
{
SendDlgItemMessage(IDC_ADINT_CHECK, BM_SETCHECK, BST_UNCHECKED, 0);
GetDlgItem(IDC_ADINT_CHECK)->EnableWindow(FALSE);
}
else
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
CDNSServerNode* pServerNode = pHolder->GetServerNode();
if (pServerNode->CanUseADS())
{
GetDlgItem(IDC_ADINT_CHECK)->EnableWindow(TRUE);
}
}
}
BOOL CDNSZoneWiz_ZoneTypePropertyPage::OnSetActive()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
pHolder->SetWizardButtonsMiddle(TRUE);
SetUIState();
return CPropertyPageBase::OnSetActive();
}
#ifdef USE_NDNC
LRESULT CDNSZoneWiz_ZoneTypePropertyPage::OnWizardNext()
{
GetUIState();
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
CDNSServerNode* pServerNode = pHolder->GetServerNode();
UINT nextPage = static_cast<UINT>(-1);
if (pHolder->m_pZoneInfo->m_storageType != CDNSCreateZoneInfo::useADS ||
pServerNode->GetBuildNumber() < DNS_SRV_BUILD_NUMBER_WHISTLER ||
(pServerNode->GetMajorVersion() <= DNS_SRV_MAJOR_VERSION_NT_5 &&
pServerNode->GetMinorVersion() < DNS_SRV_MINOR_VERSION_WHISTLER))
{
if (pHolder->m_bKnowZoneLookupType)
{
if (pHolder->m_pZoneInfo->m_bForward)
{
nextPage = CDNSZoneWiz_FwdZoneNamePropertyPage::IDD;
}
else
{
nextPage = CDNSZoneWiz_RevZoneNamePropertyPage::IDD;
}
}
else
{
nextPage = CDNSZoneWiz_ZoneLookupPropertyPage::IDD;
}
}
else
{
nextPage = CDNSZoneWiz_ADReplicationPropertyPage::IDD;
}
return (LRESULT)nextPage;
}
#else
LRESULT CDNSZoneWiz_ZoneTypePropertyPage::OnWizardNext()
{
GetUIState();
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
UINT nextPage = static_cast<UINT>(-1);
if (pHolder->m_bKnowZoneLookupType)
{
if (pHolder->m_pZoneInfo->m_bForward)
nextPage = CDNSZoneWiz_FwdZoneNamePropertyPage::IDD;
else
nextPage = CDNSZoneWiz_RevZoneNamePropertyPage::IDD;
}
else
nextPage = CDNSZoneWiz_ZoneLookupPropertyPage::IDD;
return (LRESULT)nextPage;
}
#endif // USE_NDNC
LRESULT CDNSZoneWiz_ZoneTypePropertyPage::OnWizardBack()
{
UINT nPrevPage = static_cast<UINT>(-1); // first page by default
GetUIState();
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
if (pHolder->m_bServerPage)
nPrevPage = CDNSZoneWiz_SelectServerPropertyPage::IDD;
else if (pHolder->m_nBackToPage > 0)
nPrevPage = pHolder->m_nBackToPage;
else
nPrevPage = CDNSZoneWiz_StartPropertyPage::IDD;
return nPrevPage;
}
BOOL CDNSZoneWiz_ZoneTypePropertyPage::OnInitDialog()
{
CPropertyPageBase::OnInitDialog();
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
CDNSServerNode* pServerNode = pHolder->GetServerNode();
if (!pServerNode->CanUseADS())
{
SendDlgItemMessage(IDC_ADINT_CHECK, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
GetDlgItem(IDC_ADINT_CHECK)->EnableWindow(FALSE);
pHolder->m_pZoneInfo->m_storageType = CDNSCreateZoneInfo::newFile;
}
SendDlgItemMessage(IDC_RADIO_PRIMARY_ZONE, BM_SETCHECK, BST_CHECKED, 0);
if (pServerNode->GetBuildNumber() < DNS_SRV_BUILD_NUMBER_WHISTLER ||
pServerNode->GetMajorVersion() <= DNS_SRV_MAJOR_VERSION_NT_5 &&
pServerNode->GetMinorVersion() < DNS_SRV_MINOR_VERSION_WHISTLER)
{
//
// Disable Stub zones for pre-Whistler servers
//
GetDlgItem(IDC_RADIO_STUB)->EnableWindow(FALSE);
GetDlgItem(IDC_STUB_STATIC)->EnableWindow(FALSE);
}
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
BOOL CDNSZoneWiz_ZoneTypePropertyPage::OnKillActive()
{
return CPropertyPage::OnKillActive();
}
void CDNSZoneWiz_ZoneTypePropertyPage::SetUIState()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
CButton* pPrimaryButton = (CButton*)GetDlgItem(IDC_RADIO_PRIMARY_ZONE);
CButton* pStubButton = (CButton*)GetDlgItem(IDC_RADIO_STUB);
CButton* pSecondaryButton = (CButton*)GetDlgItem(IDC_RADIO_SECONDARY);
CButton* pADIntCheck = (CButton*)GetDlgItem(IDC_ADINT_CHECK);
CDNSServerNode* pServerNode = pHolder->GetServerNode();
if (pHolder->m_pZoneInfo->m_bPrimary)
{
if (pServerNode->CanUseADS())
{
pADIntCheck->EnableWindow(TRUE);
}
else
{
pADIntCheck->EnableWindow(FALSE);
pADIntCheck->SetCheck(FALSE);
pHolder->m_pZoneInfo->m_storageType = CDNSCreateZoneInfo::newFile;
}
if (pHolder->m_pZoneInfo->m_storageType == CDNSCreateZoneInfo::useADS)
{
//
// primary DS integrated
//
pPrimaryButton->SetCheck(TRUE);
pStubButton->SetCheck(FALSE);
pSecondaryButton->SetCheck(FALSE);
pADIntCheck->SetCheck(TRUE);
}
else
{
// primary standard
pPrimaryButton->SetCheck(TRUE);
pStubButton->SetCheck(FALSE);
pSecondaryButton->SetCheck(FALSE);
pADIntCheck->SetCheck(FALSE);
}
}
else
{
if (pHolder->m_pZoneInfo->m_bIsStub)
{
//
// Stub zone
//
pPrimaryButton->SetCheck(FALSE);
pStubButton->SetCheck(TRUE);
pSecondaryButton->SetCheck(FALSE);
if (pServerNode->CanUseADS())
{
pADIntCheck->EnableWindow(TRUE);
}
if (pHolder->m_pZoneInfo->m_storageType == CDNSCreateZoneInfo::useADS)
{
pADIntCheck->SetCheck(TRUE);
}
else
{
pADIntCheck->SetCheck(FALSE);
}
}
else
{
//
// Secondary
//
pPrimaryButton->SetCheck(FALSE);
pStubButton->SetCheck(FALSE);
pSecondaryButton->SetCheck(TRUE);
pADIntCheck->EnableWindow(FALSE);
}
}
}
void CDNSZoneWiz_ZoneTypePropertyPage::GetUIState()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
CDNSServerNode* pServerNode = pHolder->GetServerNode();
if ( ((CButton*)GetDlgItem(IDC_RADIO_SECONDARY))->GetCheck() )
{
pHolder->m_pZoneInfo->m_bIsStub = FALSE;
// we were primary, need to pick a storage
pHolder->m_pZoneInfo->m_bPrimary = FALSE;
pHolder->m_pZoneInfo->m_storageType = CDNSCreateZoneInfo::newFile;
}
else if ( ((CButton*)GetDlgItem(IDC_RADIO_PRIMARY_ZONE))->GetCheck() )
{
pHolder->m_pZoneInfo->m_bPrimary = TRUE;
pHolder->m_pZoneInfo->m_bIsStub = FALSE;
if (((CButton*)GetDlgItem(IDC_ADINT_CHECK))->GetCheck())
{
//
// AD integrated primary
//
pHolder->m_pZoneInfo->m_storageType = CDNSCreateZoneInfo::useADS;
}
else
{
//
// Standard primary
//
pHolder->m_pZoneInfo->m_storageType = CDNSCreateZoneInfo::newFile;
}
}
else if (((CButton*)GetDlgItem(IDC_RADIO_STUB))->GetCheck())
{
//
// Stub zone
//
//
// Should not happen for pre-Whistler server
//
ASSERT(pServerNode->GetBuildNumber() >= DNS_SRV_BUILD_NUMBER_WHISTLER ||
pServerNode->GetMajorVersion() >= DNS_SRV_MAJOR_VERSION_NT_5 &&
pServerNode->GetMinorVersion() >= DNS_SRV_MINOR_VERSION_WHISTLER);
pHolder->m_pZoneInfo->m_bPrimary = FALSE;
pHolder->m_pZoneInfo->m_bIsStub = TRUE;
if (((CButton*)GetDlgItem(IDC_ADINT_CHECK))->GetCheck())
{
//
// AD integrated Stub zone
//
pHolder->m_pZoneInfo->m_storageType = CDNSCreateZoneInfo::useADS;
}
else
{
//
// Standard Stub zone
//
pHolder->m_pZoneInfo->m_storageType = CDNSCreateZoneInfo::newFile;
}
}
}
//////////////////////////////////////////////////////////////////////////
// CDNSZoneWiz_ZoneLookupPropertyPage
CDNSZoneWiz_ZoneLookupPropertyPage::CDNSZoneWiz_ZoneLookupPropertyPage()
: CPropertyPageBase(CDNSZoneWiz_ZoneLookupPropertyPage::IDD)
{
InitWiz97(FALSE,IDS_ZWIZ_ZONE_LOOKUP_TITLE,IDS_ZWIZ_ZONE_LOOKUP_SUBTITLE);
}
BOOL CDNSZoneWiz_ZoneLookupPropertyPage::OnSetActive()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
pHolder->SetWizardButtonsMiddle(TRUE);
return TRUE;
}
#ifdef USE_NDNC
LRESULT CDNSZoneWiz_ZoneLookupPropertyPage::OnWizardNext()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
// save the old setting
pHolder->m_pZoneInfo->m_bWasForward = pHolder->m_pZoneInfo->m_bForward;
// get the new setting
pHolder->m_pZoneInfo->m_bForward =
(GetCheckedRadioButton(IDC_RADIO_FWD, IDC_RADIO_REV) ==
IDC_RADIO_FWD);
if (pHolder->m_pZoneInfo->m_bForward)
{
return CDNSZoneWiz_FwdZoneNamePropertyPage::IDD;
}
return CDNSZoneWiz_RevZoneNamePropertyPage::IDD;
}
LRESULT CDNSZoneWiz_ZoneLookupPropertyPage::OnWizardBack()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
CDNSServerNode* pServerNode = pHolder->GetServerNode();
if (pHolder->m_pZoneInfo->m_storageType != CDNSCreateZoneInfo::useADS ||
pServerNode->GetBuildNumber() < DNS_SRV_BUILD_NUMBER_WHISTLER ||
(pServerNode->GetMajorVersion() <= DNS_SRV_MAJOR_VERSION_NT_5 &&
pServerNode->GetMinorVersion() < DNS_SRV_MINOR_VERSION_WHISTLER))
{
return CDNSZoneWiz_ZoneTypePropertyPage::IDD;
}
return CDNSZoneWiz_ADReplicationPropertyPage::IDD;
}
#else
LRESULT CDNSZoneWiz_ZoneLookupPropertyPage::OnWizardNext()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
// save the old setting
pHolder->m_pZoneInfo->m_bWasForward = pHolder->m_pZoneInfo->m_bForward;
// get the new setting
pHolder->m_pZoneInfo->m_bForward =
(GetCheckedRadioButton(IDC_RADIO_FWD, IDC_RADIO_REV) ==
IDC_RADIO_FWD);
if (pHolder->m_pZoneInfo->m_bForward)
return CDNSZoneWiz_FwdZoneNamePropertyPage::IDD;
// This was an else but the sundown build didn't like having a control path not return a value
return CDNSZoneWiz_RevZoneNamePropertyPage::IDD;
}
LRESULT CDNSZoneWiz_ZoneLookupPropertyPage::OnWizardBack()
{
return CDNSZoneWiz_ZoneTypePropertyPage::IDD;
}
#endif // USE_NDNC
BOOL CDNSZoneWiz_ZoneLookupPropertyPage::OnInitDialog()
{
CPropertyPageBase::OnInitDialog();
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
CheckRadioButton(IDC_RADIO_FWD, IDC_RADIO_REV,
pHolder->m_pZoneInfo->m_bForward ? IDC_RADIO_FWD : IDC_RADIO_REV);
return TRUE;
}
//////////////////////////////////////////////////////////////////////////
// CDNSZoneWiz_ZoneNamePropertyPageBase
BEGIN_MESSAGE_MAP(CDNSZoneWiz_ZoneNamePropertyPageBase, CPropertyPageBase)
ON_EN_CHANGE(IDC_EDIT_ZONE_NAME, OnChangeEditZoneName)
ON_BN_CLICKED(IDC_BROWSE_BUTTON, OnBrowse)
END_MESSAGE_MAP()
CDNSZoneWiz_ZoneNamePropertyPageBase::CDNSZoneWiz_ZoneNamePropertyPageBase(UINT nIDD)
: CPropertyPageBase(nIDD)
{
}
BOOL CDNSZoneWiz_ZoneNamePropertyPageBase::OnSetActive()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
// enable and show browse button only if secondary
CButton* pBrowseButton = GetBrowseButton();
pBrowseButton->EnableWindow(!pHolder->m_pZoneInfo->m_bPrimary);
pBrowseButton->ShowWindow(!pHolder->m_pZoneInfo->m_bPrimary);
//
// Limit the zone name to MAX_DNS_NAME_LEN characters
//
SendDlgItemMessage(IDC_EDIT_ZONE_NAME, EM_LIMITTEXT, (WPARAM)MAX_DNS_NAME_LEN, 0);
pHolder->SetWizardButtonsMiddle(FALSE);
SetUIState();
return CPropertyPageBase::OnSetActive();
}
#ifdef USE_NDNC
LRESULT CDNSZoneWiz_ZoneNamePropertyPageBase::OnWizardNext()
{
GetUIState();
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
CDNSServerNode* pServerNode = pHolder->GetServerNode();
DNS_STATUS err = ::ValidateDnsNameAgainstServerFlags(pHolder->m_pZoneInfo->m_szZoneName,
DnsNameDomain,
pServerNode->GetNameCheckFlag());
if (err != 0)
{
//
// Bring up an error for an invalid name
//
CString szFmt, szMsg;
szFmt.LoadString(IDS_MSG_ZONE_INVALID_NAME);
szMsg.Format((LPCWSTR)szFmt, pHolder->m_pZoneInfo->m_szZoneName);
if (DNSMessageBox(szMsg, MB_YESNO) == IDYES)
{
err = 0;
}
}
if (err == 0)
{
if (pHolder->m_pZoneInfo->m_bPrimary)
{
if (pHolder->m_pZoneInfo->m_storageType == CDNSCreateZoneInfo::useADS)
{
return CDNSZoneWiz_DynamicPropertyPage::IDD;
}
else
{
return CDNSZoneWiz_StoragePropertyPage::IDD;
}
}
else
{
if (pHolder->m_pZoneInfo->m_bIsStub &&
pHolder->m_pZoneInfo->m_storageType != CDNSCreateZoneInfo::useADS)
{
return CDNSZoneWiz_StoragePropertyPage::IDD;
}
else
{
return CDNSZoneWiz_MastersPropertyPage::IDD;
}
}
}
return -1;
}
LRESULT CDNSZoneWiz_ZoneNamePropertyPageBase::OnWizardBack()
{
GetUIState();
LRESULT nPrevPage = -1;
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
CDNSServerNode* pServerNode = pHolder->GetServerNode();
if (pHolder->m_pZoneInfo->m_storageType != CDNSCreateZoneInfo::useADS ||
pServerNode->GetBuildNumber() < DNS_SRV_BUILD_NUMBER_WHISTLER ||
(pServerNode->GetMajorVersion() <= DNS_SRV_MAJOR_VERSION_NT_5 &&
pServerNode->GetMinorVersion() < DNS_SRV_MINOR_VERSION_WHISTLER))
{
if (pHolder->m_bKnowZoneLookupType && !pHolder->m_bKnowZoneLookupTypeEx)
{
nPrevPage = (LRESULT)CDNSZoneWiz_ZoneTypePropertyPage::IDD;
}
else if (pHolder->m_bKnowZoneLookupTypeEx && pHolder->m_nBackToPage > 0)
{
nPrevPage = pHolder->m_nBackToPage;
}
else
{
nPrevPage = CDNSZoneWiz_ZoneLookupPropertyPage::IDD;
}
}
else
{
if (pHolder->m_bKnowZoneLookupType && !pHolder->m_bKnowZoneLookupTypeEx)
{
nPrevPage = (LRESULT)CDNSZoneWiz_ADReplicationPropertyPage::IDD;
}
else if (pHolder->m_bKnowZoneLookupTypeEx && pHolder->m_nBackToPage > 0)
{
nPrevPage = pHolder->m_nBackToPage;
}
else
{
nPrevPage = CDNSZoneWiz_ZoneLookupPropertyPage::IDD;
}
}
return nPrevPage;
}
#else
LRESULT CDNSZoneWiz_ZoneNamePropertyPageBase::OnWizardNext()
{
GetUIState();
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
DNS_STATUS err = ::ValidateDnsNameAgainstServerFlags(pHolder->m_pZoneInfo->m_szZoneName,
DnsNameDomain,
pHolder->GetServerNode()->GetNameCheckFlag());
if (err != 0)
{
//
// Bring up an error for an invalid name
//
CString szFmt, szMsg;
szFmt.LoadString(IDS_MSG_ZONE_INVALID_NAME);
szMsg.Format((LPCWSTR)szFmt, pHolder->m_pZoneInfo->m_szZoneName);
if (DNSMessageBox(szMsg, MB_YESNO) == IDYES)
{
err = 0;
}
}
if (err == 0)
{
if (pHolder->m_pZoneInfo->m_bPrimary)
{
if (pHolder->m_pZoneInfo->m_storageType == CDNSCreateZoneInfo::useADS)
{
return CDNSZoneWiz_DynamicPropertyPage::IDD;
}
else
{
return CDNSZoneWiz_StoragePropertyPage::IDD;
}
}
else
{
if (pHolder->m_pZoneInfo->m_bIsStub &&
pHolder->m_pZoneInfo->m_storageType != CDNSCreateZoneInfo::useADS)
{
return CDNSZoneWiz_StoragePropertyPage::IDD;
}
return CDNSZoneWiz_MastersPropertyPage::IDD;
}
}
return -1;
}
LRESULT CDNSZoneWiz_ZoneNamePropertyPageBase::OnWizardBack()
{
GetUIState();
LRESULT nPrevPage = -1;
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
if (pHolder->m_bKnowZoneLookupType && !pHolder->m_bKnowZoneLookupTypeEx)
{
nPrevPage = (LRESULT)CDNSZoneWiz_ZoneTypePropertyPage::IDD;
}
else if (pHolder->m_bKnowZoneLookupTypeEx && pHolder->m_nBackToPage > 0)
{
nPrevPage = pHolder->m_nBackToPage;
}
else
{
nPrevPage = CDNSZoneWiz_ZoneLookupPropertyPage::IDD;
}
return nPrevPage;
}
#endif // USE_NDNC
void CDNSZoneWiz_ZoneNamePropertyPageBase::OnChangeEditZoneName()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
CString sz;
GetZoneNameEdit()->GetWindowText(sz);
sz.TrimLeft();
sz.TrimRight();
pHolder->SetWizardButtonsMiddle(
IsValidDnsZoneName(sz, pHolder->m_pZoneInfo->m_bForward));
}
void CDNSZoneWiz_ZoneNamePropertyPageBase::OnBrowse()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
AFX_MANAGE_STATE(AfxGetStaticModuleState());
CComponentDataObject* pComponentDataObject =
GetHolder()->GetComponentData();
CDNSServerNode* pServerNode = pHolder->GetServerNode();
ASSERT(pServerNode != NULL);
CDNSBrowserDlg dlg(pComponentDataObject, pHolder,
pHolder->m_pZoneInfo->m_bForward ? ZONE_FWD : ZONE_REV,
FALSE /* bEnableEdit */, pServerNode->GetDisplayName() );
if (IDOK == dlg.DoModal())
{
CEdit* pEdit = GetZoneNameEdit();
pEdit->SetWindowText(dlg.GetSelectionString());
}
}
void CDNSZoneWiz_ZoneNamePropertyPageBase::SetUIState()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
// if we changed zone lookup type, need to clear zone name
if (pHolder->m_pZoneInfo->m_bWasForward != pHolder->m_pZoneInfo->m_bForward)
{
pHolder->m_pZoneInfo->m_szZoneName.Empty();
pHolder->m_pZoneInfo->m_bWasForward = pHolder->m_pZoneInfo->m_bForward;
}
GetZoneNameEdit()->SetWindowText(pHolder->m_pZoneInfo->m_szZoneName);
}
void CDNSZoneWiz_ZoneNamePropertyPageBase::GetUIState()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
CString szZoneName;
GetZoneNameEdit()->GetWindowText(szZoneName);
// need to trim blanks
szZoneName.TrimLeft();
szZoneName.TrimRight();
// provide a suggested file name
if (pHolder->m_pZoneInfo->m_szZoneName != szZoneName)
{
pHolder->m_pZoneInfo->m_szZoneName = szZoneName;
int nLen = szZoneName.GetLength();
if (nLen == 0)
{
pHolder->m_pZoneInfo->m_szZoneStorage.Empty();
}
else if (nLen == 1 && szZoneName[0] == TEXT('.'))
{
pHolder->m_pZoneInfo->m_szZoneStorage = _T("root.dns");
}
else
{
LPCTSTR lpszFmt = ( TEXT('.') == szZoneName.GetAt(nLen-1))
? _T("%sdns") : _T("%s.dns");
pHolder->m_pZoneInfo->m_szZoneStorage.Format(lpszFmt, (LPCTSTR)pHolder->m_pZoneInfo->m_szZoneName);
//
// Added by JEFFJON 2/11/99 - changes any illegal file name characters (\/:*?"<>|) to '_'
// and truncates any filename to _MAX_FNAME length
//
LPCWSTR lpszZoneStorage = (LPCWSTR)pHolder->m_pZoneInfo->m_szZoneStorage;
int iCount = pHolder->m_pZoneInfo->m_szZoneStorage.GetLength();
if (iCount > _MAX_FNAME)
{
pHolder->m_pZoneInfo->m_szZoneStorage = pHolder->m_pZoneInfo->m_szZoneStorage.Left(_MAX_FNAME - 4);
pHolder->m_pZoneInfo->m_szZoneStorage += L".dns";
}
for (int idx = 0; idx < iCount + 1; idx++)
{
if (lpszZoneStorage[0] == L'\\' ||
lpszZoneStorage[0] == L'/' ||
lpszZoneStorage[0] == L':' ||
lpszZoneStorage[0] == L'*' ||
lpszZoneStorage[0] == L'?' ||
lpszZoneStorage[0] == L'"' ||
lpszZoneStorage[0] == L'<' ||
lpszZoneStorage[0] == L'>' ||
lpszZoneStorage[0] == L'|')
{
pHolder->m_pZoneInfo->m_szZoneStorage.SetAt(idx, L'_');
}
lpszZoneStorage++;
}
}
}
}
//////////////////////////////////////////////////////////////////////////
// CDNSZoneWiz_FwdZoneNamePropertyPage
CDNSZoneWiz_FwdZoneNamePropertyPage::CDNSZoneWiz_FwdZoneNamePropertyPage()
: CDNSZoneWiz_ZoneNamePropertyPageBase(CDNSZoneWiz_FwdZoneNamePropertyPage::IDD)
{
InitWiz97(FALSE,IDS_ZWIZ_FWD_ZONE_NAME_TITLE,IDS_ZWIZ_FWD_ZONE_NAME_SUBTITLE);
}
//////////////////////////////////////////////////////////////////////////
// CDNSZoneWiz_RevZoneNamePropertyPage
BEGIN_MESSAGE_MAP(CDNSZoneWiz_RevZoneNamePropertyPage, CDNSZoneWiz_ZoneNamePropertyPageBase)
ON_EN_CHANGE(IDC_SUBNET_IPEDIT, OnChangeSubnetIPv4Ctrl)
// ON_EN_CHANGE(IDC_MASK_IPEDIT, OnChangeMaskIPv4Ctrl)
ON_BN_CLICKED(IDC_HELP_BUTTON, OnHelpButton)
ON_BN_CLICKED(IDC_USE_IP_RADIO, OnChangeUseIPRadio)
ON_BN_CLICKED(IDC_USE_EDIT_RADIO, OnChangeUseEditRadio)
END_MESSAGE_MAP()
CDNSZoneWiz_RevZoneNamePropertyPage::CDNSZoneWiz_RevZoneNamePropertyPage()
: CDNSZoneWiz_ZoneNamePropertyPageBase(CDNSZoneWiz_RevZoneNamePropertyPage::IDD)
{
InitWiz97(FALSE,IDS_ZWIZ_REV_ZONE_NAME_TITLE,IDS_ZWIZ_REV_ZONE_NAME_SUBTITLE);
m_bUseIP = TRUE; // default is to use IP ctrl for input
}
BOOL CDNSZoneWiz_RevZoneNamePropertyPage::OnInitDialog()
{
CPropertyPageBase::OnInitDialog();
ResetIPEditAndNameValue();
SyncRadioButtons(m_bUseIP);
return TRUE;
}
BOOL CDNSZoneWiz_RevZoneNamePropertyPage::OnSetActive()
{
if (!CDNSZoneWiz_ZoneNamePropertyPageBase::OnSetActive())
return FALSE;
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
if (m_bUseIP)
{
OnChangeSubnetIPv4Ctrl();
}
if (pHolder->m_pZoneInfo->m_szZoneName.IsEmpty())
ResetIPEditAndNameValue();
return TRUE;
}
INT
_fastcall
DnsGetDefaultClassNetworkOctetCountFromFirstOctect(
IN WORD dwFirstOctect
)
/*++
Routine Description:
Gets count of octets in network portion IP address.
Note, this is standard IP network class for given,
obviously subnetting is unknown.
Arguments:
dwFirstOctect -- first octet expressed as DWORD
Return Value:
Count of network address octets.
--*/
{
if ( dwFirstOctect > 255 )
{
// huh?
return( 0 );
}
// note addresses are in netbyte order
// which we are treating as byte flipped and hence
// test the high bits in the low byte
// class A?
if ( ! (0x80 & dwFirstOctect) )
{
return( 1 );
}
// class B?
if ( ! (0x40 & dwFirstOctect) )
{
return( 2 );
}
// then class C
// yes, there's some multicast BS out there, I don't
// believe it requires any special handling
return( 3 );
}
int _ValidFields(DWORD* dwArr)
{
// we count contiguous non empty fields
ASSERT(dwArr[3] == (DWORD)-1); // last field must be zero (disabled)
int nFields = 0;
if (dwArr[3] == (DWORD)-1)
{
if ( (dwArr[0] != (DWORD)-1) && (dwArr[1] == (DWORD)-1) && (dwArr[2] == (DWORD)-1) )
nFields = 1;
else if ( (dwArr[0] != (DWORD)-1) && (dwArr[1] != (DWORD)-1) && (dwArr[2] == (DWORD)-1) )
nFields = 2;
else if ( (dwArr[0] != (DWORD)-1) && (dwArr[1] != (DWORD)-1) && (dwArr[2] != (DWORD)-1) )
nFields = 3;
}
return nFields;
}
int _ValidMaskFields(DWORD* dwArr)
{
int nFields = _ValidFields(dwArr);
if (nFields == 0)
return nFields;
// REVIEW_MARCOC: should ask for contiguous octects....
// we currently check for non zero
for (int k=0; k<nFields; k++)
{
if (dwArr[k] == 0)
return k;
}
return nFields;
}
int _NumericFieldCount(DWORD* dwArr)
{
ASSERT(dwArr[3] == 0);
// assume [3] is always zero, check [2],[1],[0]
for (int k=2; k>=0; k--)
{
if ( (dwArr[k] > 0) && (dwArr[k] <= 255) )
return k+1;
}
return 0;
}
BOOL CDNSZoneWiz_RevZoneNamePropertyPage::BuildZoneName(DWORD* dwSubnetArr /*, DWORD* dwMaskArr*/)
{
int nSubnetFields = _ValidFields(dwSubnetArr);
WCHAR szBuf[128];
szBuf[0] = NULL; // clear edit field
// count the number of non zero/empty fields in the mask
/* int nMaskFields = 0;
if (nSubnetFields > 0)
nMaskFields = _ValidMaskFields(dwMaskArr);
if (nMaskFields > nSubnetFields)
{
// mask extends into blank subnet fields, torn them into zeroes
for (int k=nSubnetFields; k< nMaskFields; k++)
dwSubnetArr[k] = (DWORD)0;
}
*/
// format the zone name
// switch (nMaskFields)
switch (nSubnetFields)
{
case 0:
wsprintf(szBuf, L"???%s", INADDR_ARPA_SUFFIX);
break;
case 1:
ASSERT(dwSubnetArr[0] != (DWORD)-1);
wsprintf(szBuf, L"%d%s", dwSubnetArr[0], INADDR_ARPA_SUFFIX);
break;
case 2:
ASSERT(dwSubnetArr[0] != (DWORD)-1);
ASSERT(dwSubnetArr[1] != (DWORD)-1);
wsprintf(szBuf, L"%d.%d%s", dwSubnetArr[1], dwSubnetArr[0], INADDR_ARPA_SUFFIX);
break;
case 3:
ASSERT(dwSubnetArr[0] != (DWORD)-1);
ASSERT(dwSubnetArr[1] != (DWORD)-1);
ASSERT(dwSubnetArr[2] != (DWORD)-1);
wsprintf(szBuf, L"%d.%d.%d%s", dwSubnetArr[2], dwSubnetArr[1], dwSubnetArr[0], INADDR_ARPA_SUFFIX);
break;
};
GetZoneNameEdit()->SetWindowText(szBuf);
// return (nMaskFields > 0);
return (nSubnetFields > 0);
}
void CDNSZoneWiz_RevZoneNamePropertyPage::OnHelpButton()
{
CComPtr<IDisplayHelp> spHelp;
HRESULT hr = GetHolder()->GetComponentData()->GetConsole()->QueryInterface(IID_IDisplayHelp, (void **)&spHelp);
if (SUCCEEDED(hr))
spHelp->ShowTopic(L"DNSConcepts.chm::/sag_DNS_und_ReverseLookup.htm");
}
void CDNSZoneWiz_RevZoneNamePropertyPage::OnChangeSubnetIPv4Ctrl()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
BOOL bEnableNext = FALSE;
// retrieve subnet IP ctrl value
DWORD dwSubnetArr[4] = {0};
GetSubnetIPv4Ctrl()->GetArray(dwSubnetArr,4);
ASSERT(dwSubnetArr[3] == (DWORD)-1); // last field must be zero (disabled)
// determine address class
// if the first field is empty or zero, invalid class
int nSubnetValidFields = _ValidFields(dwSubnetArr);
int nClass;
if ( (dwSubnetArr[0] == (DWORD)-1) || (dwSubnetArr[0] == 0) )
nClass = 0;
else
{
if (nSubnetValidFields > 0)
nClass = DnsGetDefaultClassNetworkOctetCountFromFirstOctect(LOWORD(dwSubnetArr[0]));
else
nClass = 0; // bad format
}
ASSERT( (nClass >= 0) && (nClass <= 3) );
// set the default mask value to all zeroes
// look if the subnet extends beyond mask
/* DWORD dwMaskArr[4];
dwMaskArr[0] = dwMaskArr[1] = dwMaskArr[2] = dwMaskArr[3] = (DWORD)0;
if ((nSubnetValidFields > 0) && (nClass >0))
{
// look for last nonzero field
int nNumericCount = _NumericFieldCount(dwSubnetArr);
int j = nClass;
if (nNumericCount > nClass)
j = nNumericCount;
ASSERT((j>0) && (j<=3));
for (int i=0; i<j; i++)
dwMaskArr[i] = (DWORD)255;
}
// set the mask IP control
GetMaskIPv4Ctrl()->SetArray(dwMaskArr,4);
*/
// rebuild the zone name
bEnableNext = BuildZoneName(dwSubnetArr /*,dwMaskArr*/);
pHolder->SetWizardButtonsMiddle(bEnableNext);
}
/*
void CDNSZoneWiz_RevZoneNamePropertyPage::OnChangeMaskIPv4Ctrl()
{
ASSERT(m_bUseIP);
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
BOOL bEnableNext = FALSE;
// retrieve subnet IP ctrl value
DWORD dwSubnetArr[4];
GetSubnetIPv4Ctrl()->GetArray(dwSubnetArr,4);
ASSERT(dwSubnetArr[3] == 0); // last field must be zero (disabled)
// retrieve mask IP ctrl value
DWORD dwMaskArr[4];
GetMaskIPv4Ctrl()->GetArray(dwMaskArr,4);
// rebuild the zone name
bEnableNext = BuildZoneName(dwSubnetArr,dwMaskArr);
pHolder->SetWizardButtonsMiddle(bEnableNext);
}
*/
/*
void CDNSZoneWiz_RevZoneNamePropertyPage::OnChangeSubnetIPv4Ctrl()
{
ASSERT(m_bUseIP);
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
BOOL bEnable = FALSE;
// retrieve IP ctrl value
DWORD dwArr[4];
GetSubnetIPv4Ctrl()->GetArray(dwArr,4);
int nFields = -1;
WCHAR szBuf[128];
szBuf[0] = NULL; // clear edit field
ASSERT(dwArr[3] == 0); // last field must be zero (disabled)
if (dwArr[3] == 0)
{
if ( (dwArr[0] != (DWORD)-1) && (dwArr[1] == (DWORD)-1) && (dwArr[2] == (DWORD)-1) )
nFields = 1;
else if ( (dwArr[0] != (DWORD)-1) && (dwArr[1] != (DWORD)-1) && (dwArr[2] == (DWORD)-1) )
nFields = 2;
else if ( (dwArr[0] != (DWORD)-1) && (dwArr[1] != (DWORD)-1) && (dwArr[2] != (DWORD)-1) )
nFields = 3;
// convert to text, reverse and insert
// into the edit control
// do not consider trailing zeroes
int nValidOctect = DnsGetDefaultClassNetworkOctetCountFromFirstOctect(LOWORD(dwArr[0]));
while ((dwArr[nFields-1] == 0) && (nFields > nValidOctect) )
{
nFields--;
}
switch (nFields)
{
case 1:
wsprintf(szBuf, L"%d%s", dwArr[0], INADDR_ARPA_SUFFIX);
break;
case 2:
wsprintf(szBuf, L"%d.%d%s", dwArr[1], dwArr[0], INADDR_ARPA_SUFFIX);
break;
case 3:
wsprintf(szBuf, L"%d.%d.%d%s", dwArr[2], dwArr[1], dwArr[0], INADDR_ARPA_SUFFIX);
break;
};
}
GetZoneNameEdit()->SetWindowText(szBuf);
pHolder->SetWizardButtonsMiddle(nFields != -1);
}
*/
void CDNSZoneWiz_RevZoneNamePropertyPage::OnChangeUseIPRadio()
{
BOOL bPrevUseIP = m_bUseIP;
m_bUseIP = !m_bUseIP;
SyncRadioButtons(bPrevUseIP);
}
void CDNSZoneWiz_RevZoneNamePropertyPage::OnChangeUseEditRadio()
{
BOOL bPrevUseIP = m_bUseIP;
m_bUseIP = !m_bUseIP;
SyncRadioButtons(bPrevUseIP);
}
void CDNSZoneWiz_RevZoneNamePropertyPage::ResetIPEditAndNameValue()
{
DWORD dwArr[4];
dwArr[0] = (DWORD)-1;
dwArr[1] = dwArr[2] = dwArr[3] = (DWORD)-1;
GetSubnetIPv4Ctrl()->SetArray(dwArr, 4);
GetZoneNameEdit()->SetWindowText(NULL);
}
void CDNSZoneWiz_RevZoneNamePropertyPage::SyncRadioButtons(BOOL bPrevUseIP)
{
CButton* pUseIPRadio = GetUseIPRadio();
CButton* pUseEditRadio = GetUseEditRadio();
CDNSIPv4Control* pSubnetIPv4Ctrl = GetSubnetIPv4Ctrl();
// CDNSIPv4Control* pMaskIPv4Ctrl = GetMaskIPv4Ctrl();
// change selection
pUseIPRadio->SetCheck(m_bUseIP);
pUseEditRadio->SetCheck(!m_bUseIP);
GetZoneNameEdit()->EnableWindow(!m_bUseIP);
pSubnetIPv4Ctrl->EnableWindow(m_bUseIP);
pSubnetIPv4Ctrl->EnableField(3, FALSE); // always keep the last field disabled
// pMaskIPv4Ctrl->EnableWindow(m_bUseIP);
// pMaskIPv4Ctrl->EnableField(3, FALSE); // always keep the last field disabled
if (bPrevUseIP && !m_bUseIP)
{
// we are moving from editbox to IP control
// need to set values all over again
CString szZoneText;
GetZoneNameEdit()->GetWindowText(szZoneText);
DWORD dwArr[4];
dwArr[0] = (DWORD)-1;
dwArr[1] = dwArr[2] = dwArr[3] = (DWORD)-1;
pSubnetIPv4Ctrl->SetArray(dwArr, 4);
// dwArr[1] = dwArr[2] = (DWORD)-1;
// pMaskIPv4Ctrl->SetArray(dwArr, 4);
GetZoneNameEdit()->SetWindowText(szZoneText);
}
else
{
GetZoneNameEdit()->SetWindowText(NULL);
}
}
//////////////////////////////////////////////////////////////////////////
// CDNSZoneWiz_MastersPropertyPage
void CZoneWiz_MastersIPEditor::OnChangeData()
{
CDNSZoneWiz_MastersPropertyPage* pPage =
(CDNSZoneWiz_MastersPropertyPage*)GetParentWnd();
pPage->SetValidIPArray(GetCount() > 0);
}
CDNSZoneWiz_MastersPropertyPage::CDNSZoneWiz_MastersPropertyPage()
: CPropertyPageBase(CDNSZoneWiz_MastersPropertyPage::IDD)
{
InitWiz97(FALSE,IDS_ZWIZ_MASTERS_TITLE,IDS_ZWIZ_MASTERS_SUBTITLE);
m_bValidIPArray = FALSE;
}
BEGIN_MESSAGE_MAP(CDNSZoneWiz_MastersPropertyPage, CPropertyPageBase)
ON_BN_CLICKED(IDC_BROWSE_BUTTON, OnBrowse)
END_MESSAGE_MAP()
BOOL CDNSZoneWiz_MastersPropertyPage::OnSetActive()
{
// this page has to appear only for secondary zone
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
ASSERT(!pHolder->m_pZoneInfo->m_bPrimary);
SetUIState();
pHolder->SetWizardButtonsMiddle(m_bValidIPArray);
return CPropertyPageBase::OnSetActive();
}
LRESULT CDNSZoneWiz_MastersPropertyPage::OnWizardNext()
{
GetUIState();
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
// skip storage page for a secondary zone
if (pHolder->m_bFinishPage)
return CDNSZoneWiz_FinishPropertyPage::IDD;
// This was an else but the sundown build did not like having a control path not return a value
ASSERT(pHolder->m_nNextToPage != 0);
return pHolder->m_nNextToPage;
}
#ifdef USE_NDNC
LRESULT CDNSZoneWiz_MastersPropertyPage::OnWizardBack()
{
GetUIState();
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
if (pHolder->m_pZoneInfo->m_bIsStub &&
pHolder->m_pZoneInfo->m_storageType != CDNSCreateZoneInfo::useADS)
{
return (LRESULT)CDNSZoneWiz_StoragePropertyPage::IDD;
}
if (pHolder->m_pZoneInfo->m_bIsStub &&
pHolder->m_pZoneInfo->m_storageType == CDNSCreateZoneInfo::useADS)
{
//
// If its a pre-Whistler server then go back to the name page
//
if (pHolder->m_pZoneInfo->m_bForward)
{
return (LRESULT)CDNSZoneWiz_FwdZoneNamePropertyPage::IDD;
}
else
{
return (LRESULT)CDNSZoneWiz_RevZoneNamePropertyPage::IDD;
}
}
if (pHolder->m_pZoneInfo->m_bForward)
{
return (LRESULT)CDNSZoneWiz_FwdZoneNamePropertyPage::IDD;
}
return (LRESULT)CDNSZoneWiz_RevZoneNamePropertyPage::IDD;
}
#else
LRESULT CDNSZoneWiz_MastersPropertyPage::OnWizardBack()
{
GetUIState();
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
if (pHolder->m_pZoneInfo->m_bIsStub &&
pHolder->m_pZoneInfo->m_storageType != CDNSCreateZoneInfo::useADS)
{
return (LRESULT)CDNSZoneWiz_StoragePropertyPage::IDD;
}
if (pHolder->m_pZoneInfo->m_bForward)
return (LRESULT)CDNSZoneWiz_FwdZoneNamePropertyPage::IDD;
// This was an else but the sundown build did not like having a control path not return a value
return (LRESULT)CDNSZoneWiz_RevZoneNamePropertyPage::IDD;
}
#endif // USE_NDNC
BOOL CDNSZoneWiz_MastersPropertyPage::OnInitDialog()
{
CPropertyPageBase::OnInitDialog();
VERIFY(m_editor.Initialize(this,
GetParent(),
IDC_BUTTON_UP,
IDC_BUTTON_DOWN,
IDC_BUTTON_ADD,
IDC_BUTTON_REMOVE,
IDC_IPEDIT,
IDC_LIST));
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
void CDNSZoneWiz_MastersPropertyPage::SetValidIPArray(BOOL b)
{
m_bValidIPArray = b;
GetHolder()->SetWizardButtonsMiddle(m_bValidIPArray);
}
void CDNSZoneWiz_MastersPropertyPage::SetUIState()
{
m_editor.Clear();
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
if ( pHolder->m_pZoneInfo->m_ipMastersArray != NULL)
{
ASSERT(pHolder->m_pZoneInfo->m_nMastersCount > 0);
m_editor.AddAddresses(pHolder->m_pZoneInfo->m_ipMastersArray, pHolder->m_pZoneInfo->m_nMastersCount);
}
if ( pHolder->m_pZoneInfo->m_bIsStub &&
pHolder->m_pZoneInfo->m_storageType == CDNSCreateZoneInfo::useADS)
{
GetDlgItem(IDC_LOCAL_LIST_CHECK)->EnableWindow(TRUE);
GetDlgItem(IDC_LOCAL_LIST_CHECK)->ShowWindow(TRUE);
}
else
{
GetDlgItem(IDC_LOCAL_LIST_CHECK)->EnableWindow(FALSE);
GetDlgItem(IDC_LOCAL_LIST_CHECK)->ShowWindow(FALSE);
}
}
void CDNSZoneWiz_MastersPropertyPage::GetUIState()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
pHolder->m_pZoneInfo->ResetIpArr();
pHolder->m_pZoneInfo->m_nMastersCount = m_editor.GetCount();
if (pHolder->m_pZoneInfo->m_nMastersCount > 0)
{
pHolder->m_pZoneInfo->m_ipMastersArray = new IP_ADDRESS[pHolder->m_pZoneInfo->m_nMastersCount];
int nFilled;
m_editor.GetAddresses(pHolder->m_pZoneInfo->m_ipMastersArray, pHolder->m_pZoneInfo->m_nMastersCount, &nFilled);
ASSERT(nFilled == (int)(pHolder->m_pZoneInfo->m_nMastersCount));
LRESULT lLocalList = SendDlgItemMessage(IDC_LOCAL_LIST_CHECK, BM_GETCHECK, 0, 0);
pHolder->m_pZoneInfo->m_bLocalListOfMasters = (lLocalList == BST_CHECKED);
}
}
void CDNSZoneWiz_MastersPropertyPage::OnBrowse()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
if (!m_editor.BrowseFromDNSNamespace(pHolder->GetComponentData(),
pHolder,
TRUE,
pHolder->GetServerNode()->GetDisplayName()))
{
DNSMessageBox(IDS_MSG_ZONE_MASTERS_BROWSE_FAIL);
}
}
//////////////////////////////////////////////////////////////////////////
// CDNSZoneWiz_DynamicPropertyPage
CDNSZoneWiz_DynamicPropertyPage::CDNSZoneWiz_DynamicPropertyPage()
: CPropertyPageBase(CDNSZoneWiz_DynamicPropertyPage::IDD)
{
InitWiz97(FALSE,IDS_ZWIZ_DYNAMIC_TITLE,IDS_ZWIZ_DYNAMIC_SUBTITLE);
}
BEGIN_MESSAGE_MAP(CDNSZoneWiz_DynamicPropertyPage, CPropertyPageBase)
END_MESSAGE_MAP()
BOOL CDNSZoneWiz_DynamicPropertyPage::OnSetActive()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
SetUIState();
pHolder->SetWizardButtonsMiddle(TRUE);
return CPropertyPageBase::OnSetActive();
}
LRESULT CDNSZoneWiz_DynamicPropertyPage::OnWizardNext()
{
GetUIState();
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
//
// skip storage page for a secondary zone
//
if (pHolder->m_bFinishPage)
{
return CDNSZoneWiz_FinishPropertyPage::IDD;
}
//
// This was an else but the sundown build did not like having a control path not return a value
//
ASSERT(pHolder->m_nNextToPage != 0);
return pHolder->m_nNextToPage;
}
#ifdef USE_NDNC
LRESULT CDNSZoneWiz_DynamicPropertyPage::OnWizardBack()
{
GetUIState();
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
LRESULT nIDD = 0;
if (pHolder->m_pZoneInfo->m_bPrimary)
{
if (pHolder->m_pZoneInfo->m_storageType == CDNSCreateZoneInfo::useADS)
{
//
// If its a pre-Whistler server then go back to the name page
//
if (pHolder->m_pZoneInfo->m_bForward)
{
nIDD = (LRESULT)CDNSZoneWiz_FwdZoneNamePropertyPage::IDD;
}
else
{
nIDD = (LRESULT)CDNSZoneWiz_RevZoneNamePropertyPage::IDD;
}
}
else
{
nIDD = (LRESULT)CDNSZoneWiz_StoragePropertyPage::IDD;
}
}
else
{
nIDD = (LRESULT)CDNSZoneWiz_MastersPropertyPage::IDD;
}
return nIDD;
}
#else
LRESULT CDNSZoneWiz_DynamicPropertyPage::OnWizardBack()
{
GetUIState();
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
LRESULT nIDD = 0;
if (pHolder->m_pZoneInfo->m_bPrimary)
{
if (pHolder->m_pZoneInfo->m_storageType == CDNSCreateZoneInfo::useADS)
{
if (pHolder->m_pZoneInfo->m_bForward)
{
nIDD = (LRESULT)CDNSZoneWiz_FwdZoneNamePropertyPage::IDD;
}
else
{
nIDD = (LRESULT)CDNSZoneWiz_RevZoneNamePropertyPage::IDD;
}
}
else
{
nIDD = (LRESULT)CDNSZoneWiz_StoragePropertyPage::IDD;
}
}
else
{
nIDD = (LRESULT)CDNSZoneWiz_MastersPropertyPage::IDD;
}
return nIDD;
}
#endif // USE_NDNC
BOOL CDNSZoneWiz_DynamicPropertyPage::OnInitDialog()
{
CPropertyPageBase::OnInitDialog();
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
//
// Set the default dynamic update depending on zone type
//
if (pHolder->m_pZoneInfo->m_bPrimary &&
pHolder->m_pZoneInfo->m_storageType == CDNSCreateZoneInfo::useADS)
{
pHolder->m_pZoneInfo->m_nDynamicUpdate = ZONE_UPDATE_SECURE;
}
else
{
pHolder->m_pZoneInfo->m_nDynamicUpdate = ZONE_UPDATE_OFF;
}
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
void CDNSZoneWiz_DynamicPropertyPage::SetUIState()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
BOOL bSecureOK = (pHolder->m_pZoneInfo->m_storageType == CDNSCreateZoneInfo::useADS);
GetDlgItem(IDC_SECURE_DYNAMIC_RADIO)->EnableWindow(bSecureOK);
SendDlgItemMessage(IDC_SECURE_DYNAMIC_RADIO, BM_SETCHECK, BST_UNCHECKED, 0);
//
// If we are not allowing secure updates (standard primary) and
// the radio was checked before, change the flag so that we check
// the do not allow dynamic updates radio instead
//
UINT nDynamicUpdate = pHolder->m_pZoneInfo->m_nDynamicUpdate;
if (!bSecureOK && nDynamicUpdate == ZONE_UPDATE_SECURE)
{
nDynamicUpdate = ZONE_UPDATE_OFF;
pHolder->m_pZoneInfo->m_nDynamicUpdate = nDynamicUpdate;
}
//
// Set the radio buttons according to the zone info
//
if (nDynamicUpdate == ZONE_UPDATE_OFF)
{
SendDlgItemMessage(IDC_DENY_DYNAMIC_RADIO, BM_SETCHECK, BST_CHECKED, 0);
SendDlgItemMessage(IDC_ALLOW_DYNAMIC_RADIO, BM_SETCHECK, BST_UNCHECKED, 0);
SendDlgItemMessage(IDC_SECURE_DYNAMIC_RADIO, BM_SETCHECK, BST_UNCHECKED, 0);
}
else if (nDynamicUpdate == ZONE_UPDATE_UNSECURE)
{
SendDlgItemMessage(IDC_DENY_DYNAMIC_RADIO, BM_SETCHECK, BST_UNCHECKED, 0);
SendDlgItemMessage(IDC_ALLOW_DYNAMIC_RADIO, BM_SETCHECK, BST_CHECKED, 0);
SendDlgItemMessage(IDC_SECURE_DYNAMIC_RADIO, BM_SETCHECK, BST_UNCHECKED, 0);
}
else
{
SendDlgItemMessage(IDC_DENY_DYNAMIC_RADIO, BM_SETCHECK, BST_UNCHECKED, 0);
SendDlgItemMessage(IDC_ALLOW_DYNAMIC_RADIO, BM_SETCHECK, BST_UNCHECKED, 0);
SendDlgItemMessage(IDC_SECURE_DYNAMIC_RADIO, BM_SETCHECK, BST_CHECKED, 0);
}
}
void CDNSZoneWiz_DynamicPropertyPage::GetUIState()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
UINT nDynamicUpdate = 0;
if (SendDlgItemMessage(IDC_DENY_DYNAMIC_RADIO, BM_GETCHECK, 0, 0) == BST_CHECKED)
{
nDynamicUpdate = ZONE_UPDATE_OFF;
}
else if (SendDlgItemMessage(IDC_ALLOW_DYNAMIC_RADIO, BM_GETCHECK, 0, 0) == BST_CHECKED)
{
nDynamicUpdate = ZONE_UPDATE_UNSECURE;
}
else
{
nDynamicUpdate = ZONE_UPDATE_SECURE;
}
pHolder->m_pZoneInfo->m_nDynamicUpdate = nDynamicUpdate;
}
//////////////////////////////////////////////////////////////////////////
// CDNSZoneWiz_StoragePropertyPage
CDNSZoneWiz_StoragePropertyPage::CDNSZoneWiz_StoragePropertyPage()
: CPropertyPageBase(CDNSZoneWiz_StoragePropertyPage::IDD)
{
InitWiz97(FALSE,IDS_ZWIZ_STORAGE_TITLE,IDS_ZWIZ_STORAGE_SUBTITLE);
}
BEGIN_MESSAGE_MAP(CDNSZoneWiz_StoragePropertyPage, CPropertyPageBase)
ON_EN_CHANGE(IDC_EDIT_NEW_FILE, OnChangeNewFileZoneName)
ON_EN_CHANGE(IDC_EDIT_IMPORT_FILE, OnChangeImportFileZoneName)
ON_BN_CLICKED(IDC_RADIO_CREATE_NEW_FILE, OnChangeRadioCreateNewFile)
ON_BN_CLICKED(IDC_RADIO_IMPORT_FILE, OnChangeRadioImportFile)
END_MESSAGE_MAP()
BOOL CDNSZoneWiz_StoragePropertyPage::OnSetActive()
{
GetHolder()->SetWizardButtonsMiddle(FALSE);
SetUIState();
return CPropertyPageBase::OnSetActive();
}
LRESULT CDNSZoneWiz_StoragePropertyPage::OnWizardNext()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
GetUIState();
if (pHolder->m_pZoneInfo->m_bPrimary)
{
return CDNSZoneWiz_DynamicPropertyPage::IDD;
}
if (pHolder->m_pZoneInfo->m_bIsStub)
{
return CDNSZoneWiz_MastersPropertyPage::IDD;
}
if (pHolder->m_bFinishPage)
{
return CDNSZoneWiz_FinishPropertyPage::IDD;
}
// This was an else but the sundown build did not like having a control path not return a value
ASSERT(pHolder->m_nNextToPage != 0);
return pHolder->m_nNextToPage;
}
LRESULT CDNSZoneWiz_StoragePropertyPage::OnWizardBack()
{
GetUIState();
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
LRESULT nextPage = -1;
if (pHolder->m_pZoneInfo->m_bPrimary || pHolder->m_pZoneInfo->m_bIsStub)
{
if (pHolder->m_pZoneInfo->m_bForward)
nextPage = (LRESULT)CDNSZoneWiz_FwdZoneNamePropertyPage::IDD;
else
nextPage = (LRESULT)CDNSZoneWiz_RevZoneNamePropertyPage::IDD;
}
else
{
nextPage = (LRESULT)CDNSZoneWiz_MastersPropertyPage::IDD;
}
return nextPage;
}
BOOL CDNSZoneWiz_StoragePropertyPage::OnInitDialog()
{
CPropertyPageBase::OnInitDialog();
SendDlgItemMessage(IDC_EDIT_NEW_FILE, EM_SETLIMITTEXT, (WPARAM)_MAX_FNAME, 0);
SendDlgItemMessage(IDC_EDIT_IMPORT_FILE, EM_SETLIMITTEXT, (WPARAM)_MAX_FNAME, 0);
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
BOOL CDNSZoneWiz_StoragePropertyPage::OnKillActive()
{
// TODO
return CPropertyPage::OnKillActive();
}
void CDNSZoneWiz_StoragePropertyPage::SetUIState()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
ASSERT(pHolder->m_pZoneInfo->m_storageType != CDNSCreateZoneInfo::useADS);
CButton* pNewFileButton = (CButton*)GetDlgItem(IDC_RADIO_CREATE_NEW_FILE);
CButton* pImportFileButton = (CButton*)GetDlgItem(IDC_RADIO_IMPORT_FILE);
CEdit* pNewFileEdit = (CEdit*)GetDlgItem(IDC_EDIT_NEW_FILE);
CEdit* pImportFileEdit = (CEdit*)GetDlgItem(IDC_EDIT_IMPORT_FILE);
pNewFileEdit->SetWindowText(_T(""));
pImportFileEdit->SetWindowText(_T(""));
if (pHolder->m_pZoneInfo->m_bPrimary)
{
// all options are avalable, need to
pNewFileButton->EnableWindow(TRUE);
pNewFileButton->SetCheck(pHolder->m_pZoneInfo->m_storageType == CDNSCreateZoneInfo::newFile);
pNewFileEdit->EnableWindow(pHolder->m_pZoneInfo->m_storageType == CDNSCreateZoneInfo::newFile);
pImportFileButton->EnableWindow(TRUE);
pImportFileButton->SetCheck(pHolder->m_pZoneInfo->m_storageType == CDNSCreateZoneInfo::importFile);
pImportFileEdit->EnableWindow(pHolder->m_pZoneInfo->m_storageType == CDNSCreateZoneInfo::importFile);
if (pHolder->m_pZoneInfo->m_storageType == CDNSCreateZoneInfo::newFile)
{
m_nCurrRadio = IDC_RADIO_CREATE_NEW_FILE;
pNewFileEdit->SetWindowText(pHolder->m_pZoneInfo->m_szZoneStorage);
}
else if (pHolder->m_pZoneInfo->m_storageType == CDNSCreateZoneInfo::importFile)
{
m_nCurrRadio = IDC_RADIO_IMPORT_FILE;
pImportFileEdit->SetWindowText(pHolder->m_pZoneInfo->m_szZoneStorage);
}
}
else
{
// only new file available
pNewFileButton->EnableWindow(TRUE);
pNewFileButton->SetCheck(TRUE);
pNewFileEdit->SetWindowText(pHolder->m_pZoneInfo->m_szZoneStorage);
pNewFileEdit->EnableWindow(TRUE);
pImportFileButton->EnableWindow(FALSE);
pImportFileButton->SetCheck(FALSE);
pImportFileEdit->EnableWindow(FALSE);
m_nCurrRadio = IDC_RADIO_CREATE_NEW_FILE;
}
}
BOOL CDNSZoneWiz_StoragePropertyPage::ValidateEditBoxString(UINT nID)
{
CEdit* pEdit = (CEdit*)GetDlgItem(nID);
ASSERT(pEdit != NULL);
CString sz;
pEdit->GetWindowText(sz);
sz.TrimLeft();
sz.TrimRight();
return !sz.IsEmpty();
}
void CDNSZoneWiz_StoragePropertyPage::OnChangeNewFileZoneName()
{
GetHolder()->SetWizardButtonsMiddle(ValidateEditBoxString(IDC_EDIT_NEW_FILE));
}
void CDNSZoneWiz_StoragePropertyPage::OnChangeImportFileZoneName()
{
GetHolder()->SetWizardButtonsMiddle(ValidateEditBoxString(IDC_EDIT_IMPORT_FILE));
}
void CDNSZoneWiz_StoragePropertyPage::SyncRadioButtons(UINT nID)
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
ASSERT(pHolder->m_pZoneInfo->m_storageType != CDNSCreateZoneInfo::useADS);
CButton* pNewFileButton = (CButton*)GetDlgItem(IDC_RADIO_CREATE_NEW_FILE);
CButton* pImportFileButton = (CButton*)GetDlgItem(IDC_RADIO_IMPORT_FILE);
CEdit* pNewFileEdit = (CEdit*)GetDlgItem(IDC_EDIT_NEW_FILE);
CEdit* pImportFileEdit = (CEdit*)GetDlgItem(IDC_EDIT_IMPORT_FILE);
if (m_nCurrRadio == IDC_RADIO_CREATE_NEW_FILE)
{
pNewFileEdit->GetWindowText(pHolder->m_pZoneInfo->m_szZoneStorage);
}
else if(m_nCurrRadio == IDC_RADIO_IMPORT_FILE)
{
pImportFileEdit->GetWindowText(pHolder->m_pZoneInfo->m_szZoneStorage);
}
switch (nID)
{
case IDC_RADIO_CREATE_NEW_FILE:
{
pImportFileEdit->SetWindowText(_T(""));
pNewFileEdit->SetWindowText(pHolder->m_pZoneInfo->m_szZoneStorage);
pNewFileEdit->EnableWindow(TRUE);
pImportFileEdit->EnableWindow(FALSE);
pImportFileButton->SetCheck(FALSE);
}
break;
case IDC_RADIO_IMPORT_FILE:
{
pNewFileEdit->SetWindowText(_T(""));
pImportFileEdit->SetWindowText(pHolder->m_pZoneInfo->m_szZoneStorage);
pNewFileEdit->EnableWindow(FALSE);
pImportFileEdit->EnableWindow(TRUE);
pNewFileButton->SetCheck(FALSE);
}
break;
}
m_nCurrRadio = nID;
}
void CDNSZoneWiz_StoragePropertyPage::OnChangeRadioCreateNewFile()
{
SyncRadioButtons(IDC_RADIO_CREATE_NEW_FILE);
}
void CDNSZoneWiz_StoragePropertyPage::OnChangeRadioImportFile()
{
SyncRadioButtons(IDC_RADIO_IMPORT_FILE);
}
void CDNSZoneWiz_StoragePropertyPage::GetUIState()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
ASSERT(pHolder->m_pZoneInfo->m_storageType != CDNSCreateZoneInfo::useADS);
CButton* pNewFileButton = (CButton*)GetDlgItem(IDC_RADIO_CREATE_NEW_FILE);
CButton* pImportFileButton = (CButton*)GetDlgItem(IDC_RADIO_IMPORT_FILE);
CEdit* pNewFileEdit = (CEdit*)GetDlgItem(IDC_EDIT_NEW_FILE);
CEdit* pImportFileEdit = (CEdit*)GetDlgItem(IDC_EDIT_IMPORT_FILE);
if (pHolder->m_pZoneInfo->m_bPrimary)
{
// find the radio selection
if (pNewFileButton->GetCheck())
{
pHolder->m_pZoneInfo->m_storageType = CDNSCreateZoneInfo::newFile;
pNewFileEdit->GetWindowText(pHolder->m_pZoneInfo->m_szZoneStorage);
}
else if (pImportFileButton->GetCheck())
{
pHolder->m_pZoneInfo->m_storageType = CDNSCreateZoneInfo::importFile;
pImportFileEdit->GetWindowText(pHolder->m_pZoneInfo->m_szZoneStorage);
}
}
else
{
pNewFileEdit->GetWindowText(pHolder->m_pZoneInfo->m_szZoneStorage);
}
}
#ifdef USE_NDNC
//////////////////////////////////////////////////////////////////////////
// CDNSZoneWiz_ADReplicationPropertyPage
CDNSZoneWiz_ADReplicationPropertyPage::CDNSZoneWiz_ADReplicationPropertyPage()
: CPropertyPageBase(CDNSZoneWiz_ADReplicationPropertyPage::IDD)
{
InitWiz97(FALSE,IDS_ZWIZ_ADREPLICATION_TITLE,IDS_ZWIZ_ADREPLICATION_SUBTITLE);
}
BEGIN_MESSAGE_MAP(CDNSZoneWiz_ADReplicationPropertyPage, CPropertyPageBase)
ON_BN_CLICKED(IDC_FOREST_RADIO, OnRadioChange)
ON_BN_CLICKED(IDC_DOMAIN_RADIO, OnRadioChange)
ON_BN_CLICKED(IDC_DOMAIN_DC_RADIO, OnRadioChange)
ON_BN_CLICKED(IDC_CUSTOM_RADIO, OnRadioChange)
ON_CBN_EDITCHANGE(IDC_CUSTOM_COMBO, OnRadioChange)
ON_CBN_SELCHANGE(IDC_CUSTOM_COMBO, OnCustomComboSelChange)
END_MESSAGE_MAP()
BOOL CDNSZoneWiz_ADReplicationPropertyPage::OnSetActive()
{
GetHolder()->SetWizardButtonsMiddle(TRUE);
SetUIState();
return CPropertyPageBase::OnSetActive();
}
LRESULT CDNSZoneWiz_ADReplicationPropertyPage::OnWizardNext()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
GetUIState();
if (pHolder->m_bKnowZoneLookupType && !pHolder->m_bKnowZoneLookupTypeEx)
{
if (pHolder->m_pZoneInfo->m_bForward)
return CDNSZoneWiz_FwdZoneNamePropertyPage::IDD;
else
return CDNSZoneWiz_RevZoneNamePropertyPage::IDD;
}
return CDNSZoneWiz_ZoneLookupPropertyPage::IDD;
}
LRESULT CDNSZoneWiz_ADReplicationPropertyPage::OnWizardBack()
{
GetUIState();
return CDNSZoneWiz_ZoneTypePropertyPage::IDD;
}
BOOL CDNSZoneWiz_ADReplicationPropertyPage::OnInitDialog()
{
CPropertyPageBase::OnInitDialog();
USES_CONVERSION;
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
CDNSServerNode* pServerNode = pHolder->GetServerNode();
//
// Get the forest and domain names and format them into the UI
//
PCWSTR pszDomainName = UTF8_TO_W(pServerNode->GetDomainName());
PCWSTR pszForestName = UTF8_TO_W(pServerNode->GetForestName());
ASSERT(pszDomainName);
ASSERT(pszForestName);
CString szWin2KReplText;
szWin2KReplText.Format(IDS_ZWIZ_AD_REPL_FORMAT, pszDomainName);
SetDlgItemText(IDC_DOMAIN_DC_RADIO, szWin2KReplText);
CString szDNSDomainText;
szDNSDomainText.Format(IDS_ZWIZ_AD_DOMAIN_FORMAT, pszDomainName);
SetDlgItemText(IDC_DOMAIN_RADIO, szDNSDomainText);
CString szDNSForestText;
szDNSForestText.Format(IDS_ZWIZ_AD_FOREST_FORMAT, pszForestName);
SetDlgItemText(IDC_FOREST_RADIO, szDNSForestText);
//
// Enumerate the NDNCs available for storage
//
PDNS_RPC_DP_LIST pDirectoryPartitions = NULL;
DWORD dwErr = ::DnssrvEnumDirectoryPartitions(pServerNode->GetRPCName(),
DNS_DP_ENLISTED,
&pDirectoryPartitions);
//
// Don't show an error if we are not able to get the available directory partitions
// We can still continue on and the user can type in the directory partition they need
//
if (dwErr == 0 && pDirectoryPartitions)
{
for (DWORD dwIdx = 0; dwIdx < pDirectoryPartitions->dwDpCount; dwIdx++)
{
PDNS_RPC_DP_INFO pDirectoryPartition = 0;
dwErr = ::DnssrvDirectoryPartitionInfo(pServerNode->GetRPCName(),
pDirectoryPartitions->DpArray[dwIdx]->pszDpFqdn,
&pDirectoryPartition);
if (dwErr == 0 && pDirectoryPartition)
{
//
// Only add the partition if it is not one of the autocreated ones
// and the DNS server is enlisted in the partition
//
if (!(pDirectoryPartition->dwFlags & DNS_DP_AUTOCREATED) &&
(pDirectoryPartition->dwFlags & DNS_DP_ENLISTED))
{
SendDlgItemMessage(IDC_CUSTOM_COMBO,
CB_ADDSTRING,
0,
(LPARAM)UTF8_TO_W(pDirectoryPartition->pszDpFqdn));
}
::DnssrvFreeDirectoryPartitionInfo(pDirectoryPartition);
}
}
::DnssrvFreeDirectoryPartitionList(pDirectoryPartitions);
}
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
BOOL CDNSZoneWiz_ADReplicationPropertyPage::OnKillActive()
{
// TODO
return CPropertyPage::OnKillActive();
}
void CDNSZoneWiz_ADReplicationPropertyPage::SetUIState()
{
SyncRadioButtons();
}
void CDNSZoneWiz_ADReplicationPropertyPage::OnRadioChange()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
if (SendDlgItemMessage(IDC_FOREST_RADIO, BM_GETCHECK, 0, 0) == BST_CHECKED)
{
pHolder->m_pZoneInfo->m_replType = forest;
}
else if (SendDlgItemMessage(IDC_DOMAIN_RADIO, BM_GETCHECK, 0, 0) == BST_CHECKED)
{
pHolder->m_pZoneInfo->m_replType = domain;
}
else if (SendDlgItemMessage(IDC_DOMAIN_DC_RADIO, BM_GETCHECK, 0, 0) == BST_CHECKED)
{
pHolder->m_pZoneInfo->m_replType = w2k;
}
else if (SendDlgItemMessage(IDC_CUSTOM_RADIO, BM_GETCHECK, 0, 0) == BST_CHECKED)
{
pHolder->m_pZoneInfo->m_replType = custom;
}
else
{
// at least one radio button must be selected
ASSERT(FALSE);
}
SyncRadioButtons();
}
void CDNSZoneWiz_ADReplicationPropertyPage::SyncRadioButtons()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
switch (pHolder->m_pZoneInfo->m_replType)
{
case forest:
SendDlgItemMessage(IDC_FOREST_RADIO, BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
SendDlgItemMessage(IDC_DOMAIN_RADIO, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
SendDlgItemMessage(IDC_DOMAIN_DC_RADIO, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
SendDlgItemMessage(IDC_CUSTOM_RADIO, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
GetDlgItem(IDC_CUSTOM_COMBO)->EnableWindow(FALSE);
GetDlgItem(IDC_CUSTOM_STATIC)->EnableWindow(FALSE);
break;
case domain:
SendDlgItemMessage(IDC_DOMAIN_RADIO, BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
SendDlgItemMessage(IDC_FOREST_RADIO, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
SendDlgItemMessage(IDC_DOMAIN_DC_RADIO, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
SendDlgItemMessage(IDC_CUSTOM_RADIO, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
GetDlgItem(IDC_CUSTOM_COMBO)->EnableWindow(FALSE);
GetDlgItem(IDC_CUSTOM_STATIC)->EnableWindow(FALSE);
break;
case w2k:
SendDlgItemMessage(IDC_DOMAIN_DC_RADIO, BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
SendDlgItemMessage(IDC_FOREST_RADIO, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
SendDlgItemMessage(IDC_DOMAIN_RADIO, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
SendDlgItemMessage(IDC_CUSTOM_RADIO, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
GetDlgItem(IDC_CUSTOM_COMBO)->EnableWindow(FALSE);
GetDlgItem(IDC_CUSTOM_STATIC)->EnableWindow(FALSE);
break;
case custom:
SendDlgItemMessage(IDC_CUSTOM_RADIO, BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
SendDlgItemMessage(IDC_FOREST_RADIO, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
SendDlgItemMessage(IDC_DOMAIN_RADIO, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
SendDlgItemMessage(IDC_DOMAIN_DC_RADIO, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
GetDlgItem(IDC_CUSTOM_COMBO)->EnableWindow(TRUE);
GetDlgItem(IDC_CUSTOM_STATIC)->EnableWindow(TRUE);
break;
default:
SendDlgItemMessage(IDC_DOMAIN_RADIO, BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
SendDlgItemMessage(IDC_FOREST_RADIO, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
SendDlgItemMessage(IDC_DOMAIN_DC_RADIO, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
SendDlgItemMessage(IDC_CUSTOM_RADIO, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
GetDlgItem(IDC_CUSTOM_COMBO)->EnableWindow(FALSE);
GetDlgItem(IDC_CUSTOM_STATIC)->EnableWindow(FALSE);
break;
}
if (BST_CHECKED == SendDlgItemMessage(IDC_CUSTOM_RADIO, BM_GETCHECK, 0, 0))
{
CString szTemp;
GetDlgItemText(IDC_CUSTOM_COMBO, szTemp);
pHolder->SetWizardButtonsMiddle(!szTemp.IsEmpty());
}
else
{
pHolder->SetWizardButtonsMiddle(TRUE);
}
}
void CDNSZoneWiz_ADReplicationPropertyPage::OnCustomComboSelChange()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
LRESULT iSel = SendDlgItemMessage(IDC_CUSTOM_COMBO, CB_GETCURSEL, 0, 0);
if (CB_ERR != iSel)
{
CString szTemp;
CComboBox* pComboBox = reinterpret_cast<CComboBox*>(GetDlgItem(IDC_CUSTOM_COMBO));
ASSERT(pComboBox);
pComboBox->GetLBText(static_cast<int>(iSel), szTemp);
pHolder->SetWizardButtonsMiddle(!szTemp.IsEmpty());
}
else
{
pHolder->SetWizardButtonsMiddle(FALSE);
}
}
void CDNSZoneWiz_ADReplicationPropertyPage::GetUIState()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
if (SendDlgItemMessage(IDC_FOREST_RADIO, BM_GETCHECK, 0, 0) == BST_CHECKED)
{
pHolder->m_pZoneInfo->m_replType = forest;
}
else if (SendDlgItemMessage(IDC_DOMAIN_RADIO, BM_GETCHECK, 0, 0) == BST_CHECKED)
{
pHolder->m_pZoneInfo->m_replType = domain;
}
else if (SendDlgItemMessage(IDC_DOMAIN_DC_RADIO, BM_GETCHECK, 0, 0) == BST_CHECKED)
{
pHolder->m_pZoneInfo->m_replType = w2k;
}
else if (SendDlgItemMessage(IDC_CUSTOM_RADIO, BM_GETCHECK, 0, 0) == BST_CHECKED)
{
pHolder->m_pZoneInfo->m_replType = custom;
}
else
{
// at least one radio button must be checked
ASSERT(FALSE);
}
SyncRadioButtons();
CComboBox* pCustomCombo = reinterpret_cast<CComboBox*>(GetDlgItem(IDC_CUSTOM_COMBO));
ASSERT(pCustomCombo);
int iSel = pCustomCombo->GetCurSel();
if (iSel != CB_ERR)
{
pCustomCombo->GetLBText(iSel, pHolder->m_pZoneInfo->m_szCustomReplName);
}
else
{
pCustomCombo->GetWindowText(pHolder->m_pZoneInfo->m_szCustomReplName);
}
}
#endif // USE_NDNC
//////////////////////////////////////////////////////////////////////////
// CDNSZoneWiz_FinishPropertyPage
CDNSZoneWiz_FinishPropertyPage::CDNSZoneWiz_FinishPropertyPage()
: CPropertyPageBase(CDNSZoneWiz_FinishPropertyPage::IDD),
m_typeText(N_ZONEWIZ_TYPES)
{
InitWiz97(TRUE,0,0);
}
BOOL CDNSZoneWiz_FinishPropertyPage::OnInitDialog()
{
CPropertyPageBase::OnInitDialog();
SetBigBoldFont(m_hWnd, IDC_STATIC_COMPLETE);
VERIFY(m_typeText.Init(this,IDC_TYPE_STATIC));
VERIFY(m_lookupText.Init(this,IDC_LOOKUP_STATIC));
return TRUE;
}
LRESULT CDNSZoneWiz_FinishPropertyPage::OnWizardBack()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
if (pHolder->m_pZoneInfo->m_bPrimary)
{
return (LRESULT)CDNSZoneWiz_DynamicPropertyPage::IDD;
}
// This was an else but the sundown build did not like having a control path not return a value
return (LRESULT)CDNSZoneWiz_MastersPropertyPage::IDD; // secondary
}
BOOL CDNSZoneWiz_FinishPropertyPage::OnWizardFinish()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
return pHolder->CreateZone();
}
BOOL CDNSZoneWiz_FinishPropertyPage::OnSetActive()
{
GetHolder()->SetWizardButtonsLast(TRUE);
DisplaySummaryInfo();
return CPropertyPageBase::OnSetActive();
}
void CDNSZoneWiz_FinishPropertyPage::DisplaySummaryInfo()
{
CDNSZoneWizardHolder* pHolder = (CDNSZoneWizardHolder*)GetHolder();
GetDlgItem(IDC_NAME_STATIC)->SetWindowText(pHolder->m_pZoneInfo->m_szZoneName);
BOOL bUseADS = pHolder->m_pZoneInfo->m_storageType == CDNSCreateZoneInfo::useADS;
int nType;
if (pHolder->m_pZoneInfo->m_bPrimary)
{
nType = bUseADS ? N_ZONEWIZ_TYPES_DS_PRIMARY : N_ZONEWIZ_TYPES_PRIMARY;
}
else
{
if (pHolder->m_pZoneInfo->m_bIsStub)
{
nType = N_ZONEWIZ_TYPES_STUB;
}
else
{
nType = N_ZONEWIZ_TYPES_SECONDARY;
}
}
m_typeText.SetStateX(nType);
m_lookupText.SetToggleState(pHolder->m_pZoneInfo->m_bForward);
GetDlgItem(IDC_STORAGE_TYPE_STATIC)->ShowWindow(!bUseADS);
CStatic* pStorageNameStatic = (CStatic*)GetDlgItem(IDC_STORAGE_NAME_STATIC);
pStorageNameStatic->ShowWindow(!bUseADS);
LPCTSTR lpszText = bUseADS ? NULL : (LPCTSTR)(pHolder->m_pZoneInfo->m_szZoneStorage);
pStorageNameStatic->SetWindowText(lpszText);
}
Reference in a new issue Copy permalink