2817 lines
80 KiB
C++
2817 lines
80 KiB
C++
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (C) Microsoft Corporation, 1998 - 1999
|
|
//
|
|
// File: serverui.cpp
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
#include "preDNSsn.h"
|
|
#include <SnapBase.h>
|
|
|
|
#include "resource.h"
|
|
#include "dnsutil.h"
|
|
#include "DNSSnap.h"
|
|
#include "snapdata.h"
|
|
|
|
#include "server.h"
|
|
#include "serverUI.h"
|
|
#include "servwiz.h" // CRootHintsQueryThread
|
|
#include "domain.h"
|
|
#include "zone.h"
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// CDNSServer_InterfacesPropertyPage
|
|
|
|
BEGIN_MESSAGE_MAP(CDNSServer_InterfacesPropertyPage, CPropertyPageBase)
|
|
ON_BN_CLICKED(IDC_LISTEN_ON_ALL_RADIO, OnListenOnAllAddresses)
|
|
ON_BN_CLICKED(IDC_LISTEN_ON_SPECIFIED_RADIO, OnListenOnSpecifiedAddresses)
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
void CDNSServer_InterfacesPropertyPage::CListenAddressesIPEditor::OnChangeData()
|
|
{
|
|
CDNSServer_InterfacesPropertyPage* pPage =
|
|
(CDNSServer_InterfacesPropertyPage*)GetParentWnd();
|
|
pPage->SetDirty(TRUE);
|
|
if (GetCount() == 0)
|
|
{
|
|
CButton* pListenAllButton = pPage->GetListenOnAllRadio();
|
|
pListenAllButton->SetCheck(TRUE);
|
|
pPage->GetListenOnSpecifiedRadio()->SetCheck(FALSE);
|
|
pPage->SelectionHelper(TRUE);
|
|
pListenAllButton->SetFocus();
|
|
}
|
|
}
|
|
|
|
|
|
CDNSServer_InterfacesPropertyPage::CDNSServer_InterfacesPropertyPage()
|
|
: m_bAllWasPreviousSelection(FALSE),
|
|
CPropertyPageBase(IDD_SERVER_INTERFACES_PAGE)
|
|
{
|
|
}
|
|
|
|
|
|
BOOL CDNSServer_InterfacesPropertyPage::OnInitDialog()
|
|
{
|
|
CPropertyPageBase::OnInitDialog();
|
|
|
|
CDNSServerPropertyPageHolder* pHolder =
|
|
(CDNSServerPropertyPageHolder*)GetHolder();
|
|
CDNSServerNode* pServerNode = pHolder->GetServerNode();
|
|
|
|
VERIFY(m_listenAddressesEditor.Initialize(this,
|
|
GetParent(),
|
|
IDC_BUTTON_UP,
|
|
IDC_BUTTON_DOWN,
|
|
IDC_BUTTON_ADD,
|
|
IDC_BUTTON_REMOVE,
|
|
IDC_IPEDIT,
|
|
IDC_LIST));
|
|
|
|
if (!pServerNode->HasServerInfo())
|
|
{
|
|
EnableWindow(FALSE);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL bListenAll = FALSE;
|
|
DWORD cAddrCount;
|
|
PIP_ADDRESS pipAddrs;
|
|
pServerNode->GetListenAddressesInfo(&cAddrCount, &pipAddrs);
|
|
if (cAddrCount == 0)
|
|
{
|
|
// listening on all addresses
|
|
pServerNode->GetServerAddressesInfo(&cAddrCount, &pipAddrs);
|
|
bListenAll = TRUE;
|
|
m_bAllWasPreviousSelection = TRUE;
|
|
}
|
|
GetListenOnAllRadio()->SetCheck(bListenAll);
|
|
GetListenOnSpecifiedRadio()->SetCheck(!bListenAll);
|
|
if (cAddrCount > 0)
|
|
{
|
|
m_listenAddressesEditor.AddAddresses(pipAddrs, cAddrCount);
|
|
m_bAllWasPreviousSelection = FALSE;
|
|
}
|
|
m_listenAddressesEditor.EnableUI(!bListenAll, TRUE);
|
|
|
|
SetDirty(FALSE);
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
void CDNSServer_InterfacesPropertyPage::SelectionHelper(BOOL bListenAll)
|
|
{
|
|
CDNSServerPropertyPageHolder* pHolder =
|
|
(CDNSServerPropertyPageHolder*)GetHolder();
|
|
CDNSServerNode* pServerNode = pHolder->GetServerNode();
|
|
|
|
if ((m_bAllWasPreviousSelection && !bListenAll) || bListenAll)
|
|
{
|
|
m_listenAddressesEditor.Clear();
|
|
}
|
|
DWORD cAddrCount;
|
|
PIP_ADDRESS pipAddrs;
|
|
pServerNode->GetServerAddressesInfo(&cAddrCount, &pipAddrs);
|
|
if (cAddrCount > 0)
|
|
{
|
|
m_listenAddressesEditor.AddAddresses(pipAddrs, cAddrCount);
|
|
}
|
|
m_listenAddressesEditor.EnableUI(!bListenAll, TRUE);
|
|
|
|
m_bAllWasPreviousSelection = bListenAll;
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
void CDNSServer_InterfacesPropertyPage::OnListenOnSpecifiedAddresses()
|
|
{
|
|
//ASSERT(!GetListenOnAllRadio()->GetCheck());
|
|
//ASSERT(GetListenOnSpecifiedRadio()->GetCheck());
|
|
|
|
SelectionHelper(FALSE);
|
|
}
|
|
|
|
void CDNSServer_InterfacesPropertyPage::OnListenOnAllAddresses()
|
|
{
|
|
//ASSERT(GetListenOnAllRadio()->GetCheck());
|
|
//ASSERT(!GetListenOnSpecifiedRadio()->GetCheck());
|
|
SelectionHelper(TRUE);
|
|
}
|
|
|
|
|
|
BOOL CDNSServer_InterfacesPropertyPage::OnApply()
|
|
{
|
|
CDNSServerPropertyPageHolder* pHolder =
|
|
(CDNSServerPropertyPageHolder*)GetHolder();
|
|
CDNSServerNode* pServerNode = pHolder->GetServerNode();
|
|
|
|
if (!IsDirty())
|
|
return TRUE;
|
|
|
|
int cAddrCount = 0;
|
|
if (GetListenOnSpecifiedRadio()->GetCheck())
|
|
{
|
|
// get the data from the IP editor
|
|
cAddrCount = m_listenAddressesEditor.GetCount();
|
|
}
|
|
|
|
BOOL bRet = TRUE;
|
|
DWORD* pArr = (cAddrCount > 0) ? (DWORD*) malloc(sizeof(DWORD)*cAddrCount) : NULL;
|
|
if (pArr != NULL && cAddrCount > 0)
|
|
{
|
|
int nFilled = 0;
|
|
m_listenAddressesEditor.GetAddresses(pArr, cAddrCount, &nFilled);
|
|
ASSERT(nFilled == cAddrCount);
|
|
}
|
|
|
|
// write to server
|
|
DNS_STATUS err = pServerNode->ResetListenAddresses(cAddrCount, pArr);
|
|
if (err != 0)
|
|
{
|
|
DNSErrorDialog(err, IDS_MSG_SERVER_INTERFACE_UPDATE_FAILED);
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if (pArr)
|
|
{
|
|
free(pArr);
|
|
pArr = 0;
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// CDomainForwardersEditInfo
|
|
|
|
CDomainForwardersEditInfo::CDomainForwardersEditInfo(
|
|
CDNSZoneNode* pZoneNode,
|
|
BOOL bADIntegrated,
|
|
BOOL bAllOthers)
|
|
: m_bADIntegrated(bADIntegrated),
|
|
m_pZoneNode(pZoneNode)
|
|
{
|
|
m_bAllOthersDomain = bAllOthers;
|
|
m_actionItem = nochange;
|
|
|
|
if (pZoneNode != NULL)
|
|
{
|
|
m_bRPCData = TRUE;
|
|
pZoneNode->GetMastersInfo(&m_cAddrCount, &m_pIPList);
|
|
m_szDomainName = pZoneNode->GetDisplayName();
|
|
|
|
m_bSlave = pZoneNode->IsForwarderSlave();
|
|
m_dwTimeout = pZoneNode->ForwarderTimeout();
|
|
}
|
|
else
|
|
{
|
|
m_bRPCData = FALSE;
|
|
m_cAddrCount = 0;
|
|
m_pIPList = NULL;
|
|
m_szDomainName = L"";
|
|
m_bSlave = DNS_DEFAULT_SLAVE;
|
|
m_dwTimeout = DNS_DEFAULT_FORWARD_TIMEOUT;
|
|
}
|
|
}
|
|
|
|
CDomainForwardersEditInfo::~CDomainForwardersEditInfo()
|
|
{
|
|
if (m_bAllOthersDomain && m_pAllOthers != NULL)
|
|
{
|
|
delete m_pAllOthers;
|
|
}
|
|
|
|
if (m_pIPList != NULL && m_actionItem != nochange)
|
|
{
|
|
free(m_pIPList);
|
|
m_pIPList = NULL;
|
|
}
|
|
}
|
|
|
|
void CDomainForwardersEditInfo::SetAllOthersDomain(CAllOthersDomainInfo* pAllOthers)
|
|
{
|
|
if (pAllOthers != NULL)
|
|
{
|
|
m_bAllOthersDomain = TRUE;
|
|
m_pAllOthers = pAllOthers;
|
|
m_cAddrCount = m_pAllOthers->m_cAddrCount;
|
|
m_pIPList = m_pAllOthers->m_pipAddrs;
|
|
m_bSlave = m_pAllOthers->m_fSlave;
|
|
m_dwTimeout = m_pAllOthers->m_dwForwardTimeout;
|
|
}
|
|
}
|
|
|
|
void CDomainForwardersEditInfo::SetAction(ACTION_ITEM action)
|
|
{
|
|
m_actionItem = action;
|
|
}
|
|
|
|
BOOL CDomainForwardersEditInfo::Update(BOOL bSlave, DWORD dwTimeout, DWORD dwCount, PIP_ADDRESS pipArray)
|
|
{
|
|
BOOL bUpdate = FALSE;
|
|
|
|
if (bSlave != m_bSlave ||
|
|
dwTimeout != m_dwTimeout)
|
|
{
|
|
bUpdate = TRUE;
|
|
|
|
m_bSlave = bSlave;
|
|
m_dwTimeout = dwTimeout;
|
|
}
|
|
|
|
if (dwCount != m_cAddrCount)
|
|
{
|
|
if (m_pIPList != NULL)
|
|
{
|
|
if (!m_bRPCData)
|
|
{
|
|
//
|
|
// Free the memory if it isn't part of the RPC structure
|
|
//
|
|
free(m_pIPList);
|
|
m_pIPList = NULL;
|
|
}
|
|
}
|
|
m_bRPCData = FALSE;
|
|
m_pIPList = pipArray;
|
|
m_cAddrCount = dwCount;
|
|
bUpdate = TRUE;
|
|
}
|
|
else
|
|
{
|
|
if (m_pIPList != NULL)
|
|
{
|
|
for (UINT nIndex = 0; nIndex < dwCount; nIndex++)
|
|
{
|
|
if (nIndex <= m_cAddrCount)
|
|
{
|
|
if (pipArray[nIndex] != m_pIPList[nIndex])
|
|
{
|
|
bUpdate = TRUE;
|
|
if (!m_bRPCData)
|
|
{
|
|
free(m_pIPList);
|
|
m_pIPList = NULL;
|
|
}
|
|
m_bRPCData = FALSE;
|
|
m_pIPList = pipArray;
|
|
m_cAddrCount = dwCount;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bUpdate = TRUE;
|
|
if (m_actionItem != nochange)
|
|
{
|
|
free(m_pIPList);
|
|
m_pIPList = NULL;
|
|
}
|
|
m_pIPList = pipArray;
|
|
m_cAddrCount = dwCount;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (m_pIPList != NULL && dwCount > 0)
|
|
{
|
|
bUpdate = TRUE;
|
|
m_pIPList = pipArray;
|
|
m_cAddrCount = dwCount;
|
|
}
|
|
}
|
|
|
|
if (bUpdate)
|
|
{
|
|
switch (GetAction())
|
|
{
|
|
case nochange:
|
|
case update:
|
|
SetAction(update);
|
|
break;
|
|
case remove:
|
|
case add:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return bUpdate;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// CDNSServer_AddDomainForwarderDialog
|
|
|
|
class CDNSServer_AddDomainForwarderDialog : public CHelpDialog
|
|
{
|
|
public:
|
|
CDNSServer_AddDomainForwarderDialog(CDNSServerNode* pServerNode,
|
|
CComponentDataObject* pComponentData)
|
|
: CHelpDialog(IDD_SERVER_NEW_DOMAIN_FORWARDER, pComponentData),
|
|
m_pComponentData(pComponentData),
|
|
m_pServerNode(pServerNode)
|
|
{
|
|
m_bOkable = FALSE;
|
|
m_szDomainName = L"";
|
|
}
|
|
|
|
~CDNSServer_AddDomainForwarderDialog() {}
|
|
|
|
//
|
|
// Public data
|
|
//
|
|
CString m_szDomainName;
|
|
|
|
DECLARE_MESSAGE_MAP()
|
|
|
|
virtual BOOL OnInitDialog();
|
|
virtual void OnOK();
|
|
afx_msg void OnDomainEdit();
|
|
|
|
private:
|
|
BOOL m_bOkable;
|
|
CDNSServerNode* m_pServerNode;
|
|
CComponentDataObject* m_pComponentData;
|
|
};
|
|
|
|
BEGIN_MESSAGE_MAP(CDNSServer_AddDomainForwarderDialog, CHelpDialog)
|
|
ON_EN_CHANGE(IDC_DOMAIN_NAME_EDIT, OnDomainEdit)
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
BOOL CDNSServer_AddDomainForwarderDialog::OnInitDialog()
|
|
{
|
|
CHelpDialog::OnInitDialog();
|
|
|
|
GetDlgItem(IDOK)->EnableWindow(m_bOkable);
|
|
SendDlgItemMessage(IDC_DOMAIN_NAME_EDIT, EM_SETLIMITTEXT, (WPARAM)254, 0);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void CDNSServer_AddDomainForwarderDialog::OnDomainEdit()
|
|
{
|
|
GetDlgItemText(IDC_DOMAIN_NAME_EDIT, m_szDomainName);
|
|
m_bOkable = !m_szDomainName.IsEmpty();
|
|
GetDlgItem(IDOK)->EnableWindow(m_bOkable);
|
|
}
|
|
|
|
void CDNSServer_AddDomainForwarderDialog::OnOK()
|
|
{
|
|
DNS_STATUS err = ::ValidateDnsNameAgainstServerFlags(m_szDomainName,
|
|
DnsNameDomain,
|
|
m_pServerNode->GetNameCheckFlag());
|
|
if (err != 0)
|
|
{
|
|
CString szFormatMsg;
|
|
VERIFY(szFormatMsg.LoadString(IDS_MSG_DOMAIN_FORWARDER_ILLEGAL_NAME));
|
|
CString szMessage;
|
|
szMessage.Format(szFormatMsg, m_szDomainName);
|
|
|
|
DNSErrorDialog(err, szMessage);
|
|
return;
|
|
}
|
|
CHelpDialog::OnOK();
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// CDNSServer_DomainForwardersPropertyPage
|
|
|
|
void CDNSServer_DomainForwardersPropertyPage::CForwarderAddressesIPEditor::OnChangeData()
|
|
{
|
|
CDNSServer_DomainForwardersPropertyPage* pPage =
|
|
(CDNSServer_DomainForwardersPropertyPage*)GetParentWnd();
|
|
pPage->SetDirty(TRUE);
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CDNSServer_DomainForwardersPropertyPage, CPropertyPageBase)
|
|
ON_LBN_SELCHANGE(IDC_DOMAIN_LIST, OnDomainSelChange)
|
|
ON_BN_CLICKED(IDC_DOMAIN_ADD_BUTTON, OnAddDomain)
|
|
ON_BN_CLICKED(IDC_DOMAIN_REMOVE_BUTTON, OnRemoveDomain)
|
|
ON_BN_CLICKED(IDC_SLAVE_CHECK, OnSlaveCheckChange)
|
|
ON_EN_CHANGE(IDC_FWD_TIMEOUT_EDIT, OnForwarderTimeoutChange)
|
|
END_MESSAGE_MAP()
|
|
|
|
CDNSServer_DomainForwardersPropertyPage::CDNSServer_DomainForwardersPropertyPage()
|
|
: CPropertyPageBase(IDD_SERVER_DOMAIN_FORWARDERS_PAGE)
|
|
{
|
|
m_pCurrentInfo = NULL;
|
|
m_bPostApply = FALSE;
|
|
}
|
|
|
|
void CDNSServer_DomainForwardersPropertyPage::OnDomainSelChange()
|
|
{
|
|
CDNSServerPropertyPageHolder* pHolder =
|
|
(CDNSServerPropertyPageHolder*)GetHolder();
|
|
CDNSServerNode* pServerNode = pHolder->GetServerNode();
|
|
|
|
CListBox* pDomainList = (CListBox*)GetDlgItem(IDC_DOMAIN_LIST);
|
|
if (pDomainList != NULL)
|
|
{
|
|
int iSel = pDomainList->GetCurSel();
|
|
if (iSel != LB_ERR)
|
|
{
|
|
LRESULT lRes = pDomainList->GetItemData(iSel);
|
|
if (lRes != LB_ERR)
|
|
{
|
|
//
|
|
// Retrieve the edit info from the list box item
|
|
//
|
|
CDomainForwardersEditInfo* pInfo = reinterpret_cast<CDomainForwardersEditInfo*>(lRes);
|
|
if (pInfo != NULL)
|
|
{
|
|
//
|
|
// Store the previous selection's data before changing the UI.
|
|
// This may be NULL during OnInitDialog so check before trying
|
|
// to store the info.
|
|
//
|
|
if (m_pCurrentInfo != NULL)
|
|
{
|
|
BOOL bSlave = GetSlaveCheck()->GetCheck();
|
|
DWORD dwTimeout = m_forwardTimeoutEdit.GetVal();
|
|
|
|
DWORD cAddrCount = m_forwarderAddressesEditor.GetCount();
|
|
DWORD* pArr = (cAddrCount > 0) ? (DWORD*) malloc(sizeof(DWORD)*cAddrCount) : NULL;
|
|
if (pArr != NULL)
|
|
{
|
|
if (cAddrCount > 0)
|
|
{
|
|
int nFilled = 0;
|
|
m_forwarderAddressesEditor.GetAddresses(pArr, cAddrCount, &nFilled);
|
|
ASSERT(nFilled == (int)cAddrCount);
|
|
}
|
|
}
|
|
m_pCurrentInfo->Update(bSlave, dwTimeout, cAddrCount, pArr);
|
|
}
|
|
|
|
m_pCurrentInfo = pInfo;
|
|
|
|
//
|
|
// Enable the remove button according to the selection
|
|
//
|
|
if (pInfo->IsAllOthers())
|
|
{
|
|
GetDlgItem(IDC_DOMAIN_REMOVE_BUTTON)->EnableWindow(FALSE);
|
|
}
|
|
else
|
|
{
|
|
GetDlgItem(IDC_DOMAIN_REMOVE_BUTTON)->EnableWindow(TRUE);
|
|
}
|
|
|
|
if (pServerNode->GetBuildNumber() < DNS_SRV_BUILD_NUMBER_WHISTLER ||
|
|
(pServerNode->GetMajorVersion() <= DNS_SRV_MAJOR_VERSION_NT_5 &&
|
|
pServerNode->GetMinorVersion() < DNS_SRV_MINOR_VERSION_WHISTLER))
|
|
{
|
|
//
|
|
// Domain forwarding not available on pre-Whistler servers
|
|
//
|
|
GetDlgItem(IDC_DOMAIN_ADD_BUTTON)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_DOMAIN_REMOVE_BUTTON)->EnableWindow(FALSE);
|
|
}
|
|
|
|
//
|
|
// load data into the controls
|
|
//
|
|
GetSlaveCheck()->SetCheck(pInfo->IsSlave());
|
|
m_forwardTimeoutEdit.SetVal(pInfo->GetTimeout());
|
|
|
|
//
|
|
// Display the text of the forwarder is AD integrated
|
|
//
|
|
GetDlgItem(IDC_FORWARDER_ADINT_STATIC)->ShowWindow(pInfo->IsADIntegrated());
|
|
|
|
//
|
|
// Clear the IP Editor controls
|
|
//
|
|
m_forwarderAddressesEditor.Clear();
|
|
|
|
DWORD cAddrCount = 0;
|
|
PIP_ADDRESS pipAddrs = pInfo->GetIPList(&cAddrCount);
|
|
if (cAddrCount > 0 && pipAddrs != NULL)
|
|
{
|
|
m_forwarderAddressesEditor.AddAddresses(pipAddrs, cAddrCount);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
void CDNSServer_DomainForwardersPropertyPage::OnAddDomain()
|
|
{
|
|
CDNSServerPropertyPageHolder* pHolder =
|
|
(CDNSServerPropertyPageHolder*)GetHolder();
|
|
CDNSServerNode* pServerNode = pHolder->GetServerNode();
|
|
|
|
CDNSServer_AddDomainForwarderDialog dlg(pServerNode, pHolder->GetComponentData());
|
|
if (dlg.DoModal() == IDOK)
|
|
{
|
|
CListBox* pDomainList = (CListBox*)GetDlgItem(IDC_DOMAIN_LIST);
|
|
|
|
//
|
|
// Check to see if the name already exists
|
|
//
|
|
int iIndex = LB_ERR;
|
|
int iFindIdx = pDomainList->FindStringExact(-1, dlg.m_szDomainName);
|
|
if (iFindIdx == LB_ERR)
|
|
{
|
|
//
|
|
// Add the name if it isn't already there
|
|
//
|
|
iIndex = pDomainList->AddString(dlg.m_szDomainName);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// If its there just point to it
|
|
//
|
|
iIndex = iFindIdx;
|
|
}
|
|
|
|
if (iIndex != LB_ERR)
|
|
{
|
|
CDomainForwardersEditInfo* pSearchInfo = m_EditList.DoesExist(dlg.m_szDomainName);
|
|
if (pSearchInfo != NULL)
|
|
{
|
|
switch (pSearchInfo->GetAction())
|
|
{
|
|
case CDomainForwardersEditInfo::nochange:
|
|
case CDomainForwardersEditInfo::update:
|
|
case CDomainForwardersEditInfo::remove:
|
|
pSearchInfo->SetAction(CDomainForwardersEditInfo::update);
|
|
break;
|
|
case CDomainForwardersEditInfo::add:
|
|
default:
|
|
break;
|
|
}
|
|
int iIdx = pDomainList->FindStringExact(-1, dlg.m_szDomainName);
|
|
if (iIdx != LB_ERR)
|
|
{
|
|
pDomainList->SetCurSel(iIdx);
|
|
pDomainList->SetItemData(iIdx, (LPARAM)pSearchInfo);
|
|
|
|
OnDomainSelChange();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Attach some data to keep track of whats being added or changed
|
|
//
|
|
CDomainForwardersEditInfo* pNewEditInfo = new CDomainForwardersEditInfo(NULL, FALSE);
|
|
if (pNewEditInfo != NULL)
|
|
{
|
|
pNewEditInfo->SetDomainName(dlg.m_szDomainName);
|
|
m_EditList.AddTail(pNewEditInfo);
|
|
|
|
pDomainList->SetItemData(iIndex, (LPARAM)pNewEditInfo);
|
|
|
|
|
|
switch (pNewEditInfo->GetAction())
|
|
{
|
|
case CDomainForwardersEditInfo::nochange:
|
|
pNewEditInfo->SetAction(CDomainForwardersEditInfo::add);
|
|
break;
|
|
case CDomainForwardersEditInfo::update:
|
|
case CDomainForwardersEditInfo::remove:
|
|
case CDomainForwardersEditInfo::add:
|
|
default:
|
|
ASSERT(FALSE);
|
|
break;
|
|
}
|
|
|
|
pDomainList->SetCurSel(iIndex);
|
|
OnDomainSelChange();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
void CDNSServer_DomainForwardersPropertyPage::OnRemoveDomain()
|
|
{
|
|
CListBox* pDomainList = (CListBox*)GetDlgItem(IDC_DOMAIN_LIST);
|
|
if (pDomainList != NULL)
|
|
{
|
|
int iSel = pDomainList->GetCurSel();
|
|
if (iSel != LB_ERR)
|
|
{
|
|
CDomainForwardersEditInfo* pEditInfo = reinterpret_cast<CDomainForwardersEditInfo*>(pDomainList->GetItemData(iSel));
|
|
if (pEditInfo != NULL)
|
|
{
|
|
ASSERT(pEditInfo == m_pCurrentInfo);
|
|
|
|
switch (pEditInfo->GetAction())
|
|
{
|
|
case CDomainForwardersEditInfo::nochange:
|
|
case CDomainForwardersEditInfo::update:
|
|
case CDomainForwardersEditInfo::remove:
|
|
pEditInfo->SetAction(CDomainForwardersEditInfo::remove);
|
|
break;
|
|
case CDomainForwardersEditInfo::add:
|
|
m_EditList.Remove(pEditInfo);
|
|
delete pEditInfo;
|
|
break;
|
|
default:
|
|
ASSERT(FALSE);
|
|
break;
|
|
}
|
|
}
|
|
pDomainList->DeleteString(iSel);
|
|
m_pCurrentInfo = NULL;
|
|
|
|
//
|
|
// Set the selection to the previous entry
|
|
//
|
|
pDomainList->SetCurSel(iSel - 1);
|
|
OnDomainSelChange();
|
|
}
|
|
}
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
void CDNSServer_DomainForwardersPropertyPage::OnSlaveCheckChange()
|
|
{
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
void CDNSServer_DomainForwardersPropertyPage::OnForwarderTimeoutChange()
|
|
{
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
|
|
BOOL CDNSServer_DomainForwardersPropertyPage::OnInitDialog()
|
|
{
|
|
CPropertyPageBase::OnInitDialog();
|
|
|
|
CDNSServerPropertyPageHolder* pHolder =
|
|
(CDNSServerPropertyPageHolder*)GetHolder();
|
|
CDNSServerNode* pServerNode = pHolder->GetServerNode();
|
|
|
|
//
|
|
// initialize controls
|
|
//
|
|
VERIFY(m_forwarderAddressesEditor.Initialize(this,
|
|
GetParent(),
|
|
IDC_BUTTON_UP,
|
|
IDC_BUTTON_DOWN,
|
|
IDC_BUTTON_ADD,
|
|
IDC_BUTTON_REMOVE,
|
|
IDC_IPEDIT,
|
|
IDC_LIST));
|
|
|
|
VERIFY(m_forwardTimeoutEdit.SubclassDlgItem(IDC_FWD_TIMEOUT_EDIT, this));
|
|
m_forwardTimeoutEdit.SetRange(1,0xffff ); // DWORD
|
|
m_forwardTimeoutEdit.SetLimitText(5); // 0 to 65535
|
|
|
|
//
|
|
// Disable IME support on the controls
|
|
//
|
|
ImmAssociateContext(m_forwardTimeoutEdit.GetSafeHwnd(), NULL);
|
|
|
|
if (!pServerNode->HasServerInfo())
|
|
{
|
|
//
|
|
// clear the root hints message text
|
|
//
|
|
SetDlgItemText(IDC_STATIC_MESSAGE, NULL);
|
|
EnableWindow(FALSE);
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Don't show the AD Integrated text unless the forwarder is
|
|
// AD integrated (rare)
|
|
//
|
|
GetDlgItem(IDC_FORWARDER_ADINT_STATIC)->ShowWindow(FALSE);
|
|
|
|
SetDirty(FALSE);
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
BOOL CDNSServer_DomainForwardersPropertyPage::OnSetActive()
|
|
{
|
|
CDNSServerPropertyPageHolder* pHolder =
|
|
(CDNSServerPropertyPageHolder*)GetHolder();
|
|
CDNSServerNode* pServerNode = pHolder->GetServerNode();
|
|
|
|
BOOL bWasDirty = IsDirty();
|
|
|
|
BOOL bServerHasRoot = FALSE;
|
|
DNS_STATUS err = ServerHasRootZone(pServerNode->GetRPCName(), &bServerHasRoot);
|
|
if (err == ERROR_SUCCESS && (bServerHasRoot || !pServerNode->DoesRecursion()))
|
|
{
|
|
//
|
|
// the server is a root server or doesn't do recursion
|
|
//
|
|
EnableDialogControls(m_hWnd, FALSE);
|
|
|
|
CStatic* pStatic = (CStatic*)GetDlgItem(IDC_STATIC_ADD_FORWARDERS);
|
|
if (pStatic != NULL)
|
|
{
|
|
pStatic->ShowWindow(FALSE);
|
|
}
|
|
|
|
pStatic = (CStatic*)GetDlgItem(IDC_STATIC_MESSAGE);
|
|
if (pStatic != NULL)
|
|
{
|
|
if (bServerHasRoot)
|
|
{
|
|
pStatic->ShowWindow(TRUE);
|
|
}
|
|
else
|
|
{
|
|
pStatic->ShowWindow(FALSE);
|
|
}
|
|
}
|
|
|
|
if (!pServerNode->DoesRecursion())
|
|
{
|
|
CString szNoRecursionText;
|
|
VERIFY(szNoRecursionText.LoadString(IDS_DISABLED_FWDS_NO_RECURSION));
|
|
SetDlgItemText(IDC_STATIC_CAPTION, szNoRecursionText);
|
|
}
|
|
|
|
GetDlgItem(IDC_DOMAIN_LIST)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_LIST)->EnableWindow(FALSE);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// clear the root hints message text
|
|
//
|
|
SetDlgItemText(IDC_STATIC_MESSAGE, NULL);
|
|
|
|
if (!m_bPostApply)
|
|
{
|
|
//
|
|
// Clear the list box
|
|
//
|
|
SendDlgItemMessage(IDC_DOMAIN_LIST, LB_RESETCONTENT, 0, 0);
|
|
|
|
//
|
|
// Clear any stored values
|
|
//
|
|
m_EditList.DeleteAll();
|
|
m_pCurrentInfo = NULL;
|
|
}
|
|
|
|
//
|
|
// Enable all the controls
|
|
//
|
|
EnableWindow(TRUE);
|
|
EnableDialogControls(m_hWnd, TRUE);
|
|
|
|
//
|
|
// Get the domain forwarders info from hidden Category node
|
|
//
|
|
CDNSDomainForwardersNode* pDomainForwardersNode = pServerNode->GetDomainForwardersNode();
|
|
if (pDomainForwardersNode == NULL)
|
|
{
|
|
ASSERT(FALSE);
|
|
|
|
//
|
|
// Disable all controls
|
|
//
|
|
SetDlgItemText(IDC_STATIC_MESSAGE, NULL);
|
|
EnableWindow(FALSE);
|
|
EnableDialogControls(m_hWnd, FALSE);
|
|
|
|
CStatic* pStatic = (CStatic*)GetDlgItem(IDC_STATIC_ADD_FORWARDERS);
|
|
if (pStatic != NULL)
|
|
{
|
|
pStatic->ShowWindow(FALSE);
|
|
}
|
|
|
|
pStatic = (CStatic*)GetDlgItem(IDC_STATIC_MESSAGE);
|
|
if (pStatic != NULL)
|
|
{
|
|
if (bServerHasRoot)
|
|
{
|
|
pStatic->ShowWindow(TRUE);
|
|
}
|
|
else
|
|
{
|
|
pStatic->ShowWindow(FALSE);
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
if (!m_bPostApply)
|
|
{
|
|
CNodeList* pNodeList = pDomainForwardersNode->GetContainerChildList();
|
|
POSITION pos = pNodeList->GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
CDNSZoneNode* pZoneNode = dynamic_cast<CDNSZoneNode*>(pNodeList->GetNext(pos));
|
|
if (pZoneNode != NULL && pZoneNode->GetZoneType() == DNS_ZONE_TYPE_FORWARDER)
|
|
{
|
|
//
|
|
// Create a temporary list that will last through the duration of the page for all
|
|
// the forwarders
|
|
//
|
|
BOOL bADIntegrated = pZoneNode->IsDSIntegrated();
|
|
|
|
CDomainForwardersEditInfo* pForwardersInfo = new CDomainForwardersEditInfo(
|
|
pZoneNode,
|
|
bADIntegrated,
|
|
FALSE);
|
|
if (pForwardersInfo != NULL)
|
|
{
|
|
m_EditList.AddTail(pForwardersInfo);
|
|
|
|
//
|
|
// Add the forwarder to the UI
|
|
//
|
|
LRESULT lIndex = SendDlgItemMessage(IDC_DOMAIN_LIST, LB_ADDSTRING, 0, (LPARAM)pZoneNode->GetDisplayName());
|
|
if (lIndex != LB_ERR)
|
|
{
|
|
SendDlgItemMessage(IDC_DOMAIN_LIST, LB_SETITEMDATA, lIndex, (LPARAM)pForwardersInfo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// get data from server
|
|
//
|
|
DWORD cAddrCount;
|
|
PIP_ADDRESS pipAddrs;
|
|
DWORD dwForwardTimeout;
|
|
DWORD fSlave;
|
|
pServerNode->GetForwardersInfo(&cAddrCount, &pipAddrs, &dwForwardTimeout, &fSlave);
|
|
|
|
//
|
|
// Create an edit list for the "All other domains" item
|
|
//
|
|
CAllOthersDomainInfo* pAllOthers = new CAllOthersDomainInfo(cAddrCount,
|
|
pipAddrs,
|
|
dwForwardTimeout,
|
|
fSlave);
|
|
if (pAllOthers != NULL)
|
|
{
|
|
CDomainForwardersEditInfo* pForwardersInfo = new CDomainForwardersEditInfo(NULL, FALSE);
|
|
if (pForwardersInfo != NULL)
|
|
{
|
|
pForwardersInfo->SetAllOthersDomain(pAllOthers);
|
|
pForwardersInfo->SetDataFromRPC(TRUE);
|
|
m_EditList.AddTail(pForwardersInfo);
|
|
|
|
//
|
|
// Load the "All other domains" string and add it at the beginning
|
|
//
|
|
CString szAllOthers;
|
|
VERIFY(szAllOthers.LoadString(IDS_OTHER_DOMAINS));
|
|
|
|
LRESULT lRes = 0;
|
|
lRes = SendDlgItemMessage(IDC_DOMAIN_LIST, LB_INSERTSTRING, 0, (LPARAM)(LPCWSTR)szAllOthers);
|
|
if (lRes != LB_ERR)
|
|
{
|
|
SendDlgItemMessage(IDC_DOMAIN_LIST, LB_SETITEMDATA, lRes, (LPARAM)pForwardersInfo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
CStatic* pStatic = (CStatic*)GetDlgItem(IDC_STATIC_MESSAGE);
|
|
if (pStatic != NULL)
|
|
{
|
|
pStatic->EnableWindow(FALSE);
|
|
pStatic->ShowWindow(FALSE);
|
|
}
|
|
|
|
pStatic = (CStatic*)GetDlgItem(IDC_STATIC_ADD_FORWARDERS);
|
|
if (pStatic != NULL)
|
|
{
|
|
pStatic->EnableWindow(TRUE);
|
|
pStatic->ShowWindow(TRUE);
|
|
}
|
|
|
|
if (!m_bPostApply)
|
|
{
|
|
//
|
|
// Select the first item in the domain list
|
|
//
|
|
SendDlgItemMessage(IDC_DOMAIN_LIST, LB_SETCURSEL, 0, 0);
|
|
OnDomainSelChange();
|
|
}
|
|
}
|
|
|
|
if (pServerNode->GetBuildNumber() < DNS_SRV_BUILD_NUMBER_WHISTLER ||
|
|
(pServerNode->GetMajorVersion() <= DNS_SRV_MAJOR_VERSION_NT_5 &&
|
|
pServerNode->GetMinorVersion() < DNS_SRV_MINOR_VERSION_WHISTLER))
|
|
{
|
|
//
|
|
// Domain forwarding not available on pre-Whistler servers
|
|
//
|
|
if (!bServerHasRoot && pServerNode->DoesRecursion())
|
|
{
|
|
CString szDownlevelServer;
|
|
VERIFY(szDownlevelServer.LoadString(IDS_DISABLED_FWDS_DOWNLEVEL));
|
|
SetDlgItemText(IDC_STATIC_CAPTION, szDownlevelServer);
|
|
}
|
|
|
|
GetDlgItem(IDC_DOMAIN_ADD_BUTTON)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_DOMAIN_REMOVE_BUTTON)->EnableWindow(FALSE);
|
|
}
|
|
|
|
SetDirty(bWasDirty);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CDNSServer_DomainForwardersPropertyPage::OnApply()
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
CDNSServerPropertyPageHolder* pHolder =
|
|
(CDNSServerPropertyPageHolder*)GetHolder();
|
|
CComponentDataObject* pComponentData = pHolder->GetComponentData();
|
|
CDNSServerNode* pServerNode = pHolder->GetServerNode();
|
|
|
|
if (!IsDirty())
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Retrieve the current UI info
|
|
//
|
|
CListBox* pDomainList = (CListBox*)GetDlgItem(IDC_DOMAIN_LIST);
|
|
if (pDomainList != NULL)
|
|
{
|
|
int iSel = pDomainList->GetCurSel();
|
|
if (iSel != LB_ERR)
|
|
{
|
|
LRESULT lRes = pDomainList->GetItemData(iSel);
|
|
if (lRes != LB_ERR)
|
|
{
|
|
//
|
|
// Retrieve the edit info from the list box item
|
|
//
|
|
CDomainForwardersEditInfo* pInfo = reinterpret_cast<CDomainForwardersEditInfo*>(lRes);
|
|
if (pInfo != NULL)
|
|
{
|
|
//
|
|
// Store the previous selection's data before changing the UI.
|
|
// This may be NULL during OnInitDialog so check before trying
|
|
// to store the info.
|
|
//
|
|
if (m_pCurrentInfo != NULL)
|
|
{
|
|
BOOL bSlave = GetSlaveCheck()->GetCheck();
|
|
DWORD dwTimeout = m_forwardTimeoutEdit.GetVal();
|
|
|
|
DWORD cAddrCount = m_forwarderAddressesEditor.GetCount();
|
|
DWORD* pArr = (cAddrCount > 0) ? (DWORD*) malloc(sizeof(DWORD)*cAddrCount) : NULL;
|
|
if (cAddrCount > 0 && pArr != NULL)
|
|
{
|
|
int nFilled = 0;
|
|
m_forwarderAddressesEditor.GetAddresses(pArr, cAddrCount, &nFilled);
|
|
ASSERT(nFilled == (int)cAddrCount);
|
|
}
|
|
m_pCurrentInfo->Update(bSlave, dwTimeout, cAddrCount, pArr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
POSITION pos = m_EditList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
CDomainForwardersEditInfo* pInfo = m_EditList.GetNext(pos);
|
|
if (pInfo != NULL)
|
|
{
|
|
DNS_STATUS err = 0;
|
|
|
|
CString szName;
|
|
pInfo->GetDomainName(szName);
|
|
DWORD cAddrCount = 0;
|
|
PIP_ADDRESS pipAddrs = pInfo->GetIPList(&cAddrCount);
|
|
DWORD dwTimeout = pInfo->GetTimeout();
|
|
BOOL bSlave = pInfo->IsSlave();
|
|
|
|
switch (pInfo->GetAction())
|
|
{
|
|
case CDomainForwardersEditInfo::add:
|
|
{
|
|
//
|
|
// Add the new domain forwarder as a zone
|
|
//
|
|
ASSERT(!pInfo->IsAllOthers());
|
|
if (!pInfo->IsAllOthers())
|
|
{
|
|
// Every domain that is entered must contain at least
|
|
// one IP address of a server to forward to
|
|
|
|
if (cAddrCount < 1)
|
|
{
|
|
CString err;
|
|
err.Format(IDS_ERRMSG_SERVER_FORWARDER_NO_SERVER, szName);
|
|
|
|
DNSMessageBox(err, MB_OK);
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
err = pServerNode->CreateForwarderZone(szName,
|
|
pipAddrs,
|
|
cAddrCount,
|
|
dwTimeout,
|
|
bSlave,
|
|
pComponentData);
|
|
}
|
|
|
|
}
|
|
}
|
|
break;
|
|
case CDomainForwardersEditInfo::remove:
|
|
{
|
|
//
|
|
// Delete the zone representing the domain forwarder
|
|
//
|
|
ASSERT(!pInfo->IsAllOthers());
|
|
if (!pInfo->IsAllOthers())
|
|
{
|
|
BOOL bDeleteFromDS = FALSE;
|
|
if (pInfo->GetZoneNode()->GetZoneType() == DNS_ZONE_TYPE_FORWARDER &&
|
|
pInfo->IsADIntegrated())
|
|
{
|
|
if (pServerNode->GetBootMethod() == BOOT_METHOD_DIRECTORY)
|
|
{
|
|
// ask confirmation on delete from DS
|
|
int nRetVal = DNSMessageBox(IDS_MSG_FORWARDER_DELETE_FROM_DS_BOOT3,
|
|
MB_YESNO | MB_DEFBUTTON2);
|
|
if (nRetVal == IDNO)
|
|
{
|
|
break;
|
|
}
|
|
|
|
bDeleteFromDS = TRUE;
|
|
}
|
|
else
|
|
{
|
|
// ask confirmation on delete from DS
|
|
int nRetVal = DNSMessageBox(IDS_MSG_FORWARDER_DELETE_FROM_DS,
|
|
MB_YESNOCANCEL | MB_DEFBUTTON3);
|
|
if (nRetVal == IDCANCEL)
|
|
{
|
|
break;
|
|
}
|
|
|
|
bDeleteFromDS = (nRetVal == IDYES);
|
|
}
|
|
}
|
|
|
|
err = pInfo->GetZoneNode()->Delete(bDeleteFromDS);
|
|
|
|
}
|
|
}
|
|
break;
|
|
case CDomainForwardersEditInfo::update:
|
|
{
|
|
//
|
|
// Update the zone representing the domain forwarder
|
|
//
|
|
if (pInfo->IsAllOthers())
|
|
{
|
|
//
|
|
// write the default forwarder to the server
|
|
//
|
|
err = pServerNode->ResetForwarders(cAddrCount, pipAddrs, dwTimeout, bSlave);
|
|
}
|
|
else
|
|
{
|
|
err = ::DnssrvResetZoneMastersEx(pServerNode->GetRPCName(), // server name
|
|
W_TO_UTF8(szName), // forwarder as zone name
|
|
cAddrCount,
|
|
pipAddrs,
|
|
0); // global masters only
|
|
|
|
}
|
|
}
|
|
break;
|
|
case CDomainForwardersEditInfo::nochange:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (err != 0)
|
|
{
|
|
if (err == DNS_ERROR_INVALID_ZONE_TYPE)
|
|
{
|
|
CString szFwdFailed;
|
|
CString szFwdFailedFormat;
|
|
VERIFY(szFwdFailedFormat.LoadString(IDS_MSG_FAIL_CREATE_DOMAIN_FORWARDER));
|
|
szFwdFailed.Format(szFwdFailedFormat, szName);
|
|
DNSMessageBox(szFwdFailed);
|
|
}
|
|
else
|
|
{
|
|
DNSErrorDialog(err, IDS_MSG_SERVER_FORWARDER_UPDATE_FAILED);
|
|
}
|
|
return FALSE;
|
|
}
|
|
pInfo->SetAction(CDomainForwardersEditInfo::nochange);
|
|
}
|
|
} // while
|
|
|
|
m_bPostApply = TRUE;
|
|
SetDirty(FALSE);
|
|
return TRUE;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// CDNSServer_AdvancedPropertyPage
|
|
|
|
BEGIN_MESSAGE_MAP(CDNSServer_AdvancedPropertyPage, CPropertyPageBase)
|
|
ON_CLBN_CHKCHANGE(IDC_ADVANCED_OPTIONS_LIST, OnAdvancedOptionsListChange)
|
|
ON_CBN_SELCHANGE(IDC_NAME_CHECKING_COMBO, OnComboSelChange)
|
|
ON_CBN_SELCHANGE(IDC_BOOT_METHOD_COMBO, OnComboSelChange)
|
|
ON_BN_CLICKED(IDC_RESET_BUTTON, OnResetButton)
|
|
ON_BN_CLICKED(IDC_CHECK_ENABLE_SCAVENGING, OnEnableScavenging)
|
|
END_MESSAGE_MAP()
|
|
|
|
#define ADVANCED_OPTIONS_LISTBOX_ENTRIES (SERVER_REGKEY_ARR_SIZE)
|
|
|
|
// boot method constants
|
|
#define BOOT_METHOD_COMBO_ITEM_COUNT 3 // # of options in the combo box
|
|
|
|
#define BOOT_METHOD_COMBO_FROM_REGISTRY 0
|
|
#define BOOT_METHOD_COMBO_FROM_FILE 1
|
|
#define BOOT_METHOD_COMBO_FROM_DIRECTORY 2
|
|
|
|
|
|
|
|
#define CHECK_NAMES_COMBO_ITEM_COUNT 4
|
|
|
|
CDNSServer_AdvancedPropertyPage::CDNSServer_AdvancedPropertyPage()
|
|
: CPropertyPageBase(IDD_SERVER_ADVANCED_PAGE),
|
|
m_advancedOptionsListBox(ADVANCED_OPTIONS_LISTBOX_ENTRIES)
|
|
{
|
|
}
|
|
|
|
|
|
void CDNSServer_AdvancedPropertyPage::SetAdvancedOptionsListbox(BOOL* bRegKeyOptionsArr)
|
|
{
|
|
m_advancedOptionsListBox.SetArrValue((DWORD*)bRegKeyOptionsArr,
|
|
ADVANCED_OPTIONS_LISTBOX_ENTRIES);
|
|
}
|
|
|
|
void CDNSServer_AdvancedPropertyPage::GetAdvancedOptionsListbox(BOOL* bRegKeyOptionsArr)
|
|
{
|
|
m_advancedOptionsListBox.GetArrValue((DWORD*)bRegKeyOptionsArr,
|
|
ADVANCED_OPTIONS_LISTBOX_ENTRIES);
|
|
}
|
|
|
|
void CDNSServer_AdvancedPropertyPage::SetBootMethodComboVal(UCHAR fBootMethod)
|
|
{
|
|
int nIndex = BOOT_METHOD_COMBO_FROM_DIRECTORY; // sensible default
|
|
switch (fBootMethod)
|
|
{
|
|
case BOOT_METHOD_FILE:
|
|
nIndex = BOOT_METHOD_COMBO_FROM_FILE;
|
|
break;
|
|
case BOOT_METHOD_REGISTRY:
|
|
nIndex = BOOT_METHOD_COMBO_FROM_REGISTRY;
|
|
break;
|
|
case BOOT_METHOD_DIRECTORY:
|
|
nIndex = BOOT_METHOD_COMBO_FROM_DIRECTORY;
|
|
break;
|
|
default:
|
|
nIndex = BOOT_METHOD_COMBO_FROM_DIRECTORY;
|
|
break;
|
|
};
|
|
VERIFY(CB_ERR != GetBootMethodCombo()->SetCurSel(nIndex));
|
|
}
|
|
|
|
UCHAR CDNSServer_AdvancedPropertyPage::GetBootMethodComboVal()
|
|
{
|
|
int nIndex = BOOT_METHOD_COMBO_FROM_DIRECTORY;
|
|
nIndex = GetBootMethodCombo()->GetCurSel();
|
|
ASSERT(nIndex != CB_ERR);
|
|
|
|
UCHAR fBootMethod = BOOT_METHOD_DIRECTORY; // sensible default
|
|
switch (nIndex)
|
|
{
|
|
case BOOT_METHOD_COMBO_FROM_FILE:
|
|
fBootMethod = BOOT_METHOD_FILE;
|
|
break;
|
|
case BOOT_METHOD_COMBO_FROM_REGISTRY:
|
|
fBootMethod = BOOT_METHOD_REGISTRY;
|
|
break;
|
|
case BOOT_METHOD_COMBO_FROM_DIRECTORY:
|
|
fBootMethod = BOOT_METHOD_DIRECTORY;
|
|
break;
|
|
default:
|
|
ASSERT(FALSE);
|
|
};
|
|
|
|
return fBootMethod;
|
|
}
|
|
|
|
void CDNSServer_AdvancedPropertyPage::SetNameCheckingComboVal(DWORD dwNameChecking)
|
|
{
|
|
int nIndex = DNS_DEFAULT_NAME_CHECK_FLAG;
|
|
switch (dwNameChecking)
|
|
{
|
|
case DNS_ALLOW_RFC_NAMES_ONLY:
|
|
nIndex = 0;
|
|
break;
|
|
case DNS_ALLOW_NONRFC_NAMES:
|
|
nIndex = 1;
|
|
break;
|
|
case DNS_ALLOW_MULTIBYTE_NAMES:
|
|
nIndex = 2;
|
|
break;
|
|
case DNS_ALLOW_ALL_NAMES:
|
|
nIndex = 3;
|
|
break;
|
|
default:
|
|
ASSERT(FALSE);
|
|
}
|
|
VERIFY(CB_ERR != GetNameCheckingCombo()->SetCurSel(nIndex));
|
|
}
|
|
|
|
DWORD CDNSServer_AdvancedPropertyPage::GetNameCheckingComboVal()
|
|
{
|
|
int nIndex = 0;
|
|
nIndex = GetNameCheckingCombo()->GetCurSel();
|
|
ASSERT(nIndex != CB_ERR);
|
|
DWORD dw = 0;
|
|
switch (nIndex)
|
|
{
|
|
case 0:
|
|
dw = DNS_ALLOW_RFC_NAMES_ONLY;
|
|
break;
|
|
case 1:
|
|
dw = DNS_ALLOW_NONRFC_NAMES;
|
|
break;
|
|
case 2:
|
|
dw = DNS_ALLOW_MULTIBYTE_NAMES;
|
|
break;
|
|
case 3:
|
|
dw = DNS_ALLOW_ALL_NAMES;
|
|
break;
|
|
default:
|
|
ASSERT(FALSE);
|
|
}
|
|
return dw;
|
|
}
|
|
|
|
void CDNSServer_AdvancedPropertyPage::OnEnableScavenging()
|
|
{
|
|
GetDlgItem(IDC_STATIC_SCAVENGE)->EnableWindow(((CButton*)GetDlgItem(IDC_CHECK_ENABLE_SCAVENGING))->GetCheck());
|
|
GetDlgItem(IDC_REFR_INT_EDIT)->EnableWindow(((CButton*)GetDlgItem(IDC_CHECK_ENABLE_SCAVENGING))->GetCheck());
|
|
GetDlgItem(IDC_REFR_INT_COMBO)->EnableWindow(((CButton*)GetDlgItem(IDC_CHECK_ENABLE_SCAVENGING))->GetCheck());
|
|
if (m_scavengingIntervalEditGroup.GetVal() == 0)
|
|
{
|
|
m_scavengingIntervalEditGroup.SetVal(DNS_DEFAULT_SCAVENGING_INTERVAL_ON);
|
|
}
|
|
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
void CDNSServer_AdvancedPropertyPage::SetUIData()
|
|
{
|
|
CDNSServerPropertyPageHolder* pHolder =
|
|
(CDNSServerPropertyPageHolder*)GetHolder();
|
|
CDNSServerNode* pServerNode = pHolder->GetServerNode();
|
|
|
|
// set server version
|
|
CEdit* pVersionEdit = (CEdit*)GetDlgItem(IDC_SERVER_VERSION_EDIT);
|
|
WCHAR szBuffer[128];
|
|
WORD wBuildNumber = pServerNode->GetBuildNumber();
|
|
if (wBuildNumber == 0)
|
|
wsprintf(szBuffer, _T("%d.%d"), pServerNode->GetMajorVersion(),
|
|
pServerNode->GetMinorVersion());
|
|
else
|
|
wsprintf(szBuffer, _T("%d.%d %d (0x%x)"), pServerNode->GetMajorVersion(),
|
|
pServerNode->GetMinorVersion(),
|
|
wBuildNumber, wBuildNumber);
|
|
pVersionEdit->SetWindowText(szBuffer);
|
|
|
|
// NOTICE: Assume ordering in the list is the same
|
|
// as in the array. "Name check Flag" and "Boot method" are the last ones
|
|
// in the array and are ignored (separate controls).
|
|
BOOL bRegKeyOptionsArr[SERVER_REGKEY_ARR_SIZE];
|
|
|
|
pServerNode->GetAdvancedOptions(bRegKeyOptionsArr);
|
|
SetAdvancedOptionsListbox(bRegKeyOptionsArr);
|
|
|
|
SetBootMethodComboVal(pServerNode->GetBootMethod());
|
|
SetNameCheckingComboVal(pServerNode->GetNameCheckFlag());
|
|
((CButton*)GetDlgItem(IDC_CHECK_ENABLE_SCAVENGING))->SetCheck(pServerNode->GetScavengingState());
|
|
GetDlgItem(IDC_STATIC_SCAVENGE)->EnableWindow(pServerNode->GetScavengingState());
|
|
GetDlgItem(IDC_REFR_INT_EDIT)->EnableWindow(pServerNode->GetScavengingState());
|
|
GetDlgItem(IDC_REFR_INT_COMBO)->EnableWindow(pServerNode->GetScavengingState());
|
|
m_scavengingIntervalEditGroup.SetVal(pServerNode->GetScavengingInterval());
|
|
}
|
|
|
|
|
|
BOOL CDNSServer_AdvancedPropertyPage::OnInitDialog()
|
|
{
|
|
CPropertyPageBase::OnInitDialog();
|
|
CDNSServerPropertyPageHolder* pHolder =
|
|
(CDNSServerPropertyPageHolder*)GetHolder();
|
|
CDNSServerNode* pServerNode = pHolder->GetServerNode();
|
|
|
|
VERIFY(m_advancedOptionsListBox.Initialize(IDC_ADVANCED_OPTIONS_LIST,
|
|
IDS_SERVER_ADV_PP_OPTIONS,
|
|
this));
|
|
VERIFY(LoadStringsToComboBox(_Module.GetModuleInstance(),
|
|
GetNameCheckingCombo(),
|
|
IDS_SERVER_NAME_CHECKING_OPTIONS,
|
|
256,
|
|
CHECK_NAMES_COMBO_ITEM_COUNT));
|
|
|
|
VERIFY(LoadStringsToComboBox(_Module.GetModuleInstance(),
|
|
GetBootMethodCombo(),
|
|
IDS_SERVER_BOOT_METHOD_OPTIONS,
|
|
256,
|
|
BOOT_METHOD_COMBO_ITEM_COUNT));
|
|
if (!pServerNode->HasServerInfo())
|
|
{
|
|
EnableWindow(FALSE);
|
|
return TRUE;
|
|
}
|
|
|
|
m_scavengingIntervalEditGroup.m_pPage2 = this;
|
|
|
|
VERIFY(m_scavengingIntervalEditGroup.Initialize(this,
|
|
IDC_REFR_INT_EDIT, IDC_REFR_INT_COMBO,IDS_TIME_AGING_INTERVAL_UNITS));
|
|
|
|
SetUIData();
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
|
|
BOOL _HandleAvancedOptionsErrors(DNS_STATUS* dwRegKeyOptionsErrorArr)
|
|
{
|
|
BOOL bAllFine = TRUE;
|
|
|
|
// check for errors in the array
|
|
for (UINT iKey=0; iKey < SERVER_REGKEY_ARR_SIZE; iKey++)
|
|
{
|
|
if (dwRegKeyOptionsErrorArr[iKey] != 0)
|
|
{
|
|
bAllFine = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
if (bAllFine)
|
|
return TRUE; // no error condition
|
|
|
|
// load the string array to get the option key name
|
|
CString szBuf;
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
VERIFY(szBuf.LoadString(IDS_SERVER_ADV_PP_OPTIONS));
|
|
LPWSTR* lpszArr = (LPWSTR*)malloc(sizeof(LPWSTR*)*SERVER_REGKEY_ARR_SIZE);
|
|
if (!lpszArr)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
UINT nArrEntries;
|
|
ParseNewLineSeparatedString(szBuf.GetBuffer(1),lpszArr, &nArrEntries);
|
|
szBuf.ReleaseBuffer();
|
|
ASSERT(nArrEntries == SERVER_REGKEY_ARR_SIZE);
|
|
|
|
CString szFmt;
|
|
szFmt.LoadString(IDS_MSG_SERVER_FAIL_ADV_PROP_FMT);
|
|
CString szMsg;
|
|
for (iKey=0; iKey < SERVER_REGKEY_ARR_SIZE; iKey++)
|
|
{
|
|
if (dwRegKeyOptionsErrorArr[iKey] != 0)
|
|
{
|
|
szMsg.Format((LPCWSTR)szFmt, lpszArr[iKey]);
|
|
DNSErrorDialog(dwRegKeyOptionsErrorArr[iKey], szMsg);
|
|
}
|
|
}
|
|
|
|
if (lpszArr)
|
|
{
|
|
free(lpszArr);
|
|
lpszArr = 0;
|
|
}
|
|
return FALSE; // we had an error condition
|
|
}
|
|
|
|
BOOL CDNSServer_AdvancedPropertyPage::OnApply()
|
|
{
|
|
if (!IsDirty())
|
|
return TRUE;
|
|
|
|
CDNSServerPropertyPageHolder* pHolder =
|
|
(CDNSServerPropertyPageHolder*)GetHolder();
|
|
CDNSServerNode* pServerNode = pHolder->GetServerNode();
|
|
|
|
// get data from the UI
|
|
BOOL bRegKeyOptionsArr[SERVER_REGKEY_ARR_SIZE];
|
|
ZeroMemory(bRegKeyOptionsArr, sizeof(bRegKeyOptionsArr));
|
|
|
|
GetAdvancedOptionsListbox(bRegKeyOptionsArr);
|
|
UCHAR fBootMethod = GetBootMethodComboVal();
|
|
DWORD dwNameCheckFlag = GetNameCheckingComboVal();
|
|
BOOL bScavengingState = ((CButton*)GetDlgItem(IDC_CHECK_ENABLE_SCAVENGING))->GetCheck();
|
|
DWORD dwScavengingInterval = m_scavengingIntervalEditGroup.GetVal();
|
|
|
|
// write data to the server
|
|
DNS_STATUS dwRegKeyOptionsErrorArr[SERVER_REGKEY_ARR_SIZE];
|
|
ZeroMemory(dwRegKeyOptionsErrorArr, sizeof(dwRegKeyOptionsErrorArr));
|
|
|
|
DNS_STATUS dwErr = pServerNode->ResetAdvancedOptions(bRegKeyOptionsArr, dwRegKeyOptionsErrorArr);
|
|
if (dwErr != 0)
|
|
{
|
|
DNSErrorDialog(dwErr, IDS_MSG_SERVER_NO_ADVANCED_OPTIONS);
|
|
return FALSE;
|
|
}
|
|
if (!_HandleAvancedOptionsErrors(dwRegKeyOptionsErrorArr))
|
|
return FALSE;
|
|
|
|
dwErr = pServerNode->ResetBootMethod(fBootMethod);
|
|
if (dwErr != 0)
|
|
{
|
|
DNSErrorDialog(dwErr, IDS_MSG_SERVER_NO_BOOT_METHOD);
|
|
return FALSE;
|
|
}
|
|
|
|
dwErr = pServerNode->ResetNameCheckFlag(dwNameCheckFlag);
|
|
if (dwErr != 0)
|
|
{
|
|
DNSErrorDialog(dwErr, IDS_MSG_SERVER_NO_NAME_CHECKING);
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
dwErr = pServerNode->ResetScavengingState(bScavengingState);
|
|
if (dwErr != 0)
|
|
{
|
|
DNSErrorDialog(dwErr, IDS_MSG_SERVER_SCAVENGING_STATE);
|
|
return FALSE;
|
|
}
|
|
*/
|
|
if (bScavengingState)
|
|
{
|
|
dwErr = pServerNode->ResetScavengingInterval(dwScavengingInterval);
|
|
}
|
|
else
|
|
{
|
|
dwErr = pServerNode->ResetScavengingInterval(0);
|
|
}
|
|
|
|
if (dwErr != 0)
|
|
{
|
|
DNSErrorDialog(dwErr, IDS_MSG_SERVER_SCAVENGING_INTERVAL);
|
|
return FALSE;
|
|
}
|
|
|
|
// all is fine
|
|
SetDirty(FALSE);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void CDNSServer_AdvancedPropertyPage::OnResetButton()
|
|
{
|
|
BOOL bRegKeyOptArrDef[SERVER_REGKEY_ARR_SIZE];
|
|
|
|
bRegKeyOptArrDef[SERVER_REGKEY_ARR_INDEX_NO_RECURSION] = DNS_DEFAULT_NO_RECURSION;
|
|
bRegKeyOptArrDef[SERVER_REGKEY_ARR_INDEX_BIND_SECONDARIES] = DNS_DEFAULT_BIND_SECONDARIES;
|
|
bRegKeyOptArrDef[SERVER_REGKEY_ARR_INDEX_STRICT_FILE_PARSING] = DNS_DEFAULT_STRICT_FILE_PARSING;
|
|
bRegKeyOptArrDef[SERVER_REGKEY_ARR_INDEX_ROUND_ROBIN] = DNS_DEFAULT_ROUND_ROBIN;
|
|
bRegKeyOptArrDef[SERVER_REGKEY_ARR_LOCAL_NET_PRIORITY] = DNS_DEFAULT_LOCAL_NET_PRIORITY;
|
|
bRegKeyOptArrDef[SERVER_REGKEY_ARR_CACHE_POLLUTION] = FALSE;
|
|
|
|
UCHAR fBootMethod = BOOT_METHOD_DIRECTORY;
|
|
|
|
SetAdvancedOptionsListbox(bRegKeyOptArrDef);
|
|
SetBootMethodComboVal(fBootMethod);
|
|
SetNameCheckingComboVal(DNS_DEFAULT_NAME_CHECK_FLAG);
|
|
|
|
BOOL bDefaultScavengingState = DNS_DEFAULT_SCAVENGING_INTERVAL > 0;
|
|
((CButton*)GetDlgItem(IDC_CHECK_ENABLE_SCAVENGING))->SetCheck(bDefaultScavengingState);
|
|
GetDlgItem(IDC_STATIC_SCAVENGE)->EnableWindow(bDefaultScavengingState);
|
|
GetDlgItem(IDC_REFR_INT_EDIT)->EnableWindow(bDefaultScavengingState);
|
|
GetDlgItem(IDC_REFR_INT_COMBO)->EnableWindow(bDefaultScavengingState);
|
|
m_scavengingIntervalEditGroup.SetVal(DNS_DEFAULT_SCAVENGING_INTERVAL);
|
|
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// CIPFilterDialog
|
|
|
|
class CIPFilterDialog : public CHelpDialog
|
|
{
|
|
public:
|
|
CIPFilterDialog(PIP_ARRAY pIpArray, CComponentDataObject* pComponentData)
|
|
: CHelpDialog(IDD_IP_FILTER_DIALOG, pComponentData),
|
|
m_pIPFilterList(pIpArray),
|
|
m_pComponentData(pComponentData)
|
|
{}
|
|
|
|
~CIPFilterDialog() {}
|
|
|
|
virtual BOOL OnInitDialog();
|
|
virtual void OnOK();
|
|
|
|
PIP_ARRAY GetIPFilter() { return m_pIPFilterList; }
|
|
virtual void SetDirty(BOOL bDirty = TRUE);
|
|
|
|
private:
|
|
|
|
class CFilterAddressesIPEditor : public CIPEditor
|
|
{
|
|
public:
|
|
CFilterAddressesIPEditor() : CIPEditor(TRUE) {}
|
|
virtual void OnChangeData();
|
|
};
|
|
CFilterAddressesIPEditor m_filterAddressesEditor;
|
|
PIP_ARRAY m_pIPFilterList;
|
|
CComponentDataObject* m_pComponentData;
|
|
DECLARE_MESSAGE_MAP()
|
|
};
|
|
|
|
void CIPFilterDialog::CFilterAddressesIPEditor::OnChangeData()
|
|
{
|
|
//
|
|
// Set the dialog dirty
|
|
//
|
|
CIPFilterDialog* pDialog = (CIPFilterDialog*)GetParentWnd();
|
|
pDialog->SetDirty(TRUE);
|
|
}
|
|
|
|
BEGIN_MESSAGE_MAP(CIPFilterDialog, CHelpDialog)
|
|
END_MESSAGE_MAP()
|
|
|
|
BOOL CIPFilterDialog::OnInitDialog()
|
|
{
|
|
CHelpDialog::OnInitDialog();
|
|
|
|
//
|
|
// initialize controls
|
|
//
|
|
VERIFY(m_filterAddressesEditor.Initialize(this,
|
|
this,
|
|
IDC_BUTTON_UP,
|
|
IDC_BUTTON_DOWN,
|
|
IDC_BUTTON_ADD,
|
|
IDC_BUTTON_REMOVE,
|
|
IDC_IPEDIT,
|
|
IDC_LIST));
|
|
|
|
if (m_pIPFilterList != NULL)
|
|
{
|
|
m_filterAddressesEditor.AddAddresses(m_pIPFilterList->AddrArray, m_pIPFilterList->AddrCount);
|
|
}
|
|
|
|
SetDirty(FALSE);
|
|
return TRUE;
|
|
}
|
|
|
|
void CIPFilterDialog::SetDirty(BOOL bDirty)
|
|
{
|
|
GetDlgItem(IDOK)->EnableWindow(bDirty);
|
|
}
|
|
|
|
void CIPFilterDialog::OnOK()
|
|
{
|
|
ULONG cAddress = m_filterAddressesEditor.GetCount();
|
|
PIP_ARRAY aipAddresses = (cAddress > 0) ? (PIP_ARRAY) malloc(sizeof(DWORD)*(cAddress + 1)) : NULL;
|
|
if (aipAddresses != NULL && cAddress > 0)
|
|
{
|
|
int nFilled = 0;
|
|
aipAddresses->AddrCount = cAddress;
|
|
m_filterAddressesEditor.GetAddresses(aipAddresses->AddrArray, cAddress, &nFilled);
|
|
ASSERT(nFilled == (int)cAddress);
|
|
}
|
|
m_pIPFilterList = aipAddresses;
|
|
CHelpDialog::OnOK();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// CDNSServer_DebugLoggingPropertyPage
|
|
|
|
BEGIN_MESSAGE_MAP(CDNSServer_DebugLoggingPropertyPage, CPropertyPageBase)
|
|
ON_BN_CLICKED(IDC_DEBUG_LOGGING_CHECK, OnLoggingCheck)
|
|
ON_BN_CLICKED(IDC_SEND_CHECK, OnSendCheck)
|
|
ON_BN_CLICKED(IDC_RECEIVE_CHECK, OnReceiveCheck)
|
|
ON_BN_CLICKED(IDC_QUERIES_CHECK, OnQueriesCheck)
|
|
ON_BN_CLICKED(IDC_NOTIFIES_CHECK, OnNotifiesCheck)
|
|
ON_BN_CLICKED(IDC_UPDATES_CHECK, OnUpdatesCheck)
|
|
ON_BN_CLICKED(IDC_REQUEST_CHECK, OnRequestCheck)
|
|
ON_BN_CLICKED(IDC_RESPONSE_CHECK, OnResponseCheck)
|
|
ON_BN_CLICKED(IDC_UDP_CHECK, OnUDPCheck)
|
|
ON_BN_CLICKED(IDC_TCP_CHECK, OnTCPCheck)
|
|
ON_BN_CLICKED(IDC_DETAIL_CHECK, OnDetailCheck)
|
|
ON_BN_CLICKED(IDC_FILTERING_CHECK, OnFilterCheck)
|
|
ON_BN_CLICKED(IDC_FILTER_BUTTON, OnFilterButton)
|
|
ON_EN_CHANGE(IDC_LOGFILE_EDIT, OnLogFileChange)
|
|
ON_EN_CHANGE(IDC_MAX_SIZE_EDIT, OnMaxSizeChange)
|
|
END_MESSAGE_MAP()
|
|
|
|
CDNSServer_DebugLoggingPropertyPage::CDNSServer_DebugLoggingPropertyPage()
|
|
: CPropertyPageBase(IDD_SERVER_DEBUG_LOGGING_PAGE),
|
|
m_dwLogLevel(0),
|
|
m_pIPFilterList(NULL),
|
|
m_dwMaxSize(0),
|
|
m_bOnSetUIData(FALSE),
|
|
m_bMaxSizeDirty(FALSE),
|
|
m_bLogFileDirty(FALSE),
|
|
m_bFilterDirty(FALSE),
|
|
m_bOwnIPListMemory(FALSE),
|
|
m_bNotWhistler(FALSE),
|
|
m_bOptionsDirty(FALSE)
|
|
{
|
|
m_szLogFileName = L"";
|
|
}
|
|
|
|
CDNSServer_DebugLoggingPropertyPage::~CDNSServer_DebugLoggingPropertyPage()
|
|
{
|
|
if (m_bOwnIPListMemory && m_pIPFilterList != NULL)
|
|
{
|
|
free(m_pIPFilterList);
|
|
m_pIPFilterList = NULL;
|
|
}
|
|
}
|
|
|
|
typedef struct _LoggingOption
|
|
{
|
|
DWORD dwOption;
|
|
UINT nControlID;
|
|
} LOGGING_OPTION, *PLOGGING_OPTION;
|
|
|
|
|
|
//
|
|
// NOTE: if the resource IDs of the checkboxes are changed,
|
|
// then the IDs in the table below need to be changed too.
|
|
//
|
|
LOGGING_OPTION g_loggingOptions[] =
|
|
{
|
|
{ DNS_LOG_LEVEL_QUERY, IDC_QUERIES_CHECK },
|
|
{ DNS_LOG_LEVEL_NOTIFY, IDC_NOTIFIES_CHECK },
|
|
{ DNS_LOG_LEVEL_UPDATE, IDC_UPDATES_CHECK },
|
|
{ DNS_LOG_LEVEL_QUESTIONS, IDC_REQUEST_CHECK },
|
|
{ DNS_LOG_LEVEL_ANSWERS, IDC_RESPONSE_CHECK },
|
|
{ DNS_LOG_LEVEL_SEND, IDC_SEND_CHECK },
|
|
{ DNS_LOG_LEVEL_RECV, IDC_RECEIVE_CHECK },
|
|
{ DNS_LOG_LEVEL_UDP, IDC_UDP_CHECK },
|
|
{ DNS_LOG_LEVEL_TCP, IDC_TCP_CHECK },
|
|
{ DNS_LOG_LEVEL_FULL_PACKETS, IDC_DETAIL_CHECK }
|
|
};
|
|
|
|
#define DEFAULT_LOGGING_OPTIONS (DNS_LOG_LEVEL_SEND | \
|
|
DNS_LOG_LEVEL_RECV | \
|
|
DNS_LOG_LEVEL_UDP | \
|
|
DNS_LOG_LEVEL_TCP | \
|
|
DNS_LOG_LEVEL_QUERY | \
|
|
DNS_LOG_LEVEL_UPDATE | \
|
|
DNS_LOG_LEVEL_QUESTIONS | \
|
|
DNS_LOG_LEVEL_ANSWERS )
|
|
|
|
void CDNSServer_DebugLoggingPropertyPage::OnLoggingCheck()
|
|
{
|
|
BOOL bLogging = SendDlgItemMessage(IDC_DEBUG_LOGGING_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
|
|
EnableLogging(bLogging);
|
|
|
|
if (bLogging &&
|
|
m_dwLogLevel == 0 &&
|
|
!AreOptionsDirty())
|
|
{
|
|
ResetToDefaults();
|
|
}
|
|
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
void CDNSServer_DebugLoggingPropertyPage::OnSendCheck()
|
|
{
|
|
BOOL bOutgoing = SendDlgItemMessage(IDC_SEND_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
BOOL bIncoming = SendDlgItemMessage(IDC_RECEIVE_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
|
|
if (!bOutgoing && !bIncoming)
|
|
{
|
|
SendDlgItemMessage(IDC_RECEIVE_CHECK, BM_SETCHECK, BST_CHECKED, 0);
|
|
GetDlgItem(IDC_RECEIVE_CHECK)->SetFocus();
|
|
}
|
|
SetOptionsDirty();
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
void CDNSServer_DebugLoggingPropertyPage::OnReceiveCheck()
|
|
{
|
|
BOOL bOutgoing = SendDlgItemMessage(IDC_SEND_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
BOOL bIncoming = SendDlgItemMessage(IDC_RECEIVE_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
|
|
if (!bOutgoing && !bIncoming)
|
|
{
|
|
SendDlgItemMessage(IDC_SEND_CHECK, BM_SETCHECK, BST_CHECKED, 0);
|
|
GetDlgItem(IDC_SEND_CHECK)->SetFocus();
|
|
}
|
|
SetOptionsDirty();
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
void CDNSServer_DebugLoggingPropertyPage::OnQueriesCheck()
|
|
{
|
|
BOOL bQueries = SendDlgItemMessage(IDC_QUERIES_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
BOOL bNotifies = SendDlgItemMessage(IDC_NOTIFIES_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
BOOL bUpdates = SendDlgItemMessage(IDC_UPDATES_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
|
|
if (!bQueries && !bNotifies && !bUpdates)
|
|
{
|
|
SendDlgItemMessage(IDC_UPDATES_CHECK, BM_SETCHECK, BST_CHECKED, 0);
|
|
GetDlgItem(IDC_UPDATES_CHECK)->SetFocus();
|
|
}
|
|
SetOptionsDirty();
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
void CDNSServer_DebugLoggingPropertyPage::OnUpdatesCheck()
|
|
{
|
|
BOOL bQueries = SendDlgItemMessage(IDC_QUERIES_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
BOOL bNotifies = SendDlgItemMessage(IDC_NOTIFIES_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
BOOL bUpdates = SendDlgItemMessage(IDC_UPDATES_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
|
|
if (!bQueries && !bNotifies && !bUpdates)
|
|
{
|
|
SendDlgItemMessage(IDC_NOTIFIES_CHECK, BM_SETCHECK, BST_CHECKED, 0);
|
|
GetDlgItem(IDC_NOTIFIES_CHECK)->SetFocus();
|
|
}
|
|
SetOptionsDirty();
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
void CDNSServer_DebugLoggingPropertyPage::OnNotifiesCheck()
|
|
{
|
|
BOOL bQueries = SendDlgItemMessage(IDC_QUERIES_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
BOOL bNotifies = SendDlgItemMessage(IDC_NOTIFIES_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
BOOL bUpdates = SendDlgItemMessage(IDC_UPDATES_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
|
|
if (!bQueries && !bNotifies && !bUpdates)
|
|
{
|
|
SendDlgItemMessage(IDC_QUERIES_CHECK, BM_SETCHECK, BST_CHECKED, 0);
|
|
GetDlgItem(IDC_QUERIES_CHECK)->SetFocus();
|
|
}
|
|
SetOptionsDirty();
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
|
|
void CDNSServer_DebugLoggingPropertyPage::OnRequestCheck()
|
|
{
|
|
BOOL bRequest = SendDlgItemMessage(IDC_REQUEST_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
BOOL bResponse = SendDlgItemMessage(IDC_RESPONSE_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
|
|
if (!bRequest && !bResponse)
|
|
{
|
|
SendDlgItemMessage(IDC_RESPONSE_CHECK, BM_SETCHECK, BST_CHECKED, 0);
|
|
GetDlgItem(IDC_RESPONSE_CHECK)->SetFocus();
|
|
}
|
|
SetOptionsDirty();
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
void CDNSServer_DebugLoggingPropertyPage::OnResponseCheck()
|
|
{
|
|
BOOL bRequest = SendDlgItemMessage(IDC_REQUEST_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
BOOL bResponse = SendDlgItemMessage(IDC_RESPONSE_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
|
|
if (!bRequest && !bResponse)
|
|
{
|
|
SendDlgItemMessage(IDC_REQUEST_CHECK, BM_SETCHECK, BST_CHECKED, 0);
|
|
GetDlgItem(IDC_REQUEST_CHECK)->SetFocus();
|
|
}
|
|
SetOptionsDirty();
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
void CDNSServer_DebugLoggingPropertyPage::OnUDPCheck()
|
|
{
|
|
BOOL bUDP = SendDlgItemMessage(IDC_UDP_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
BOOL bTCP = SendDlgItemMessage(IDC_TCP_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
|
|
if (!bUDP && !bTCP)
|
|
{
|
|
SendDlgItemMessage(IDC_TCP_CHECK, BM_SETCHECK, BST_CHECKED, 0);
|
|
GetDlgItem(IDC_TCP_CHECK)->SetFocus();
|
|
}
|
|
SetOptionsDirty();
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
void CDNSServer_DebugLoggingPropertyPage::OnTCPCheck()
|
|
{
|
|
BOOL bUDP = SendDlgItemMessage(IDC_UDP_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
BOOL bTCP = SendDlgItemMessage(IDC_TCP_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
|
|
if (!bUDP && !bTCP)
|
|
{
|
|
SendDlgItemMessage(IDC_UDP_CHECK, BM_SETCHECK, BST_CHECKED, 0);
|
|
GetDlgItem(IDC_UDP_CHECK)->SetFocus();
|
|
}
|
|
SetOptionsDirty();
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
void CDNSServer_DebugLoggingPropertyPage::OnDetailCheck()
|
|
{
|
|
SetOptionsDirty();
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
void CDNSServer_DebugLoggingPropertyPage::SetOptionsDirty(BOOL bDirty)
|
|
{
|
|
m_bOptionsDirty = bDirty;
|
|
}
|
|
|
|
BOOL CDNSServer_DebugLoggingPropertyPage::AreOptionsDirty()
|
|
{
|
|
return m_bOptionsDirty;
|
|
}
|
|
void CDNSServer_DebugLoggingPropertyPage::EnableLogging(BOOL bEnable)
|
|
{
|
|
//
|
|
// NOTE: the curly brace icons must be enabled before
|
|
// the other controls so that they get painted first
|
|
// and the other controls can paint over top of them
|
|
// If not, the text of the controls gets cut off
|
|
//
|
|
GetDlgItem(IDC_BRACE1_STATIC)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_SELECT1_STATIC)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_BRACE2_STATIC)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_SELECT2_STATIC)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_BRACE3_STATIC)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_SELECT3_STATIC)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_BRACE4_STATIC)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_SELECT4_STATIC)->EnableWindow(bEnable);
|
|
|
|
GetDlgItem(IDC_DIRECTION_STATIC)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_SEND_CHECK)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_RECEIVE_CHECK)->EnableWindow(bEnable);
|
|
|
|
GetDlgItem(IDC_CONTENTS_STATIC)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_QUERIES_CHECK)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_NOTIFIES_CHECK)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_UPDATES_CHECK)->EnableWindow(bEnable);
|
|
|
|
GetDlgItem(IDC_TRANSPORT_STATIC)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_UDP_CHECK)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_TCP_CHECK)->EnableWindow(bEnable);
|
|
|
|
GetDlgItem(IDC_TYPE_STATIC)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_REQUEST_CHECK)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_RESPONSE_CHECK)->EnableWindow(bEnable);
|
|
|
|
GetDlgItem(IDC_OPTIONS_STATIC)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_DETAIL_CHECK)->EnableWindow(bEnable);
|
|
|
|
//
|
|
// All controls after this point will be disabled no matter
|
|
// what the input if we are not targetting a Whistler or greater
|
|
// server
|
|
//
|
|
if (m_bNotWhistler)
|
|
{
|
|
bEnable = FALSE;
|
|
}
|
|
|
|
GetDlgItem(IDC_FILTERING_CHECK)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_FILTER_BUTTON)->EnableWindow(
|
|
SendDlgItemMessage(IDC_FILTERING_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED
|
|
&& bEnable);
|
|
|
|
GetDlgItem(IDC_LOG_STATIC)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_FILENAME_STATIC)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_LOGFILE_EDIT)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_MAXSIZE_STATIC)->EnableWindow(bEnable);
|
|
GetDlgItem(IDC_MAX_SIZE_EDIT)->EnableWindow(bEnable);
|
|
|
|
}
|
|
|
|
void CDNSServer_DebugLoggingPropertyPage::ResetToDefaults()
|
|
{
|
|
SetUIFromOptions(DEFAULT_LOGGING_OPTIONS);
|
|
}
|
|
|
|
void CDNSServer_DebugLoggingPropertyPage::OnFilterCheck()
|
|
{
|
|
LRESULT lRes = SendDlgItemMessage(IDC_FILTERING_CHECK, BM_GETCHECK, 0, 0);
|
|
GetDlgItem(IDC_FILTER_BUTTON)->EnableWindow(lRes == BST_CHECKED);
|
|
|
|
if (!m_bOnSetUIData)
|
|
{
|
|
m_bFilterDirty = TRUE;
|
|
SetDirty(TRUE);
|
|
}
|
|
}
|
|
|
|
void CDNSServer_DebugLoggingPropertyPage::OnFilterButton()
|
|
{
|
|
CIPFilterDialog filterDialog(m_pIPFilterList, GetHolder()->GetComponentData());
|
|
if (filterDialog.DoModal() == IDOK)
|
|
{
|
|
if (m_bOwnIPListMemory && m_pIPFilterList != NULL)
|
|
{
|
|
free(m_pIPFilterList);
|
|
m_pIPFilterList = NULL;
|
|
}
|
|
m_pIPFilterList = filterDialog.GetIPFilter();
|
|
m_bOwnIPListMemory = TRUE;
|
|
m_bFilterDirty = TRUE;
|
|
SetDirty(TRUE);
|
|
}
|
|
}
|
|
|
|
void CDNSServer_DebugLoggingPropertyPage::OnLogFileChange()
|
|
{
|
|
if (!m_bOnSetUIData)
|
|
{
|
|
m_bLogFileDirty = TRUE;
|
|
SetDirty(TRUE);
|
|
}
|
|
}
|
|
|
|
void CDNSServer_DebugLoggingPropertyPage::OnMaxSizeChange()
|
|
{
|
|
if (!m_bOnSetUIData)
|
|
{
|
|
m_bMaxSizeDirty = TRUE;
|
|
SetDirty(TRUE);
|
|
}
|
|
}
|
|
|
|
void CDNSServer_DebugLoggingPropertyPage::SetUIData()
|
|
{
|
|
m_bOnSetUIData = TRUE;
|
|
|
|
CPropertyPageBase::OnInitDialog();
|
|
CDNSServerPropertyPageHolder* pHolder =
|
|
(CDNSServerPropertyPageHolder*)GetHolder();
|
|
CDNSServerNode* pServerNode = pHolder->GetServerNode();
|
|
|
|
m_dwLogLevel = pServerNode->GetLogLevelFlag();
|
|
m_dwMaxSize = pServerNode->GetDebugLogFileMaxSize();
|
|
|
|
if (m_bOwnIPListMemory && m_pIPFilterList)
|
|
{
|
|
free(m_pIPFilterList);
|
|
m_pIPFilterList = NULL;
|
|
m_bOwnIPListMemory = FALSE;
|
|
}
|
|
m_pIPFilterList = pServerNode->GetDebugLogFilterList();
|
|
m_szLogFileName = pServerNode->GetDebugLogFileName();
|
|
|
|
|
|
if (m_dwLogLevel)
|
|
{
|
|
SendDlgItemMessage(IDC_DEBUG_LOGGING_CHECK, BM_SETCHECK, BST_CHECKED, 0);
|
|
SetUIFromOptions(m_dwLogLevel);
|
|
}
|
|
else
|
|
{
|
|
SendDlgItemMessage(IDC_DEBUG_LOGGING_CHECK, BM_SETCHECK, BST_UNCHECKED, 0);
|
|
ResetToDefaults();
|
|
}
|
|
|
|
//
|
|
// Set log file name
|
|
//
|
|
SetDlgItemText(IDC_LOGFILE_EDIT, m_szLogFileName);
|
|
|
|
//
|
|
// Set max file size
|
|
//
|
|
SetDlgItemInt(IDC_MAX_SIZE_EDIT, m_dwMaxSize);
|
|
|
|
//
|
|
// Set filter check
|
|
//
|
|
if (m_pIPFilterList != NULL)
|
|
{
|
|
SendDlgItemMessage(IDC_FILTERING_CHECK, BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
|
|
GetDlgItem(IDC_FILTER_BUTTON)->EnableWindow(TRUE);
|
|
}
|
|
else
|
|
{
|
|
SendDlgItemMessage(IDC_FILTERING_CHECK, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
|
|
GetDlgItem(IDC_FILTER_BUTTON)->EnableWindow(FALSE);
|
|
}
|
|
|
|
//
|
|
// Now enable/disable the controls based on the options
|
|
//
|
|
EnableLogging(m_dwLogLevel > 0);
|
|
|
|
m_bOnSetUIData = FALSE;
|
|
}
|
|
|
|
void CDNSServer_DebugLoggingPropertyPage::SetUIFromOptions(DWORD dwOptions)
|
|
{
|
|
//
|
|
// Set logging options
|
|
//
|
|
for (UINT idx = 0; idx < ARRAYLENGTH(g_loggingOptions); idx++)
|
|
{
|
|
if (g_loggingOptions[idx].dwOption & dwOptions)
|
|
{
|
|
SendDlgItemMessage(g_loggingOptions[idx].nControlID, BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
|
|
}
|
|
else
|
|
{
|
|
SendDlgItemMessage(g_loggingOptions[idx].nControlID, BM_SETCHECK, (WPARAM)BST_UNCHECKED, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDNSServer_DebugLoggingPropertyPage::GetUIData(BOOL)
|
|
{
|
|
if (SendDlgItemMessage(IDC_DEBUG_LOGGING_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED)
|
|
{
|
|
//
|
|
// Get logging options
|
|
//
|
|
for (UINT idx = 0; idx < ARRAYLENGTH(g_loggingOptions); idx++)
|
|
{
|
|
LRESULT lCheck = SendDlgItemMessage(g_loggingOptions[idx].nControlID, BM_GETCHECK, 0, 0);
|
|
if (lCheck == BST_CHECKED)
|
|
{
|
|
m_dwLogLevel |= g_loggingOptions[idx].dwOption;
|
|
}
|
|
else
|
|
{
|
|
m_dwLogLevel &= ~(g_loggingOptions[idx].dwOption);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Get log file name
|
|
//
|
|
GetDlgItemText(IDC_LOGFILE_EDIT, m_szLogFileName);
|
|
|
|
//
|
|
// Get max file size
|
|
//
|
|
BOOL bTrans = FALSE;
|
|
m_dwMaxSize = GetDlgItemInt(IDC_MAX_SIZE_EDIT, &bTrans, FALSE);
|
|
|
|
//
|
|
// Note: the filter IP addresses will be set when returning from the filter dialog
|
|
//
|
|
}
|
|
else
|
|
{
|
|
m_dwLogLevel = 0;
|
|
}
|
|
|
|
}
|
|
|
|
BOOL CDNSServer_DebugLoggingPropertyPage::OnInitDialog()
|
|
{
|
|
CPropertyPageBase::OnInitDialog();
|
|
CDNSServerPropertyPageHolder* pHolder =
|
|
(CDNSServerPropertyPageHolder*)GetHolder();
|
|
CDNSServerNode* pServerNode = pHolder->GetServerNode();
|
|
|
|
//
|
|
// Retrieve necessary data from server
|
|
//
|
|
if (!pServerNode->HasServerInfo())
|
|
{
|
|
EnableWindow(FALSE);
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Limit the file size to 10 characters (MAX_INT is 10 characters)
|
|
//
|
|
SendDlgItemMessage(IDC_MAX_SIZE_EDIT, EM_SETLIMITTEXT, (WPARAM)10, 0);
|
|
|
|
SetUIData();
|
|
|
|
m_bMaxSizeDirty = FALSE;
|
|
m_bLogFileDirty = FALSE;
|
|
m_bFilterDirty = FALSE;
|
|
|
|
if (pServerNode->GetBuildNumber() < DNS_SRV_BUILD_NUMBER_WHISTLER ||
|
|
(pServerNode->GetMajorVersion() <= DNS_SRV_MAJOR_VERSION_NT_5 &&
|
|
pServerNode->GetMinorVersion() < DNS_SRV_MINOR_VERSION_WHISTLER))
|
|
{
|
|
//
|
|
// These debug options are not available on pre-Whistler servers
|
|
//
|
|
m_bNotWhistler = TRUE;
|
|
GetDlgItem(IDC_FILTERING_CHECK)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_MAX_SIZE_EDIT)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_LOGFILE_EDIT)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_FILENAME_STATIC)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_MAXSIZE_STATIC)->EnableWindow(FALSE);
|
|
}
|
|
|
|
SetDirty(FALSE);
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
BOOL CDNSServer_DebugLoggingPropertyPage::OnApply()
|
|
{
|
|
if (!IsDirty())
|
|
return TRUE;
|
|
|
|
CDNSServerPropertyPageHolder* pHolder =
|
|
(CDNSServerPropertyPageHolder*)GetHolder();
|
|
CDNSServerNode* pServerNode = pHolder->GetServerNode();
|
|
|
|
GetUIData(FALSE);
|
|
|
|
DNS_STATUS dwErr = pServerNode->ResetLogLevelFlag(m_dwLogLevel);
|
|
if (dwErr != 0)
|
|
{
|
|
DNSErrorDialog(dwErr, IDS_MSG_SERVER_LOG_LEVEL_OPTIONS_FAILED);
|
|
return FALSE;
|
|
}
|
|
|
|
if (m_bMaxSizeDirty && !m_bNotWhistler)
|
|
{
|
|
dwErr = pServerNode->ResetDebugLogFileMaxSize(m_dwMaxSize);
|
|
if (dwErr != 0)
|
|
{
|
|
DNSErrorDialog(dwErr, IDS_MSG_SERVER_LOG_MAX_SIZE_FAILED);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (m_bLogFileDirty && !m_bNotWhistler)
|
|
{
|
|
dwErr = pServerNode->ResetDebugLogFileName(m_szLogFileName);
|
|
if (dwErr != 0)
|
|
{
|
|
DNSErrorDialog(dwErr, IDS_MSG_SERVER_LOG_FILE_NAME_FAILED);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (m_bFilterDirty && !m_bNotWhistler)
|
|
{
|
|
LRESULT lCheck = SendDlgItemMessage(IDC_FILTERING_CHECK, BM_GETCHECK, 0, 0);
|
|
if (lCheck == BST_CHECKED)
|
|
{
|
|
dwErr = pServerNode->ResetDebugLogFilterList(m_pIPFilterList);
|
|
}
|
|
else
|
|
{
|
|
dwErr = pServerNode->ResetDebugLogFilterList(NULL);
|
|
}
|
|
if (dwErr != 0)
|
|
{
|
|
DNSErrorDialog(dwErr, IDS_MSG_SERVER_LOG_FILTER_LIST_FAILED);
|
|
return FALSE;
|
|
}
|
|
m_bFilterDirty = FALSE;
|
|
}
|
|
|
|
//
|
|
// all is fine
|
|
//
|
|
SetUIData();
|
|
SetDirty(FALSE);
|
|
return TRUE;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// CDNSServer_EventLoggingPropertyPage
|
|
|
|
BEGIN_MESSAGE_MAP(CDNSServer_EventLoggingPropertyPage, CPropertyPageBase)
|
|
ON_BN_CLICKED(IDC_NO_EVENTS_RADIO, OnSetDirty)
|
|
ON_BN_CLICKED(IDC_ERRORS_RADIO, OnSetDirty)
|
|
ON_BN_CLICKED(IDC_ERRORS_WARNINGS_RADIO, OnSetDirty)
|
|
ON_BN_CLICKED(IDC_ALL_RADIO, OnSetDirty)
|
|
END_MESSAGE_MAP()
|
|
|
|
CDNSServer_EventLoggingPropertyPage::CDNSServer_EventLoggingPropertyPage()
|
|
: CPropertyPageBase(IDD_SERVER_EVENT_LOGGING_PAGE),
|
|
m_dwEventLogLevel(EVENTLOG_INFORMATION_TYPE)
|
|
{
|
|
}
|
|
|
|
|
|
void CDNSServer_EventLoggingPropertyPage::SetUIData()
|
|
{
|
|
if (m_dwEventLogLevel == 0)
|
|
{
|
|
SendDlgItemMessage(IDC_NO_EVENTS_RADIO, BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
|
|
}
|
|
else if (m_dwEventLogLevel == EVENTLOG_ERROR_TYPE)
|
|
{
|
|
SendDlgItemMessage(IDC_ERRORS_RADIO, BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
|
|
}
|
|
else if (m_dwEventLogLevel == EVENTLOG_WARNING_TYPE)
|
|
{
|
|
SendDlgItemMessage(IDC_ERRORS_WARNINGS_RADIO, BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
|
|
}
|
|
else
|
|
{
|
|
SendDlgItemMessage(IDC_ALL_RADIO, BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
|
|
}
|
|
}
|
|
|
|
void CDNSServer_EventLoggingPropertyPage::OnSetDirty()
|
|
{
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
BOOL CDNSServer_EventLoggingPropertyPage::OnInitDialog()
|
|
{
|
|
CPropertyPageBase::OnInitDialog();
|
|
CDNSServerPropertyPageHolder* pHolder =
|
|
(CDNSServerPropertyPageHolder*)GetHolder();
|
|
CDNSServerNode* pServerNode = pHolder->GetServerNode();
|
|
|
|
if (!pServerNode->HasServerInfo())
|
|
{
|
|
EnableWindow(FALSE);
|
|
return TRUE;
|
|
}
|
|
|
|
m_dwEventLogLevel = pServerNode->GetEventLogLevelFlag();
|
|
|
|
SetUIData();
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
BOOL CDNSServer_EventLoggingPropertyPage::OnApply()
|
|
{
|
|
if (!IsDirty())
|
|
return TRUE;
|
|
|
|
CDNSServerPropertyPageHolder* pHolder =
|
|
(CDNSServerPropertyPageHolder*)GetHolder();
|
|
CDNSServerNode* pServerNode = pHolder->GetServerNode();
|
|
|
|
//
|
|
// Retrieve UI data
|
|
//
|
|
LRESULT lNoEventsCheck = SendDlgItemMessage(IDC_NO_EVENTS_RADIO, BM_GETCHECK, 0, 0);
|
|
LRESULT lErrorsCheck = SendDlgItemMessage(IDC_ERRORS_RADIO, BM_GETCHECK, 0, 0);
|
|
LRESULT lWarningsCheck = SendDlgItemMessage(IDC_ERRORS_WARNINGS_RADIO, BM_GETCHECK, 0, 0);
|
|
LRESULT lAllCheck = SendDlgItemMessage(IDC_ALL_RADIO, BM_GETCHECK, 0, 0);
|
|
|
|
DWORD dwEventLogLevel = 0;
|
|
if (lNoEventsCheck == BST_CHECKED)
|
|
{
|
|
dwEventLogLevel = 0;
|
|
}
|
|
|
|
if (lErrorsCheck == BST_CHECKED)
|
|
{
|
|
dwEventLogLevel = EVENTLOG_ERROR_TYPE;
|
|
}
|
|
|
|
if (lWarningsCheck == BST_CHECKED)
|
|
{
|
|
dwEventLogLevel = EVENTLOG_WARNING_TYPE;
|
|
}
|
|
|
|
if (lAllCheck == BST_CHECKED)
|
|
{
|
|
dwEventLogLevel = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE;
|
|
}
|
|
|
|
//
|
|
// Set new event log level on server
|
|
//
|
|
DNS_STATUS err = 0;
|
|
err = pServerNode->ResetEventLogLevelFlag(dwEventLogLevel);
|
|
if (err != 0)
|
|
{
|
|
::DNSErrorDialog(err, IDS_MSG_SERVER_FAILED_SET_EVENTLOGLEVEL);
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// all is fine
|
|
//
|
|
SetDirty(FALSE);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// CDNSServer_CopyRootHintsFromDialog
|
|
|
|
BEGIN_MESSAGE_MAP(CDNSServer_CopyRootHintsFromDialog, CHelpDialog)
|
|
ON_EN_CHANGE(IDC_IPEDIT, OnIPv4CtrlChange)
|
|
END_MESSAGE_MAP()
|
|
|
|
CDNSServer_CopyRootHintsFromDialog::CDNSServer_CopyRootHintsFromDialog(CComponentDataObject* pComponentData)
|
|
: CHelpDialog(IDD_COPY_ROOTHINTS_DIALOG, pComponentData),
|
|
m_pComponentData(pComponentData)
|
|
{
|
|
m_dwIPVal = 0;
|
|
}
|
|
|
|
void CDNSServer_CopyRootHintsFromDialog::OnIPv4CtrlChange()
|
|
{
|
|
GetDlgItem(IDOK)->EnableWindow(!GetIPv4Ctrl()->IsEmpty());
|
|
}
|
|
|
|
void CDNSServer_CopyRootHintsFromDialog::OnOK()
|
|
{
|
|
GetIPv4Ctrl()->GetIPv4Val(&m_dwIPVal);
|
|
CDialog::OnOK();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// CDNSServer_RootHintsPropertyPage
|
|
|
|
BEGIN_MESSAGE_MAP(CDNSServer_RootHintsPropertyPage, CDNSNameServersPropertyPage)
|
|
ON_BN_CLICKED(IDC_COPY_FROM_BUTTON, OnCopyFrom)
|
|
END_MESSAGE_MAP()
|
|
|
|
CDNSServer_RootHintsPropertyPage::CDNSServer_RootHintsPropertyPage()
|
|
: CDNSNameServersPropertyPage(IDD_NAME_SERVERS_PAGE, IDS_NSPAGE_ROOT_HINTS)
|
|
{
|
|
m_bMeaningfulTTL = FALSE; // TTL for root hinst means nothing
|
|
}
|
|
|
|
BOOL CDNSServer_RootHintsPropertyPage::OnInitDialog()
|
|
{
|
|
CDNSNameServersPropertyPage::OnInitDialog();
|
|
|
|
if (m_bReadOnly)
|
|
{
|
|
GetDlgItem(IDC_COPY_FROM_BUTTON)->ShowWindow(TRUE);
|
|
GetDlgItem(IDC_COPY_FROM_BUTTON)->EnableWindow(FALSE);
|
|
}
|
|
else
|
|
{
|
|
GetDlgItem(IDC_COPY_FROM_BUTTON)->ShowWindow(TRUE);
|
|
GetDlgItem(IDC_COPY_FROM_BUTTON)->EnableWindow(TRUE);
|
|
}
|
|
GetDlgItem(IDC_DNSQUERY_STATIC)->ShowWindow(FALSE);
|
|
GetDlgItem(IDC_DNSQUERY_STATIC)->EnableWindow(FALSE);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CDNSServer_RootHintsPropertyPage::OnCopyFrom()
|
|
{
|
|
BOOL bSuccess = FALSE;
|
|
while (!bSuccess)
|
|
{
|
|
CDNSServer_CopyRootHintsFromDialog copydlg(GetHolder()->GetComponentData());
|
|
if (copydlg.DoModal() == IDCANCEL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// create a thread object and set the name of servers to query
|
|
//
|
|
CRootHintsQueryThread* pThreadObj = new CRootHintsQueryThread;
|
|
if (pThreadObj == NULL)
|
|
{
|
|
ASSERT(FALSE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// if IP address given, try it
|
|
//
|
|
pThreadObj->LoadIPAddresses(1, &(copydlg.m_dwIPVal));
|
|
|
|
//
|
|
// create a dialog and attach the thread to it
|
|
//
|
|
CWnd* pParentWnd = CWnd::FromHandle(GetSafeHwnd());
|
|
if (pParentWnd == NULL)
|
|
{
|
|
ASSERT(FALSE);
|
|
return;
|
|
}
|
|
|
|
CLongOperationDialog dlg(pThreadObj, pParentWnd, IDR_SEARCH_AVI);
|
|
VERIFY(dlg.LoadTitleString(IDS_MSG_SERVWIZ_COLLECTINFO));
|
|
dlg.m_bExecuteNoUI = FALSE;
|
|
|
|
dlg.DoModal();
|
|
if (!dlg.m_bAbandoned)
|
|
{
|
|
if (pThreadObj->GetError() != 0)
|
|
{
|
|
DNSMessageBox(IDS_MSG_SERVWIZ_FAIL_ROOT_HINTS);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// success, get the root hints info to the UI
|
|
//
|
|
PDNS_RECORD pRootHintsRecordList = pThreadObj->GetHintsRecordList();
|
|
AddCopiedRootHintsToList(pRootHintsRecordList);
|
|
}
|
|
bSuccess = pThreadObj->GetError() == 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDNSServer_RootHintsPropertyPage::AddCopiedRootHintsToList(PDNS_RECORD pRootHintsRecordList)
|
|
{
|
|
CDNSRecordNodeEditInfoList NSRecordList;
|
|
CDNSRecordNodeEditInfoList ARecordList;
|
|
|
|
//
|
|
// walk through the list of root hints,
|
|
// convert to C++ format,
|
|
// write to server and add to the folder list (no UI, folder hidden)
|
|
//
|
|
PDNS_RECORD pCurrDnsQueryRecord = pRootHintsRecordList;
|
|
while (pCurrDnsQueryRecord != NULL)
|
|
{
|
|
ASSERT( (pCurrDnsQueryRecord->wType == DNS_TYPE_A) ||
|
|
(pCurrDnsQueryRecord->wType == DNS_TYPE_NS) );
|
|
|
|
//
|
|
// create a record node and read data from DnsQuery format
|
|
//
|
|
CDNSRecordNodeBase* pRecordNode =
|
|
CDNSRecordInfo::CreateRecordNode(pCurrDnsQueryRecord->wType);
|
|
pRecordNode->CreateFromDnsQueryRecord(pCurrDnsQueryRecord, DNS_RPC_RECORD_FLAG_ZONE_ROOT);
|
|
|
|
//
|
|
// create new data
|
|
//
|
|
CDNSRecordNodeEditInfo* pNewInfo = new CDNSRecordNodeEditInfo;
|
|
pNewInfo->m_action = CDNSRecordNodeEditInfo::add;
|
|
CDNSRootData* pRootData = (CDNSRootData*)(GetHolder()->GetComponentData()->GetRootData());
|
|
ASSERT(pRootData != NULL);
|
|
|
|
//
|
|
// create entry into the record info list
|
|
//
|
|
if (pCurrDnsQueryRecord->wType == DNS_TYPE_NS)
|
|
{
|
|
pNewInfo->CreateFromNewRecord(new CDNS_NS_RecordNode);
|
|
|
|
//
|
|
// set the record node name
|
|
//
|
|
BOOL bAtTheNode = (pCurrDnsQueryRecord->wType == DNS_TYPE_NS);
|
|
pNewInfo->m_pRecordNode->SetRecordName(pCurrDnsQueryRecord->pName, bAtTheNode);
|
|
|
|
//
|
|
// Set the record
|
|
//
|
|
pNewInfo->m_pRecord->ReadDnsQueryData(pCurrDnsQueryRecord);
|
|
|
|
//
|
|
// Add to the NS record list
|
|
//
|
|
NSRecordList.AddTail(pNewInfo);
|
|
}
|
|
else // DNS_TYPE_A
|
|
{
|
|
pNewInfo->CreateFromNewRecord(new CDNS_A_RecordNode);
|
|
|
|
//
|
|
// set the record node name
|
|
//
|
|
pNewInfo->m_pRecordNode->SetRecordName(pCurrDnsQueryRecord->pName, FALSE);
|
|
|
|
//
|
|
// Set the record
|
|
//
|
|
pNewInfo->m_pRecord->ReadDnsQueryData(pCurrDnsQueryRecord);
|
|
|
|
ARecordList.AddTail(pNewInfo);
|
|
}
|
|
|
|
pCurrDnsQueryRecord = pCurrDnsQueryRecord->pNext;
|
|
}
|
|
|
|
//
|
|
// Match the A records to the NS records
|
|
//
|
|
POSITION Apos = ARecordList.GetHeadPosition();
|
|
while (Apos != NULL)
|
|
{
|
|
CDNSRecordNodeEditInfo* pAInfo = ARecordList.GetNext(Apos);
|
|
ASSERT(pAInfo != NULL);
|
|
if (pAInfo == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
CDNS_A_RecordNode* pARecordNode = reinterpret_cast<CDNS_A_RecordNode*>(pAInfo->m_pRecordNode);
|
|
ASSERT(pARecordNode != NULL);
|
|
if (pARecordNode == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
POSITION NSpos = NSRecordList.GetHeadPosition();
|
|
while (NSpos != NULL)
|
|
{
|
|
CDNSRecordNodeEditInfo* pNSInfo = NSRecordList.GetNext(NSpos);
|
|
ASSERT(pNSInfo != NULL);
|
|
if (pNSInfo == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
CDNS_NS_Record* pNSRecord = reinterpret_cast<CDNS_NS_Record*>(pNSInfo->m_pRecord);
|
|
ASSERT(pNSRecord != NULL);
|
|
if (pNSRecord == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (_match(pNSRecord->m_szNameNode, pARecordNode))
|
|
{
|
|
pNSInfo->m_pEditInfoList->AddTail(pAInfo);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Detach and add the NS records info to the UI
|
|
//
|
|
while (!NSRecordList.IsEmpty())
|
|
{
|
|
CDNSRecordNodeEditInfo* pNewInfo = reinterpret_cast<CDNSRecordNodeEditInfo*>(NSRecordList.RemoveTail());
|
|
ASSERT(pNewInfo != NULL);
|
|
if (pNewInfo == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// add to the list view (at the end)
|
|
//
|
|
int nCount = m_listCtrl.GetItemCount();
|
|
if (m_listCtrl.InsertNSRecordEntry(pNewInfo, nCount))
|
|
{
|
|
//
|
|
// Add to the clone info list so that changes will be applied
|
|
//
|
|
m_pCloneInfoList->AddTail(pNewInfo);
|
|
|
|
//
|
|
// set selection and button state on the last inserted
|
|
//
|
|
m_listCtrl.SetSelection(nCount);
|
|
EnableEditorButtons(nCount);
|
|
|
|
//
|
|
// notify count change
|
|
//
|
|
OnCountChange(nCount+1); // added one
|
|
}
|
|
|
|
//
|
|
// set dirty flag, it is a new record
|
|
//
|
|
SetDirty(TRUE);
|
|
|
|
}
|
|
|
|
while (!ARecordList.IsEmpty())
|
|
{
|
|
ARecordList.RemoveTail();
|
|
}
|
|
}
|
|
|
|
void CDNSServer_RootHintsPropertyPage::ReadRecordNodesList()
|
|
{
|
|
ASSERT(m_pCloneInfoList != NULL);
|
|
CDNSServerPropertyPageHolder* pHolder = (CDNSServerPropertyPageHolder*)GetHolder();
|
|
CDNSServerNode* pServerNode = pHolder->GetServerNode();
|
|
|
|
|
|
CString szBuffer;
|
|
szBuffer.LoadString(IDS_ROOT_HINTS_DESCR);
|
|
GetDescription()->EnableWindow(TRUE);
|
|
GetDescription()->ShowWindow(TRUE);
|
|
SetDescription(szBuffer);
|
|
|
|
|
|
if (!pServerNode->HasServerInfo())
|
|
{
|
|
SetReadOnly();
|
|
return;
|
|
}
|
|
|
|
BOOL bRoot = FALSE;
|
|
DNS_STATUS err = ::ServerHasRootZone(pServerNode->GetRPCName(), &bRoot);
|
|
if (err == 0 && bRoot)
|
|
{
|
|
//
|
|
// it is a root server
|
|
//
|
|
szBuffer.LoadString(IDS_ROOT_HINTS_NO);
|
|
SetMessage(szBuffer);
|
|
SetReadOnly();
|
|
EnableDialogControls(m_hWnd, FALSE);
|
|
}
|
|
else
|
|
{
|
|
if (pServerNode->HasRootHints())
|
|
{
|
|
CDNSRootHintsNode* pRootHints = pServerNode->GetRootHints();
|
|
ASSERT(pRootHints != NULL);
|
|
SetDomainNode(pRootHints);
|
|
pRootHints->GetNSRecordNodesInfo(m_pCloneInfoList);
|
|
}
|
|
else
|
|
{
|
|
CDNSRootHintsNode* pRootHints = pServerNode->GetRootHints();
|
|
if (pRootHints != NULL)
|
|
{
|
|
SetDomainNode(pRootHints);
|
|
pRootHints->GetNSRecordNodesInfo(m_pCloneInfoList);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL CDNSServer_RootHintsPropertyPage::WriteNSRecordNodesList()
|
|
{
|
|
// call base class
|
|
BOOL bRetVal = CDNSNameServersPropertyPage::WriteNSRecordNodesList();
|
|
CDNSServerPropertyPageHolder* pHolder = (CDNSServerPropertyPageHolder*)GetHolder();
|
|
CDNSServerNode* pServerNode = pHolder->GetServerNode();
|
|
if (bRetVal && pServerNode->HasServerInfo())
|
|
{
|
|
DNS_STATUS err = CDNSZoneNode::WriteToDatabase(pServerNode->GetRPCName(), DNS_ZONE_ROOT_HINTS);
|
|
if (err != 0)
|
|
{
|
|
//DNSErrorDialog(err, L"CDNSZoneNode::WriteToDatabase() failed");
|
|
bRetVal = FALSE;
|
|
}
|
|
}
|
|
|
|
return bRetVal;
|
|
}
|
|
|
|
BOOL CDNSServer_RootHintsPropertyPage::OnApply()
|
|
{
|
|
BOOL bRet = TRUE;
|
|
|
|
CDNSServerPropertyPageHolder* pHolder = (CDNSServerPropertyPageHolder*)GetHolder();
|
|
CDNSServerNode* pServerNode = pHolder->GetServerNode();
|
|
if (m_listCtrl.GetItemCount() == 0 && pServerNode->HasRootHints())
|
|
{
|
|
//
|
|
// If there are no forwarders and no root zone then show an error message
|
|
//
|
|
BOOL bServerHasForwarders = FALSE;
|
|
CDNSDomainForwardersNode* pDomainForwardersNode = pServerNode->GetDomainForwardersNode();
|
|
if (pDomainForwardersNode)
|
|
{
|
|
CNodeList* pChildList = pDomainForwardersNode->GetContainerChildList();
|
|
if (pChildList)
|
|
{
|
|
bServerHasForwarders = (pChildList->GetHeadPosition() != NULL);
|
|
}
|
|
}
|
|
|
|
DWORD cAddrCount = 0;
|
|
PIP_ADDRESS pipAddrs = 0;
|
|
DWORD dwForwardTimeout = 0;
|
|
DWORD fSlave = 0;
|
|
pServerNode->GetForwardersInfo(&cAddrCount, &pipAddrs, &dwForwardTimeout, &fSlave);
|
|
if (cAddrCount > 0)
|
|
{
|
|
bServerHasForwarders = TRUE;
|
|
}
|
|
|
|
BOOL bServerHasRoot = FALSE;
|
|
DNS_STATUS err = ServerHasRootZone(pServerNode->GetRPCName(), &bServerHasRoot);
|
|
if (err == 0 && !bServerHasRoot && !bServerHasForwarders)
|
|
{
|
|
if (IDNO == DNSMessageBox(IDS_NO_ROOTHINTS, MB_YESNO | MB_DEFBUTTON2))
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bRet)
|
|
{
|
|
bRet = CDNSNameServersPropertyPage::OnApply();
|
|
}
|
|
return bRet;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// CDNSServerPropertyPageHolder
|
|
|
|
CDNSServerPropertyPageHolder::CDNSServerPropertyPageHolder(CDNSRootData* pRootDataNode,
|
|
CDNSServerNode* pServerNode, CComponentDataObject* pComponentData)
|
|
: CPropertyPageHolderBase(pRootDataNode, pServerNode, pComponentData)
|
|
{
|
|
ASSERT(pRootDataNode == GetContainerNode());
|
|
m_pAclEditorPage = NULL;
|
|
|
|
m_bAutoDeletePages = FALSE; // we have the pages as embedded members
|
|
|
|
if (pServerNode->HasServerInfo())
|
|
{
|
|
AddPageToList((CPropertyPageBase*)&m_interfacesPage);
|
|
AddPageToList((CPropertyPageBase*)&m_newForwardersPage);
|
|
AddPageToList((CPropertyPageBase*)&m_advancedPage);
|
|
AddPageToList((CPropertyPageBase*)&m_rootHintsPage);
|
|
AddPageToList((CPropertyPageBase*)&m_debugLoggingPage);
|
|
AddPageToList((CPropertyPageBase*)&m_eventLoggingPage);
|
|
|
|
// security page added only if needed
|
|
{
|
|
CString szPath;
|
|
pServerNode->CreateDsServerLdapPath(szPath);
|
|
if (!szPath.IsEmpty())
|
|
m_pAclEditorPage = CAclEditorPage::CreateInstance(szPath, this);
|
|
}
|
|
}
|
|
|
|
AddPageToList((CPropertyPageBase*)&m_testPage);
|
|
}
|
|
|
|
CDNSServerPropertyPageHolder::~CDNSServerPropertyPageHolder()
|
|
{
|
|
if (m_pAclEditorPage != NULL)
|
|
delete m_pAclEditorPage;
|
|
}
|
|
|
|
void CDNSServerPropertyPageHolder::OnSheetMessage(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
if (wParam == SHEET_MSG_SERVER_TEST_DATA)
|
|
{
|
|
m_testPage.OnHaveTestData(lParam);
|
|
}
|
|
}
|
|
|
|
|
|
HRESULT CDNSServerPropertyPageHolder::OnAddPage(int nPage, CPropertyPageBase*)
|
|
{
|
|
// add the ACL editor page after the last, if present
|
|
if ( (nPage != -1) || (m_pAclEditorPage == NULL) )
|
|
return S_OK;
|
|
|
|
// add the ACLU page
|
|
HPROPSHEETPAGE hPage = m_pAclEditorPage->CreatePage();
|
|
if (hPage == NULL)
|
|
return E_FAIL;
|
|
// add the raw HPROPSHEETPAGE to sheet, not in the list
|
|
return AddPageToSheetRaw(hPage);
|
|
} |