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

3620 lines
98 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: server.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 "servmon.h"
#include "servwiz.h"
#include "domain.h"
#include "record.h"
#include "zone.h"
#include "ZoneWiz.h"
#ifdef DEBUG_ALLOCATOR
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#endif
///////////////////////////////////////////////////////////////////////////////
// GLOBAL FUNCTIONS
LPCWSTR DNS_EVT_COMMAND_LINE = L"\\system32\\msdssevt.msc /computer=";
LPCWSTR MMC_APP = L"\\system32\\mmc.exe";
DNS_STATUS ServerHasCache(LPCWSTR lpszServerName, BOOL* pbRes)
{
USES_CONVERSION;
*pbRes = FALSE;
DWORD dwFilter = ZONE_REQUEST_CACHE;
PDNS_RPC_ZONE_LIST pZoneList = NULL;
DNS_STATUS err = ::DnssrvEnumZones(lpszServerName,
dwFilter,
NULL /*pszLastZone, unused for the moment */,
&pZoneList);
if (err == 0 &&
pZoneList)
{
*pbRes = (pZoneList->dwZoneCount > 0);
::DnssrvFreeZoneList(pZoneList);
}
else
{
ASSERT(pZoneList);
}
return err;
}
DNS_STATUS ServerHasRootZone(LPCWSTR lpszServerName, BOOL* pbRes)
{
USES_CONVERSION;
*pbRes = FALSE;
DWORD dwFilter = ZONE_REQUEST_FORWARD | ZONE_REQUEST_PRIMARY | ZONE_REQUEST_SECONDARY;
PDNS_RPC_ZONE_LIST pZoneList = NULL;
DNS_STATUS err = ::DnssrvEnumZones(lpszServerName,
dwFilter,
NULL /*pszLastZone, unused for the moment */,
&pZoneList);
if (err == 0 && pZoneList)
{
for (DWORD iZone = 0; iZone < pZoneList->dwZoneCount; iZone++)
{
if (pZoneList->ZoneArray[iZone]->pszZoneName)
{
if (wcscmp(L".", pZoneList->ZoneArray[iZone]->pszZoneName) == 0)
{
*pbRes = TRUE;
break;
}
}
}
}
if (pZoneList != NULL)
::DnssrvFreeZoneList(pZoneList);
return err;
}
///////////////////////////////////////////////////////////////////////////////
// CZoneInfoHolder : simple memory manager for arrays of zone info handles
#define DEFAULT_ZONE_INFO_ARRAY_SIZE (128)
#define MAX_ZONE_INFO_ARRAY_SIZE (0xffff)
CZoneInfoHolder::CZoneInfoHolder()
{
AllocateMemory(DEFAULT_ZONE_INFO_ARRAY_SIZE);
}
CZoneInfoHolder::~CZoneInfoHolder()
{
FreeMemory();
}
void CZoneInfoHolder::AllocateMemory(DWORD dwArrSize)
{
TRACE(_T("CZoneInfoHolder::AllocateMemory(dwArrSize = %d)\n"), dwArrSize);
m_dwArrSize = dwArrSize;
DWORD dwMemSize = 2*m_dwArrSize*sizeof(PDNS_ZONE_INFO);
m_zoneInfoArray = (PDNS_ZONE_INFO*)malloc(dwMemSize);
if (m_zoneInfoArray != NULL)
{
ASSERT(m_zoneInfoArray != NULL);
memset(m_zoneInfoArray, 0x0, dwMemSize);
m_dwZoneCount = 0;
#ifdef _DEBUG
for (DWORD k=0; k< dwArrSize; k++)
ASSERT(m_zoneInfoArray[k] == NULL);
#endif
}
}
void CZoneInfoHolder::FreeMemory()
{
if (m_zoneInfoArray != NULL)
{
TRACE(_T("CZoneInfoHolder::FreeMemory() m_dwArrSize = %d\n"), m_dwArrSize);
ASSERT(m_dwArrSize > 0);
//ASSERT(m_dwZoneCount <= m_dwArrSize);
for (DWORD k=0; k < m_dwArrSize; k++)
{
if (m_zoneInfoArray[k] != NULL)
{
TRACE(_T("CZoneInfoHolder::FreeMemory() DnsFreeZoneInfo(m_zoneInfoArray[%d])\n"), k);
::DnssrvFreeZoneInfo(m_zoneInfoArray[k]);
}
}
free(m_zoneInfoArray);
m_zoneInfoArray = NULL;
m_dwZoneCount = 0;
m_dwArrSize = 0;
}
}
BOOL CZoneInfoHolder::Grow()
{
TRACE(_T("CZoneInfoHolder::Grow()\n"));
if (m_dwArrSize >= MAX_ZONE_INFO_ARRAY_SIZE)
return FALSE;
ASSERT(m_dwArrSize > 0);
ASSERT(m_dwZoneCount > m_dwArrSize);
DWORD dwNewSize = m_dwZoneCount;
FreeMemory();
AllocateMemory(dwNewSize);
return TRUE;
}
/////////////////////////////////////////////////////////////////////////
// CDNSMTContainerNode
CDNSMTContainerNode::CDNSMTContainerNode()
{
m_pServerNode = NULL;
m_nState = notLoaded;
m_szDescriptionBar = _T("");
m_pColumnSet = NULL;
}
HRESULT CDNSMTContainerNode::OnSetToolbarVerbState(IToolbar* pToolbar,
CNodeList*)
{
HRESULT hr = S_OK;
//
// Set the button state for each button on the toolbar
//
hr = pToolbar->SetButtonState(toolbarNewServer, ENABLED, FALSE);
hr = pToolbar->SetButtonState(toolbarNewZone, ENABLED, FALSE);
hr = pToolbar->SetButtonState(toolbarNewRecord, ENABLED, FALSE);
return hr;
}
LPWSTR CDNSMTContainerNode::GetDescriptionBarText()
{
static CString szFilterEnabled;
if(((CDNSRootData*)GetRootContainer())->IsFilteringEnabled())
{
if (szFilterEnabled.IsEmpty())
{
szFilterEnabled.LoadString(IDS_FILTER_ENABLED);
}
m_szDescriptionBar = szFilterEnabled;
}
else
{
m_szDescriptionBar = _T("");
}
return (LPWSTR)(LPCWSTR)m_szDescriptionBar;
}
int CDNSMTContainerNode::GetImageIndex(BOOL)
{
int nIndex = 0;
switch (m_nState)
{
case notLoaded:
nIndex = FOLDER_IMAGE_NOT_LOADED;
break;
case loading:
nIndex = FOLDER_IMAGE_LOADING;
break;
case loaded:
nIndex = FOLDER_IMAGE_LOADED;
break;
case unableToLoad:
nIndex = FOLDER_IMAGE_UNABLE_TO_LOAD;
break;
case accessDenied:
nIndex = FOLDER_IMAGE_ACCESS_DENIED;
break;
default:
ASSERT(FALSE);
}
return nIndex;
}
void CDNSMTContainerNode::OnChangeState(CComponentDataObject* pComponentDataObject)
{
switch (m_nState)
{
case notLoaded:
case loaded:
case unableToLoad:
case accessDenied:
{
m_nState = loading;
m_dwErr = 0;
}
break;
case loading:
{
if (m_dwErr == 0)
m_nState = loaded;
else if (m_dwErr == ERROR_ACCESS_DENIED)
m_nState = accessDenied;
else
m_nState = unableToLoad;
}
break;
default:
ASSERT(FALSE);
}
VERIFY(SUCCEEDED(pComponentDataObject->ChangeNode(this, CHANGE_RESULT_ITEM_ICON)));
VERIFY(SUCCEEDED(pComponentDataObject->UpdateVerbState(this)));
if (m_nState != loading)
{
pComponentDataObject->UpdateResultPaneView(this);
}
}
BOOL CDNSMTContainerNode::CanCloseSheets()
{
return (IDCANCEL != DNSMessageBox(IDS_MSG_CONT_CLOSE_SHEET, MB_OKCANCEL));
}
void CDNSMTContainerNode::OnHaveData(CObjBase* pObj, CComponentDataObject* pComponentDataObject)
{
CDNSMTContainerNode* p = dynamic_cast<CDNSMTContainerNode*>(pObj);
ASSERT(p != NULL);
if (p != NULL)
{
p->SetServerNode(GetServerNode());
}
AddChildToListAndUI(p, pComponentDataObject);
pComponentDataObject->SetDescriptionBarText(this);
}
void CDNSMTContainerNode::OnError(DWORD dwErr)
{
if (dwErr == ERROR_MORE_DATA)
{
// need to pop message
AFX_MANAGE_STATE(AfxGetStaticModuleState());
CString szFmt;
szFmt.LoadString(IDS_MSG_QUERY_TOO_MANY_ITEMS);
CString szMsg;
szMsg.Format(szFmt, GetDisplayName());
AfxMessageBox(szMsg);
// this is actually a warning, need to reset
dwErr = 0;
}
m_dwErr = dwErr;
}
///////////////////////////////////////////////////////////////////////////////
// CDNSQueryObj : general purpose base class
void CDNSQueryObj::SetFilterOptions(CDNSQueryFilter* pFilter)
{
// limits
m_bGetAll = pFilter->GetAll();
m_nMaxObjectCount = pFilter->GetMaxObjectCount();
// filtering
m_nFilterOption = pFilter->GetFilterOption();
m_szFilterString1 = pFilter->GetFilterString();
m_nFilterStringLen1 = m_szFilterString1.GetLength();
m_szFilterString2 = pFilter->GetFilterStringRange();
m_nFilterStringLen2 = m_szFilterString2.GetLength();
if ((m_nFilterStringLen1 == 0) && (m_nFilterStringLen2 == 0))
m_nFilterOption = DNS_QUERY_FILTER_NONE;
}
BOOL CDNSQueryObj::MatchName(LPCWSTR lpszName)
{
if (m_nFilterOption == DNS_QUERY_FILTER_CONTAINS)
{
//
// wcsstr is case sensitive so make the strings lower
// case before trying to find the substring
//
CString szName = lpszName;
CString szFilterString = m_szFilterString1;
szName.MakeLower();
szFilterString.MakeLower();
LPWSTR lpsz = wcsstr((LPCWSTR)szName, (LPCWSTR)szFilterString);
return (lpsz != NULL);
}
if (m_nFilterOption == DNS_QUERY_FILTER_STARTS)
{
// match at the beginning
size_t nLen = wcslen(lpszName);
if (static_cast<int>(nLen) < m_nFilterStringLen1)
return FALSE; // too short
return (_wcsnicmp(lpszName, (LPCWSTR)m_szFilterString1, m_nFilterStringLen1) == 0);
}
if (m_nFilterOption == DNS_QUERY_FILTER_RANGE)
{
// test lower limit
if (m_nFilterStringLen1 > 0)
{
if (_wcsicmp(lpszName, (LPCWSTR)m_szFilterString1) < 0)
return FALSE; // below range, no need to continue
}
// test upper limit
if (m_nFilterStringLen2 > 0)
{
return _wcsnicmp(lpszName, (LPCWSTR)m_szFilterString2, m_nFilterStringLen2) <= 0;
}
return TRUE;
}
return TRUE;
}
BOOL CDNSQueryObj::TooMuchData()
{
if (m_bGetAll || (m_nObjectCount <= m_nMaxObjectCount))
return FALSE;
TRACE(_T("TooMuchData() m_nObjectCount = %d "), m_nObjectCount);
/*
AFX_MANAGE_STATE(AfxGetStaticModuleState());
CString szFmt;
szFmt.LoadString(IDS_MSG_QUERY_TOO_MANY_ITEMS);
CString szMsg;
szMsg.Format(szFmt, lpszFolderName);
AfxMessageBox(szMsg);
*/
return TRUE;
}
/////////////////////////////////////////////////////////////////////////
// CCathegoryFolderNode
BOOL CCathegoryFolderQueryObj::CanAddZone(PDNS_RPC_ZONE pZoneInfo)
{
// no filtering if cache is selected
if (m_type == cache)
return TRUE;
// no filtering on reverse lookup autocreated zones
if ( (m_type == revAuthoritated) && (pZoneInfo->Flags.AutoCreated))
return TRUE;
// filter on name
return MatchName(pZoneInfo->pszZoneName);
}
BOOL CCathegoryFolderQueryObj::Enumerate()
{
USES_CONVERSION;
DWORD dwFilter = 0;
switch(m_type)
{
case cache:
dwFilter = ZONE_REQUEST_CACHE;
m_bGetAll = TRUE; // no limit on #, to be safe
break;
case fwdAuthoritated:
dwFilter = ZONE_REQUEST_FORWARD |
ZONE_REQUEST_PRIMARY |
ZONE_REQUEST_SECONDARY |
ZONE_REQUEST_STUB;
break;
case revAuthoritated:
dwFilter = ZONE_REQUEST_REVERSE |
ZONE_REQUEST_PRIMARY |
ZONE_REQUEST_SECONDARY |
ZONE_REQUEST_STUB |
ZONE_REQUEST_AUTO;
break;
case domainForwarders:
dwFilter = ZONE_REQUEST_FORWARDER;
break;
}
PDNS_RPC_ZONE_LIST pZoneList = NULL;
DNS_STATUS err = ::DnssrvEnumZones(m_szServerName,
dwFilter,
NULL /*pszLastZone, unused for the moment */,
&pZoneList);
if (err != 0)
{
if (pZoneList != NULL)
::DnssrvFreeZoneList(pZoneList);
OnError(err);
return FALSE;
}
if (!pZoneList)
{
ASSERT(pZoneList);
return FALSE;
}
for (DWORD iZone = 0; iZone < pZoneList->dwZoneCount; iZone++)
{
if (pZoneList->ZoneArray[iZone]->Flags.AutoCreated)
{
// if the zone is autocreated, we cannot count it in the
// filtering limit, because we need it anyway
m_nMaxObjectCount++;
}
else
{
if (TooMuchData())
break;
}
//
// Don't filter the domain forwarders
//
if (m_type != domainForwarders)
{
if (CanAddZone(pZoneList->ZoneArray[iZone]))
{
TRACE(_T("%s\n"),pZoneList->ZoneArray[iZone]->pszZoneName);
CDNSZoneNode* pZoneNode = new CDNSZoneNode();
if (pZoneNode != NULL)
{
pZoneNode->InitializeFromRPCZoneInfo(pZoneList->ZoneArray[iZone], m_bAdvancedView);
VERIFY(AddQueryResult(pZoneNode));
}
}
}
else
{
TRACE(_T("%s\n"),pZoneList->ZoneArray[iZone]->pszZoneName);
CDNSZoneNode* pZoneNode = new CDNSZoneNode();
if (pZoneNode != NULL)
{
pZoneNode->InitializeFromRPCZoneInfo(pZoneList->ZoneArray[iZone], m_bAdvancedView);
VERIFY(AddQueryResult(pZoneNode));
}
}
}
::DnssrvFreeZoneList(pZoneList);
return FALSE;
}
CQueryObj* CCathegoryFolderNode::OnCreateQuery()
{
CDNSRootData* pRootData = (CDNSRootData*)GetRootContainer();
ASSERT(pRootData != NULL);
ASSERT(m_type != CCathegoryFolderQueryObj::unk);
CCathegoryFolderQueryObj* pQuery =
new CCathegoryFolderQueryObj(pRootData->IsAdvancedView(),
GetServerNode()->GetVersion());
pQuery->m_szServerName = GetServerNode()->GetRPCName();
pQuery->SetType(m_type);
return pQuery;
}
HRESULT CCathegoryFolderNode::OnCommand(long nCommandID,
DATA_OBJECT_TYPES,
CComponentDataObject* pComponentData,
CNodeList* pNodeList)
{
if (pNodeList->GetCount() > 1) // multiple selection
{
return E_FAIL;
}
if (nCommandID == IDM_SNAPIN_ADVANCED_VIEW)
{
((CDNSRootData*)pComponentData->GetRootData())->OnViewOptions(pComponentData);
pComponentData->UpdateResultPaneView(this);
return S_OK;
}
if (nCommandID == IDM_SNAPIN_FILTERING)
{
if(((CDNSRootData*)pComponentData->GetRootData())->OnFilteringOptions(pComponentData))
{
pComponentData->SetDescriptionBarText(this);
}
return S_OK;
}
return E_FAIL;
}
BOOL CCathegoryFolderNode::OnAddMenuItem(LPCONTEXTMENUITEM2 pContextMenuItem2,
long*)
{
if (pContextMenuItem2->lCommandID == IDM_SNAPIN_ADVANCED_VIEW)
{
pContextMenuItem2->fFlags = ((CDNSRootData*)GetRootContainer())->IsAdvancedView() ? MF_CHECKED : 0;
}
if (pContextMenuItem2->lCommandID == IDM_SNAPIN_FILTERING)
{
if (((CDNSRootData*)GetRootContainer())->IsFilteringEnabled())
{
pContextMenuItem2->fFlags = MF_CHECKED;
}
return TRUE;
}
return FALSE;
}
BOOL CCathegoryFolderNode::OnSetRefreshVerbState(DATA_OBJECT_TYPES,
BOOL* pbHide,
CNodeList*)
{
*pbHide = FALSE;
return !IsThreadLocked();
}
LPWSTR CCathegoryFolderNode::GetDescriptionBarText()
{
static CString szFilterEnabled;
static CString szZonesFormat;
INT_PTR nContainerCount = GetContainerChildList()->GetCount();
INT_PTR nLeafCount = GetLeafChildList()->GetCount();
//
// If not already loaded, then load the format string L"%d record(s)"
//
if (szZonesFormat.IsEmpty())
{
szZonesFormat.LoadString(IDS_FORMAT_ZONES);
}
//
// Format the child count into the description bar text
//
m_szDescriptionBar.Format(szZonesFormat, nContainerCount + nLeafCount);
//
// Add L"[Filter Activated]" if the filter is on
//
if(((CDNSRootData*)GetRootContainer())->IsFilteringEnabled())
{
//
// If not already loaded, then load the L"[Filter Activated]" string
//
if (szFilterEnabled.IsEmpty())
{
szFilterEnabled.LoadString(IDS_FILTER_ENABLED);
}
m_szDescriptionBar += szFilterEnabled;
}
return (LPWSTR)(LPCWSTR)m_szDescriptionBar;
}
/////////////////////////////////////////////////////////////////////////
// CDNSCacheNode
CDNSCacheNode::CDNSCacheNode()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
m_type = CCathegoryFolderQueryObj::cache;
m_dwNodeFlags |= TN_FLAG_NO_WRITE;
m_szDisplayName.LoadString(IDS_CATHEGORY_FOLDER_CACHE);
}
BOOL CDNSCacheNode::OnAddMenuItem(LPCONTEXTMENUITEM2 pContextMenuItem2,
long*)
{
//we have only one menu item, so no checks
if (IsThreadLocked())
{
pContextMenuItem2->fFlags |= MF_GRAYED;
}
return TRUE;
}
HRESULT CDNSCacheNode::OnCommand(long nCommandID,
DATA_OBJECT_TYPES,
CComponentDataObject* pComponentData,
CNodeList* pNodeList)
{
if (pNodeList->GetCount() > 1) // multiple selection
{
return E_FAIL;
}
switch (nCommandID)
{
case IDM_CACHE_FOLDER_CLEAR_CACHE:
OnClearCache(pComponentData);
break;
default:
ASSERT(FALSE); // Unknown command!
return E_FAIL;
}
return S_OK;
}
void CDNSCacheNode::OnClearCache(CComponentDataObject* pComponentData)
{
ASSERT((GetFlags() & TN_FLAG_HIDDEN) == 0); // must not be hidden
// if there are sheets up, ask to close them down, because
// we will need a refresh
if (IsSheetLocked())
{
if (!CanCloseSheets())
return;
pComponentData->GetPropertyPageHolderTable()->DeleteSheetsOfNode(this);
}
DNS_STATUS err;
{ // scope for the wait cursor
CWaitCursor wait;
err = GetServerNode()->ClearCache();
}
if (err != 0)
{
// need to let the user know the operation failed
DNSErrorDialog(err, IDS_MSG_SERVER_FAIL_CLEAR_CACHE);
return;
}
CNodeList nodeList;
nodeList.AddTail(this);
// the cache has been cleared, cause a refresh to get new data
VERIFY(OnRefresh(pComponentData, &nodeList));
}
/////////////////////////////////////////////////////////////////////////
// CDNSDomainForwardersNode
//
CDNSDomainForwardersNode::CDNSDomainForwardersNode()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
m_type = CCathegoryFolderQueryObj::domainForwarders;
//
// Always hide the domain forwarders node
//
m_dwNodeFlags |= TN_FLAG_HIDDEN;
m_szDisplayName.LoadString(IDS_CATHEGORY_FOLDER_DOMAIN_FORWARDERS);
}
BOOL CDNSDomainForwardersNode::OnEnumerate(CComponentDataObject* pComponentData, BOOL)
{
OnChangeState(pComponentData);
VERIFY(StartBackgroundThread(pComponentData, FALSE));
//
// Now enumerate all the children
//
CNodeList* pContList = GetContainerChildList();
if (pContList != NULL)
{
POSITION pos = pContList->GetHeadPosition();
while (pos != NULL)
{
CDNSZoneNode* pZoneNode = reinterpret_cast<CDNSZoneNode*>(pContList->GetNext(pos));
if (pZoneNode != NULL)
{
//
// Enumerate the zone asynchronously
//
pZoneNode->OnEnumerate(pComponentData);
}
}
}
return FALSE;
}
/////////////////////////////////////////////////////////////////////////
// CDNSAuthoritatedZonesNode
BEGIN_TOOLBAR_MAP(CDNSAuthoritatedZonesNode)
TOOLBAR_EVENT(toolbarNewZone, OnNewZone)
END_TOOLBAR_MAP()
CDNSAuthoritatedZonesNode::CDNSAuthoritatedZonesNode(BOOL bReverse, UINT nStringID)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
m_szDisplayName.LoadString(nStringID);
m_bReverse = bReverse;
m_type = bReverse ? CCathegoryFolderQueryObj::revAuthoritated :
CCathegoryFolderQueryObj::fwdAuthoritated;
}
HRESULT CDNSAuthoritatedZonesNode::OnSetToolbarVerbState(IToolbar* pToolbar,
CNodeList* pNodeList)
{
HRESULT hr = S_OK;
//
// Set the button state for each button on the toolbar
//
hr = pToolbar->SetButtonState(toolbarNewServer, ENABLED, FALSE);
ASSERT(SUCCEEDED(hr));
hr = pToolbar->SetButtonState(toolbarNewRecord, ENABLED, FALSE);
ASSERT(SUCCEEDED(hr));
if (pNodeList->GetCount() > 1) // multiple selection
{
hr = pToolbar->SetButtonState(toolbarNewZone, ENABLED, FALSE);
ASSERT(SUCCEEDED(hr));
}
else if (pNodeList->GetCount() == 1) // single selection
{
hr = pToolbar->SetButtonState(toolbarNewZone, ENABLED, (m_nState == loaded));
ASSERT(SUCCEEDED(hr));
}
return hr;
}
HRESULT CDNSAuthoritatedZonesNode::OnCommand(long nCommandID,
DATA_OBJECT_TYPES,
CComponentDataObject* pComponentData,
CNodeList* pNodeList)
{
HRESULT hr = S_OK;
if (pNodeList->GetCount() > 1) // multiple selection
{
return E_FAIL;
}
switch (nCommandID)
{
case IDM_SERVER_NEW_ZONE:
hr = OnNewZone(pComponentData, pNodeList);
pComponentData->UpdateResultPaneView(this);
break;
case IDM_SNAPIN_ADVANCED_VIEW:
((CDNSRootData*)pComponentData->GetRootData())->OnViewOptions(pComponentData);
pComponentData->UpdateResultPaneView(this);
break;
case IDM_SNAPIN_FILTERING:
{
if (((CDNSRootData*)pComponentData->GetRootData())->OnFilteringOptions(pComponentData))
{
pComponentData->SetDescriptionBarText(this);
}
}
break;
default:
ASSERT(FALSE); // Unknown command!
return E_FAIL;
}
return hr;
};
HRESULT CDNSAuthoritatedZonesNode::OnNewZone(CComponentDataObject* pComponentData, CNodeList*)
{
ASSERT(pComponentData != NULL);
CDNSServerNode* pServerNode = GetServerNode();
ASSERT(pServerNode != NULL);
CDNSZoneWizardHolder holder(pComponentData);
holder.Initialize(pServerNode);
holder.PreSetZoneLookupType(!m_bReverse);
holder.DoModalWizard();
return S_OK;
}
BOOL CDNSAuthoritatedZonesNode::OnAddMenuItem(LPCONTEXTMENUITEM2 pContextMenuItem2,
long*)
{
// gray out commands that need data from the server
if ((m_nState != loaded) && (pContextMenuItem2->lCommandID == IDM_SERVER_NEW_ZONE))
{
pContextMenuItem2->fFlags |= MF_GRAYED;
}
// add toggle menu item for advanced view
if (pContextMenuItem2->lCommandID == IDM_SNAPIN_ADVANCED_VIEW)
{
pContextMenuItem2->fFlags = ((CDNSRootData*)GetRootContainer())->IsAdvancedView() ? MF_CHECKED : 0;
}
if (pContextMenuItem2->lCommandID == IDM_SNAPIN_FILTERING)
{
if (((CDNSRootData*)GetRootContainer())->IsFilteringEnabled())
{
pContextMenuItem2->fFlags = MF_CHECKED;
}
return TRUE;
}
return TRUE;
};
BOOL CDNSAuthoritatedZonesNode::OnSetRefreshVerbState(DATA_OBJECT_TYPES,
BOOL* pbHide,
CNodeList*)
{
*pbHide = FALSE;
return !IsThreadLocked();
}
/////////////////////////////////////////////////////////////////////////
// CDNSForwardZonesNode
CDNSForwardZonesNode::CDNSForwardZonesNode() :
CDNSAuthoritatedZonesNode(FALSE, IDS_CATHEGORY_FOLDER_FWD)
{
}
HRESULT CDNSForwardZonesNode::GetResultViewType(CComponentDataObject*,
LPOLESTR *ppViewType,
long *pViewOptions)
{
HRESULT hr = S_FALSE;
if ((m_containerChildList.IsEmpty() &&
m_leafChildList.IsEmpty()) ||
m_nState == accessDenied ||
m_nState == unableToLoad &&
m_nState != loading &&
m_nState != notLoaded)
{
*pViewOptions = MMC_VIEW_OPTIONS_NOLISTVIEWS;
LPOLESTR psz = NULL;
StringFromCLSID(CLSID_MessageView, &psz);
USES_CONVERSION;
if (psz != NULL)
{
*ppViewType = psz;
hr = S_OK;
}
}
else
{
*pViewOptions = MMC_VIEW_OPTIONS_MULTISELECT;
*ppViewType = NULL;
hr = S_FALSE;
}
return hr;
}
HRESULT CDNSForwardZonesNode::OnShow(LPCONSOLE lpConsole)
{
CComPtr<IUnknown> spUnknown;
CComPtr<IMessageView> spMessageView;
HRESULT hr = lpConsole->QueryResultView(&spUnknown);
if (FAILED(hr))
return S_OK;
hr = spUnknown->QueryInterface(IID_IMessageView, (PVOID*)&spMessageView);
if (SUCCEEDED(hr))
{
CString szTitle, szMessage;
IconIdentifier iconID;
if (m_nState == accessDenied)
{
VERIFY(szTitle.LoadString(IDS_MESSAGE_VIEW_ACCESS_DENIED_TITLE));
VERIFY(szMessage.LoadString(IDS_MESSAGE_VIEW_ACCESS_DENIED_MESSAGE));
iconID = Icon_Error;
}
else if (m_nState == unableToLoad)
{
VERIFY(szTitle.LoadString(IDS_MESSAGE_VIEW_NOT_LOADED_TITLE));
VERIFY(szMessage.LoadString(IDS_MESSAGE_VIEW_NOT_LOADED_MESSAGE));
iconID = Icon_Error;
}
else
{
VERIFY(szTitle.LoadString(IDS_MESSAGE_VIEW_EMPTY_FOLDER_TITLE));
VERIFY(szMessage.LoadString(IDS_MESSAGE_VIEW_EMPTY_FOLDER_MESSAGE));
iconID = Icon_Information;
}
spMessageView->SetTitleText(szTitle);
spMessageView->SetBodyText(szMessage);
spMessageView->SetIcon(iconID);
}
return S_OK;
}
/////////////////////////////////////////////////////////////////////////
// CDNSReverseZonesNode
CDNSReverseZonesNode::CDNSReverseZonesNode() :
CDNSAuthoritatedZonesNode(TRUE, IDS_CATHEGORY_FOLDER_REV)
{
m_p0ZoneNode = NULL;
m_p127ZoneNode = NULL;
m_p255ZoneNode = NULL;
}
BOOL CDNSReverseZonesNode::OnRefresh(CComponentDataObject* pComponentData,
CNodeList* pNodeList)
{
if (pNodeList->GetCount() > 1) // multiple selection
{
return FALSE;
}
if (CDNSAuthoritatedZonesNode::OnRefresh(pComponentData, pNodeList))
{
m_p0ZoneNode = NULL;
m_p127ZoneNode = NULL;
m_p255ZoneNode = NULL;
return TRUE;
}
return FALSE;
}
void CDNSReverseZonesNode::OnHaveData(CObjBase* pObj, CComponentDataObject* pComponentDataObject)
{
// the autocreated zone nodes can be shown or not, depending on the view options
if ( (m_p0ZoneNode == NULL) || (m_p127ZoneNode == NULL) || (m_p255ZoneNode == NULL) &&
IS_CLASS(*pObj, CDNSZoneNode))
{
CDNSZoneNode* pZoneNode = dynamic_cast<CDNSZoneNode*>(pObj);
ASSERT(pZoneNode != NULL); // should never have anything below but zones!!!
if (pZoneNode != NULL)
{
CDNSRootData* pRootData = (CDNSRootData*)pComponentDataObject->GetRootData();
if (pZoneNode->IsAutocreated())
{
BOOL bCachedPointer = FALSE;
if (_wcsicmp(pZoneNode->GetFullName(), AUTOCREATED_0) == 0)
{
ASSERT(m_p0ZoneNode == NULL);
m_p0ZoneNode = pZoneNode;
bCachedPointer = TRUE;
}
else if (_wcsicmp(pZoneNode->GetFullName(), AUTOCREATED_127) == 0)
{
ASSERT(m_p127ZoneNode == NULL);
m_p127ZoneNode = pZoneNode;
bCachedPointer = TRUE;
}
else if (_wcsicmp(pZoneNode->GetFullName(), AUTOCREATED_255) == 0)
{
ASSERT(m_p255ZoneNode == NULL);
m_p255ZoneNode = pZoneNode;
bCachedPointer = TRUE;
}
if (bCachedPointer && !pRootData->IsAdvancedView())
{
pZoneNode->SetFlagsDown(TN_FLAG_HIDDEN,TRUE); // mark it hidden, will not be added to UI
}
}
}
}
CDNSMTContainerNode::OnHaveData(pObj,pComponentDataObject);
}
void CDNSReverseZonesNode::ChangeViewOption(BOOL bAdvanced,
CComponentDataObject* pComponentDataObject)
{
POSITION pos;
for( pos = m_containerChildList.GetHeadPosition(); pos != NULL; )
{
CTreeNode* pCurrentChild = m_containerChildList.GetNext(pos);
CDNSZoneNode* pZoneNode = dynamic_cast<CDNSZoneNode*>(pCurrentChild);
ASSERT(pZoneNode != NULL);
pZoneNode->ChangeViewOption(bAdvanced, pComponentDataObject);
}
if (m_p0ZoneNode != NULL)
m_p0ZoneNode->Show(bAdvanced,pComponentDataObject);
if (m_p127ZoneNode != NULL)
m_p127ZoneNode->Show(bAdvanced,pComponentDataObject);
if (m_p255ZoneNode != NULL)
m_p255ZoneNode->Show(bAdvanced,pComponentDataObject);
}
HRESULT CDNSReverseZonesNode::GetResultViewType(CComponentDataObject*,
LPOLESTR *ppViewType,
long *pViewOptions)
{
HRESULT hr = S_FALSE;
// the 3 refers to the auto-created reverse lookup zones
if ((m_containerChildList.IsEmpty() &&
m_leafChildList.IsEmpty()) ||
(!((CDNSRootData*)GetRootContainer())->IsAdvancedView() && m_containerChildList.GetCount() == 3) ||
m_nState == accessDenied ||
m_nState == unableToLoad &&
m_nState != loading &&
m_nState != notLoaded)
{
*pViewOptions = MMC_VIEW_OPTIONS_NOLISTVIEWS;
LPOLESTR psz = NULL;
StringFromCLSID(CLSID_MessageView, &psz);
USES_CONVERSION;
if (psz != NULL)
{
*ppViewType = psz;
hr = S_OK;
}
}
else
{
*pViewOptions = MMC_VIEW_OPTIONS_MULTISELECT;
*ppViewType = NULL;
hr = S_FALSE;
}
return hr;
}
HRESULT CDNSReverseZonesNode::OnShow(LPCONSOLE lpConsole)
{
CComPtr<IUnknown> spUnknown;
CComPtr<IMessageView> spMessageView;
HRESULT hr = lpConsole->QueryResultView(&spUnknown);
if (FAILED(hr))
return S_OK;
hr = spUnknown->QueryInterface(IID_IMessageView, (PVOID*)&spMessageView);
if (SUCCEEDED(hr))
{
CString szTitle, szMessage;
IconIdentifier iconID;
if (m_nState == accessDenied)
{
VERIFY(szTitle.LoadString(IDS_MESSAGE_VIEW_ACCESS_DENIED_TITLE));
VERIFY(szMessage.LoadString(IDS_MESSAGE_VIEW_ACCESS_DENIED_MESSAGE));
iconID = Icon_Error;
}
else if (m_nState == unableToLoad)
{
VERIFY(szTitle.LoadString(IDS_MESSAGE_VIEW_NOT_LOADED_TITLE));
VERIFY(szMessage.LoadString(IDS_MESSAGE_VIEW_NOT_LOADED_MESSAGE));
iconID = Icon_Error;
}
else
{
VERIFY(szTitle.LoadString(IDS_MESSAGE_VIEW_EMPTY_FOLDER_TITLE));
VERIFY(szMessage.LoadString(IDS_MESSAGE_VIEW_EMPTY_FOLDER_MESSAGE));
iconID = Icon_Information;
}
spMessageView->SetTitleText(szTitle);
spMessageView->SetBodyText(szMessage);
spMessageView->SetIcon(iconID);
}
return S_OK;
}
/////////////////////////////////////////////////////////////////////////
// CDNSServerTestOptions
CDNSServerTestOptions::CDNSServerTestOptions()
{
m_bEnabled = FALSE;
m_dwInterval = DEFAULT_SERVER_TEST_INTERVAL;
m_bSimpleQuery = FALSE;
m_bRecursiveQuery = FALSE;
}
HRESULT CDNSServerTestOptions::Save(IStream* pStm)
{
ULONG cbWrite;
VERIFY(SUCCEEDED(pStm->Write((void*)&m_bEnabled, sizeof(BOOL),&cbWrite)));
ASSERT(cbWrite == sizeof(BOOL));
VERIFY(SUCCEEDED(pStm->Write((void*)&m_dwInterval, sizeof(DWORD),&cbWrite)));
ASSERT(cbWrite == sizeof(DWORD));
VERIFY(SUCCEEDED(pStm->Write((void*)&m_bSimpleQuery, sizeof(BOOL),&cbWrite)));
ASSERT(cbWrite == sizeof(BOOL));
VERIFY(SUCCEEDED(pStm->Write((void*)&m_bRecursiveQuery, sizeof(BOOL),&cbWrite)));
ASSERT(cbWrite == sizeof(BOOL));
return S_OK;
}
HRESULT CDNSServerTestOptions::Load(IStream* pStm)
{
ULONG cbRead;
VERIFY(SUCCEEDED(pStm->Read((void*)&m_bEnabled,sizeof(BOOL), &cbRead)));
ASSERT(cbRead == sizeof(BOOL));
VERIFY(SUCCEEDED(pStm->Read((void*)&m_dwInterval,sizeof(DWORD), &cbRead)));
ASSERT(cbRead == sizeof(DWORD));
VERIFY(SUCCEEDED(pStm->Read((void*)&m_bSimpleQuery,sizeof(BOOL), &cbRead)));
ASSERT(cbRead == sizeof(BOOL));
VERIFY(SUCCEEDED(pStm->Read((void*)&m_bRecursiveQuery,sizeof(BOOL), &cbRead)));
ASSERT(cbRead == sizeof(BOOL));
// force range on test interval
if (m_dwInterval < MIN_SERVER_TEST_INTERVAL)
m_dwInterval = MIN_SERVER_TEST_INTERVAL;
else if (m_dwInterval > MAX_SERVER_TEST_INTERVAL)
m_dwInterval = MAX_SERVER_TEST_INTERVAL;
return S_OK;
}
const CDNSServerTestOptions&
CDNSServerTestOptions::operator=(const CDNSServerTestOptions& x)
{
m_bEnabled = x.m_bEnabled;
m_dwInterval = x.m_dwInterval;
m_bSimpleQuery = x.m_bSimpleQuery;
m_bRecursiveQuery = x.m_bRecursiveQuery;
return *this;
}
BOOL CDNSServerTestOptions::operator==(const CDNSServerTestOptions& x) const
{
if (m_bEnabled != x.m_bEnabled) return FALSE;
if (m_dwInterval != x.m_dwInterval) return FALSE;
if (m_bSimpleQuery != x.m_bSimpleQuery) return FALSE;
if (m_bRecursiveQuery != x.m_bRecursiveQuery) return FALSE;
return TRUE;
}
/////////////////////////////////////////////////////////////////////////
// CDNSServerNode
BEGIN_TOOLBAR_MAP(CDNSServerNode)
TOOLBAR_EVENT(toolbarNewZone, OnNewZone)
END_TOOLBAR_MAP()
// {720132B8-44B2-11d1-B92F-00A0C9A06D2D}
const GUID CDNSServerNode::NodeTypeGUID =
{ 0x720132b8, 0x44b2, 0x11d1, { 0xb9, 0x2f, 0x0, 0xa0, 0xc9, 0xa0, 0x6d, 0x2d } };
CDNSServerNode::CDNSServerNode(LPCTSTR lpszName, BOOL bIsLocalServer)
{
SetServerNode(this);
m_szDisplayName = lpszName;
m_pServInfoEx = new CDNSServerInfoEx;
m_pRootHintsNode = NULL;
m_pCacheFolderNode = NULL;
m_pFwdZonesFolderNode = NULL;
m_pRevZonesFolderNode = NULL;
m_pDomainForwardersFolderNode = NULL;
m_dwTestTime = 0x0;
m_bTestQueryPending = FALSE;
m_bShowMessages = TRUE;
m_bPrevQuerySuccess = TRUE;
m_nStartProppage = -1;
m_bLocalServer = bIsLocalServer;
}
CDNSServerNode::~CDNSServerNode()
{
ASSERT(m_pServInfoEx != NULL);
delete m_pServInfoEx;
FreeRootHints();
//TRACE(_T("~CDNSServerNode(), name <%s>\n"),GetDisplayName());
}
void CDNSServerNode::SetDisplayName(LPCWSTR lpszDisplayName)
{
m_szDisplayName = lpszDisplayName;
}
LPCWSTR CDNSServerNode::GetRPCName()
{
return GetDisplayName();
}
CLIPFORMAT g_cfMachineName = (CLIPFORMAT)RegisterClipboardFormat(L"MMC_SNAPIN_MACHINE_NAME");
CLIPFORMAT g_cfServiceName = (CLIPFORMAT)RegisterClipboardFormat(L"FILEMGMT_SNAPIN_SERVICE_NAME");
CLIPFORMAT g_cfServiceDisplayName = (CLIPFORMAT)RegisterClipboardFormat(L"FILEMGMT_SNAPIN_SERVICE_DISPLAYNAME");
CLIPFORMAT g_cfFramewrkDataObjectType = (CLIPFORMAT)RegisterClipboardFormat(L"FRAMEWRK_DATA_OBJECT_TYPE");
CLIPFORMAT g_cfEventViewer = (CLIPFORMAT)RegisterClipboardFormat(L"CF_EV_VIEWS");
HRESULT CDNSServerNode::GetDataHere(CLIPFORMAT cf, LPSTGMEDIUM lpMedium,
CDataObject* pDataObject)
{
ASSERT(pDataObject != NULL);
HRESULT hr = DV_E_CLIPFORMAT;
if (cf == g_cfMachineName)
{
LPCWSTR pwszMachineName = GetDisplayName();
hr = pDataObject->Create(pwszMachineName, BYTE_MEM_LEN_W(pwszMachineName), lpMedium);
}
else if (cf == g_cfServiceName)
{
LPCWSTR pwszServiceName = _T("DNS");
hr = pDataObject->Create(pwszServiceName, BYTE_MEM_LEN_W(pwszServiceName), lpMedium);
}
else if (cf == g_cfServiceDisplayName)
{
LPCWSTR pwszServiceDisplayName = _T("Microsoft DNS Server");
hr = pDataObject->Create(pwszServiceDisplayName, BYTE_MEM_LEN_W(pwszServiceDisplayName), lpMedium);
}
else if (cf == g_cfFramewrkDataObjectType)
{
DATA_OBJECT_TYPES type = pDataObject->GetType();
hr = pDataObject->Create(&type, sizeof(DATA_OBJECT_TYPES), lpMedium);
}
return hr;
}
HRESULT CDNSServerNode::GetData(CLIPFORMAT cf, LPSTGMEDIUM lpMedium, CDataObject* pDataObject)
{
ASSERT(pDataObject != NULL);
HRESULT hr = DV_E_CLIPFORMAT;
if (cf == g_cfEventViewer)
{
hr = RetrieveEventViewerLogs(lpMedium, pDataObject);
}
return hr;
}
//
// Macros and #defines for event viewer clipformats
//
#define ELT_SYSTEM 101
#define ELT_SECURITY 102
#define ELT_APPLICATION 103
#define ELT_CUSTOM 104
#define VIEWINFO_BACKUP 0x0001
#define VIEWINFO_FILTERED 0x0002
#define VIEWINFO_LOW_SPEED 0x0004
#define VIEWINFO_USER_CREATED 0x0008
#define VIEWINFO_ALLOW_DELETE 0x0100
#define VIEWINFO_DISABLED 0x0200
#define VIEWINFO_READ_ONLY 0x0400
#define VIEWINFO_DONT_PERSIST 0x0800
#define VIEWINFO_CUSTOM ( VIEWINFO_FILTERED | VIEWINFO_DONT_PERSIST | \
VIEWINFO_ALLOW_DELETE | VIEWINFO_USER_CREATED)
#define EV_ALL_ERRORS (EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | \
EVENTLOG_INFORMATION_TYPE | EVENTLOG_AUDIT_SUCCESS | \
EVENTLOG_AUDIT_FAILURE)
// Make sure that the data is processor aligned
#if defined(_X86_)
#define _RNDUP(p,m) (p)
#else
#define _RNDUP(p,m) (BYTE *)(((ULONG_PTR)(p) + (m) - 1) & ~((m) - 1))
#endif
#define ADD_TYPE(data, type) \
pPos = _RNDUP(pPos, (ULONG_PTR) __alignof(type)); \
*((type*)pPos) = (type)(data); \
pPos += sizeof(type)
#define ADD_USHORT(us) ADD_TYPE(us, USHORT)
#define ADD_BOOL(b) ADD_TYPE(b, BOOL)
#define ADD_ULONG(ul) ADD_TYPE(ul, ULONG)
#define ADD_STRING(str) \
strLength = wcslen((LPCWSTR)(str)) + 1; \
ADD_USHORT(strLength); \
wcsncpy((LPWSTR)pPos, (LPCWSTR)(str), strLength); \
pPos += strLength * sizeof(WCHAR);
HRESULT CDNSServerNode::RetrieveEventViewerLogs(LPSTGMEDIUM lpMedium, CDataObject*)
{
HRESULT hr = S_OK;
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HGLOBAL hMem = ::GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, 1024 );
if( NULL == hMem )
{
return STG_E_MEDIUMFULL;
}
//
// Get a pointer to our data
//
BYTE* pPos = reinterpret_cast<BYTE*>(::GlobalLock(hMem));
if (!pPos)
{
return HRESULT_FROM_WIN32(GetLastError());
}
size_t strLength = 0;
//
// Build the path to the event log
//
CString szDNSEventPath;
CString szConfigPath;
CString szServerName = L"\\\\";
szServerName += GetDisplayName();
szConfigPath += szServerName;
szConfigPath += L"\\Admin$\\System32\\config\\";
szDNSEventPath = szConfigPath;
szDNSEventPath += L"DNSEvent.Evt";
//
// Add header info
//
ADD_BOOL( TRUE ); // fOnlyTheseViews
ADD_USHORT( 1 ); // cViews
//
// Add application log filtered for our services
//
ADD_ULONG( ELT_CUSTOM ); // Type; ELT_CUSTOM
ADD_USHORT( VIEWINFO_CUSTOM ); // flViewFlags: VIEWINFO_FILTERED
ADD_STRING( GetDisplayName() ); // ServerName
ADD_STRING( L"DNS Server" ); // SourceName
ADD_STRING( szDNSEventPath ); // FileName
ADD_STRING( L"DNS Events" ); // DisplayName REVIEW_JEFFJON : this needs to be put in the rc file
ADD_ULONG( EV_ALL_ERRORS );// flRecType (could filter warning, error, etc.)
ADD_USHORT( 0 ); // usCategory
ADD_BOOL( FALSE ); // fEventID
ADD_ULONG( 0 ); // ulEventID
ADD_STRING( L"" ); // szSourceName
ADD_STRING( L"" ); // szUser
ADD_STRING( L"" ); // szComputer
ADD_ULONG( 0 ); // ulFrom
ADD_ULONG( 0 ); // ulTo
::GlobalUnlock( hMem ); // Unlock and set the rest of the
lpMedium->hGlobal = hMem; // StgMedium variables
lpMedium->tymed = TYMED_HGLOBAL;
lpMedium->pUnkForRelease = NULL;
return hr;
}
void CDNSServerNode::ChangeViewOption(BOOL bAdvanced, CComponentDataObject* pComponentData)
{
//
// changes in record options
//
SetFlagsOnNonContainers(TN_FLAG_DNS_RECORD_FULL_NAME , !bAdvanced);
//
//pComponentData->RepaintResultPane(this);
//
pComponentData->RepaintSelectedFolderInResultPane();
//
// Cached Lookup Folder
//
if (m_pCacheFolderNode != NULL)
{
m_pCacheFolderNode->Show(bAdvanced,pComponentData);
}
//
// Auto Created Zones
//
if (m_pRevZonesFolderNode != NULL)
{
m_pRevZonesFolderNode->ChangeViewOption(bAdvanced, pComponentData);
}
}
CDNSAuthoritatedZonesNode* CDNSServerNode::GetAuthoritatedZoneFolder(BOOL bFwd)
{
return bFwd ? (CDNSAuthoritatedZonesNode*)m_pFwdZonesFolderNode :
(CDNSAuthoritatedZonesNode*)m_pRevZonesFolderNode;
}
HRESULT CDNSServerNode::OnSetToolbarVerbState(IToolbar* pToolbar,
CNodeList* pNodeList)
{
HRESULT hr = S_OK;
//
// Set the button state for each button on the toolbar
//
hr = pToolbar->SetButtonState(toolbarNewServer, ENABLED, FALSE);
ASSERT(SUCCEEDED(hr));
hr = pToolbar->SetButtonState(toolbarNewRecord, ENABLED, FALSE);
ASSERT(SUCCEEDED(hr));
if (pNodeList->GetCount() > 1) // multiple selection
{
hr = pToolbar->SetButtonState(toolbarNewZone, ENABLED, FALSE);
ASSERT(SUCCEEDED(hr));
}
else if (pNodeList->GetCount() == 1) // single selection
{
hr = pToolbar->SetButtonState(toolbarNewZone, ENABLED, (m_nState == loaded));
}
return hr;
}
HRESULT CDNSServerNode::OnCommand(long nCommandID,
DATA_OBJECT_TYPES,
CComponentDataObject* pComponentData,
CNodeList* pNodeList)
{
HRESULT hr = S_OK;
if (pNodeList->GetCount() == 1) // single selection
{
switch (nCommandID)
{
case IDM_SERVER_NEW_ZONE:
hr = OnNewZone(pComponentData, pNodeList);
break;
case IDM_SERVER_UPDATE_DATA_FILES:
OnUpdateDataFiles(pComponentData);
break;
case IDM_SERVER_CLEAR_CACHE:
OnClearCache(pComponentData);
break;
case IDM_SNAPIN_ADVANCED_VIEW:
((CDNSRootData*)pComponentData->GetRootData())->OnViewOptions(pComponentData);
break;
case IDM_SNAPIN_MESSAGE:
m_bShowMessages = !m_bShowMessages;
pComponentData->UpdateResultPaneView(this);
break;
case IDM_SNAPIN_FILTERING:
{
if (((CDNSRootData*)pComponentData->GetRootData())->OnFilteringOptions(pComponentData))
{
pComponentData->SetDescriptionBarText(this);
}
}
break;
case IDM_SERVER_SET_AGING:
SetRecordAging();
break;
case IDM_SERVER_SCAVENGE:
ScavengeRecords();
break;
case IDM_SERVER_CONFIGURE:
OnConfigureServer(pComponentData);
break;
#ifdef USE_NDNC
case IDM_SERVER_CREATE_NDNC:
OnCreateNDNC();
break;
#endif
default:
ASSERT(FALSE); // Unknown command!
hr = E_FAIL;
}
}
else
{
hr = E_FAIL;
}
return hr;
}
#ifdef USE_NDNC
void CDNSServerNode::OnCreateNDNC()
{
// First ask if they want to create the domain NDNC
USES_CONVERSION;
do
{
DNS_STATUS err = 0;
CString szDomainNDNC;
szDomainNDNC.Format(IDS_SERVER_CREATE_DOMAIN_NDNC_FORMAT, UTF8_TO_W(GetDomainName()));
UINT nResult = DNSMessageBox(szDomainNDNC, MB_YESNOCANCEL | MB_ICONWARNING);
if (IDCANCEL == nResult)
{
// don't do anything more
break;
}
else if (IDYES == nResult)
{
// create the domain partition
err = ::DnssrvSetupDefaultDirectoryPartitions(
GetRPCName(),
DNS_DP_OP_CREATE_DOMAIN);
if (err != 0)
{
DNSErrorDialog(err, IDS_ERRMSG_CREATE_DOMAIN_NDNC);
break;
}
}
CString szForestNDNC;
szForestNDNC.Format(IDS_SERVER_CREATE_FOREST_NDNC_FORMAT, UTF8_TO_W(GetForestName()));
nResult = DNSMessageBox(szForestNDNC, MB_YESNO | MB_ICONWARNING);
if (IDYES == nResult)
{
// create the forest partition
err = ::DnssrvSetupDefaultDirectoryPartitions(
GetRPCName(),
DNS_DP_OP_CREATE_FOREST);
if (err != 0)
{
DNSErrorDialog(err, IDS_ERRMSG_CREATE_FOREST_NDNC);
break;
}
}
} while (false);
}
#endif // USE_NDNC
void CDNSServerNode::OnConfigureServer(CComponentDataObject* pComponentData)
{
CDNSServerWizardHolder holder((CDNSRootData*)GetRootContainer(), pComponentData, this);
holder.DoModalWizard();
pComponentData->UpdateResultPaneView(this);
}
void CDNSServerNode::SetRecordAging()
{
CDNSZone_AgingDialog dlg(NULL, IDD_SERVER_AGING_DIALOG, ((CDNSRootData*)GetRootContainer())->GetComponentDataObject());
dlg.m_dwRefreshInterval = GetDefaultRefreshInterval();
dlg.m_dwNoRefreshInterval = GetDefaultNoRefreshInterval();
dlg.m_fScavengingEnabled = GetDefaultScavengingState();
dlg.m_dwDefaultRefreshInterval = GetDefaultRefreshInterval();
dlg.m_dwDefaultNoRefreshInterval = GetDefaultNoRefreshInterval();
dlg.m_bDefaultScavengingState = GetDefaultScavengingState();
if (IDCANCEL == dlg.DoModal())
{
return;
}
DNS_STATUS dwErr;
if (dlg.m_dwRefreshInterval != GetDefaultRefreshInterval())
{
dwErr = ResetDefaultRefreshInterval(dlg.m_dwRefreshInterval);
if (dwErr != 0)
{
DNSErrorDialog(dwErr, IDS_MSG_SERVER_UPDATE_AGING);
return;
}
}
if (dlg.m_dwNoRefreshInterval != GetDefaultNoRefreshInterval())
{
dwErr = ResetDefaultNoRefreshInterval(dlg.m_dwNoRefreshInterval);
if (dwErr != 0)
{
DNSErrorDialog(dwErr, IDS_MSG_SERVER_UPDATE_AGING);
return;
}
}
if (dlg.m_fScavengingEnabled != GetDefaultScavengingState())
{
DWORD dwScavengingState = DNS_AGING_OFF;
if (dlg.m_fScavengingEnabled)
{
dwScavengingState = DNS_AGING_DS_ZONES;
}
dwErr = ResetDefaultScavengingState(dwScavengingState);
if (dwErr != 0)
{
DNSErrorDialog(dwErr, IDS_MSG_SERVER_UPDATE_AGING);
return;
}
}
BOOL bApplyAll = dlg.m_bADApplyAll;
if (bApplyAll)
{
DWORD dwContextFlags = ZONE_REQUEST_PRIMARY;
dwContextFlags = dlg.m_bADApplyAll ? dwContextFlags | ZONE_REQUEST_DS : dwContextFlags;
if (dlg.m_bNoRefreshDirty)
{
dwErr = ::DnssrvResetDwordPropertyWithContext(GetRPCName(),
DNS_ZONE_ALL,
dwContextFlags,
DNS_REGKEY_ZONE_NOREFRESH_INTERVAL,
dlg.m_dwNoRefreshInterval);
if (dwErr != 0)
{
DNSErrorDialog(dwErr, IDS_MSG_SERVER_UPDATE_AGING);
return;
}
}
if (dlg.m_bRefreshDirty)
{
dwErr = ::DnssrvResetDwordPropertyWithContext(GetRPCName(),
DNS_ZONE_ALL,
dwContextFlags,
DNS_REGKEY_ZONE_REFRESH_INTERVAL,
dlg.m_dwRefreshInterval);
if (dwErr != 0)
{
DNSErrorDialog(dwErr, IDS_MSG_SERVER_UPDATE_AGING);
return;
}
}
if (dlg.m_bScavengeDirty)
{
dwErr = ::DnssrvResetDwordPropertyWithContext(GetRPCName(),
DNS_ZONE_ALL,
dwContextFlags,
DNS_REGKEY_ZONE_AGING,
dlg.m_fScavengingEnabled);
if (dwErr != 0)
{
DNSErrorDialog(dwErr, IDS_MSG_SERVER_UPDATE_AGING);
return;
}
}
}
}
void CDNSServerNode::ScavengeRecords()
{
UINT nRet = DNSConfirmOperation(IDS_MSG_SERVER_CONFIRM_SCAVENGE, this);
if(IDCANCEL == nRet ||
IDNO == nRet)
{
return;
}
DNS_STATUS dwErr = ::DnssrvOperation(GetRPCName(),
NULL,
DNSSRV_OP_START_SCAVENGING,
DNSSRV_TYPEID_NULL,
NULL);
if (dwErr != 0)
{
DNSErrorDialog(dwErr, IDS_MSG_ERROR_SCAVENGE_RECORDS);
return;
}
}
int CDNSServerNode::GetImageIndex(BOOL)
{
BOOL bSuccess = m_testResultList.LastQuerySuceeded();
int nIndex = 0;
switch (m_nState)
{
case notLoaded:
nIndex = bSuccess ? SERVER_IMAGE_NOT_LOADED : SERVER_IMAGE_NOT_LOADED_TEST_FAIL;
break;
case loading:
nIndex = bSuccess ? SERVER_IMAGE_LOADING : SERVER_IMAGE_LOADING_TEST_FAIL;
break;
case loaded:
nIndex = bSuccess ? SERVER_IMAGE_LOADED : SERVER_IMAGE_LOADED_TEST_FAIL;
break;
case unableToLoad:
nIndex = bSuccess ? SERVER_IMAGE_UNABLE_TO_LOAD : SERVER_IMAGE_UNABLE_TO_LOAD_TEST_FAIL;
break;
case accessDenied:
nIndex = bSuccess ? SERVER_IMAGE_ACCESS_DENIED : SERVER_IMAGE_ACCESS_DENIED_TEST_FAIL;
break;
default:
ASSERT(FALSE);
}
return nIndex;
}
void CDNSServerNode::OnDelete(CComponentDataObject* pComponentData,
CNodeList* pNodeList)
{
if (pNodeList->GetCount() > 1) // multiple selection
{
return;
}
UINT nRet = DNSConfirmOperation(IDS_MSG_SERVER_DELETE, this);
if (IDCANCEL == nRet ||
IDNO == nRet)
{
return;
}
if (IsSheetLocked())
{
if (!CanCloseSheets())
return;
pComponentData->GetPropertyPageHolderTable()->DeleteSheetsOfNode(this);
}
ASSERT(!IsSheetLocked());
// now remove from the UI and from the cache
DeleteHelper(pComponentData);
CDNSRootData* pSnapinData = (CDNSRootData*)GetRootContainer();
pSnapinData->SetDirtyFlag(TRUE);
pSnapinData->RemoveServerFromThreadList(this, pComponentData);
pComponentData->UpdateResultPaneView(GetContainer());
delete this; // gone
}
#define MAX_COMPUTER_DISPLAYNAME_LENGTH 256
HRESULT CDNSServerNode::CreateFromStream(IStream* pStm, CDNSServerNode** ppServerNode)
{
WCHAR szBuffer[MAX_COMPUTER_DISPLAYNAME_LENGTH];
ULONG nLen; // WCHAR counting NULL
ULONG cbRead;
VERIFY(SUCCEEDED(pStm->Read((void*)&nLen,sizeof(UINT), &cbRead)));
ASSERT(cbRead == sizeof(UINT));
VERIFY(SUCCEEDED(pStm->Read((void*)szBuffer,sizeof(WCHAR)*nLen, &cbRead)));
ASSERT(cbRead == sizeof(WCHAR)*nLen);
BOOL bIsLocalHost = (_wcsicmp(szBuffer, L"localhost.") == 0);
if (bIsLocalHost)
{
//
// Retrieve the local computer name
//
DWORD dwLen = MAX_COMPUTER_DISPLAYNAME_LENGTH;
BOOL bRes = ::GetComputerName(szBuffer, &dwLen);
ASSERT(bRes);
}
*ppServerNode = new CDNSServerNode(szBuffer, bIsLocalHost);
ASSERT(*ppServerNode != NULL);
VERIFY(SUCCEEDED((*ppServerNode)->m_testOptions.Load(pStm)));
return S_OK;
}
HRESULT CDNSServerNode::SaveToStream(IStream* pStm)
{
// for each server name, write # of chars+NULL, and then the name
ULONG cbWrite = 0;
ULONG nLen = 0;
static PCWSTR pszLocalHost = L"localhost.";
if (IsLocalServer())
{
nLen = static_cast<ULONG>(wcslen(pszLocalHost) + 1);
VERIFY(SUCCEEDED(pStm->Write((void*)&nLen, sizeof(UINT),&cbWrite)));
ASSERT(cbWrite == sizeof(UINT));
VERIFY(SUCCEEDED(pStm->Write((void*)(pszLocalHost), sizeof(WCHAR)*nLen,&cbWrite)));
ASSERT(cbWrite == sizeof(WCHAR)*nLen);
}
else
{
nLen = static_cast<ULONG>(wcslen(GetDisplayName())+1); // WCHAR including NULL
VERIFY(SUCCEEDED(pStm->Write((void*)&nLen, sizeof(UINT),&cbWrite)));
ASSERT(cbWrite == sizeof(UINT));
VERIFY(SUCCEEDED(pStm->Write((void*)(GetDisplayName()), sizeof(WCHAR)*nLen,&cbWrite)));
ASSERT(cbWrite == sizeof(WCHAR)*nLen);
}
VERIFY(SUCCEEDED(m_testOptions.Save(pStm)));
return S_OK;
}
HRESULT CDNSServerNode::OnNewZone(CComponentDataObject* pComponentData, CNodeList*)
{
ASSERT(pComponentData != NULL);
ASSERT(pComponentData != NULL);
CDNSZoneWizardHolder holder(pComponentData);
holder.Initialize(this);
holder.DoModalWizard();
return S_OK;
}
void CDNSServerNode::OnUpdateDataFiles(CComponentDataObject* pComponentData)
{
// if there are sheets up, ask to close them down, because a
// failure would "Red X" the server and remove all the children
if (IsSheetLocked())
{
if (!CanCloseSheets())
return;
pComponentData->GetPropertyPageHolderTable()->DeleteSheetsOfNode(this);
}
OnChangeState(pComponentData); // move to loading
m_dwErr = WriteDirtyZones();
// if there is a failure, remove all children,
// will need a refresh to get them back
if (m_dwErr != 0)
{
RemoveAllChildrenHelper(pComponentData);
ASSERT(!HasChildren());
}
OnChangeState(pComponentData); // move to loaded or unableToLoad
}
void CDNSServerNode::OnClearCache(CComponentDataObject* pComponentData)
{
// if there is a cache folder and it is not hidden, delegate to it
if ((m_pCacheFolderNode != NULL) && ((m_pCacheFolderNode->GetFlags() & TN_FLAG_HIDDEN) == 0))
{
m_pCacheFolderNode->OnClearCache(pComponentData);
return;
}
// directly call into the server
DNS_STATUS err;
{ // scope for wait cursor
CWaitCursor wait;
err = ClearCache();
}
if (err != 0)
{
// need to let the user know the operation failed
DNSErrorDialog(err, IDS_MSG_SERVER_FAIL_CLEAR_CACHE);
return;
}
if (m_pCacheFolderNode != NULL)
{
ASSERT(m_pCacheFolderNode->GetFlags() & TN_FLAG_HIDDEN);
// the cache folder is there, but hidden, so we just have
// to call the API and remove its children
m_pCacheFolderNode->RemoveAllChildrenFromList();
}
}
BOOL CDNSServerNode::HasPropertyPages(DATA_OBJECT_TYPES,
BOOL* pbHideVerb,
CNodeList* pNodeList)
{
if (pNodeList->GetCount() > 1) // multiple selection
{
return FALSE;
}
*pbHideVerb = FALSE; // always show the verb
// cannot have property pages when in loading, notLoaded, or the thread lock state
return (!IsThreadLocked() && (m_nState != notLoaded) && (m_nState != loading));
}
HRESULT CDNSServerNode::CreatePropertyPages(LPPROPERTYSHEETCALLBACK lpProvider,
LONG_PTR handle,
CNodeList* pNodeList)
{
CWaitCursor wait;
ASSERT(pNodeList->GetCount() == 1); // multi-select not support
ASSERT(m_nState != loading);
CComponentDataObject* pComponentDataObject =
((CRootData*)(GetContainer()->GetRootContainer()))->GetComponentDataObject();
ASSERT(pComponentDataObject != NULL);
//
// Refresh the domain forwarders node under the server so that it has current data,
// but do it manually since we have to enumerate synchronously
//
CDNSDomainForwardersNode* pDomainForwardersNode = GetDomainForwardersNode();
if (pDomainForwardersNode != NULL)
{
pDomainForwardersNode->RemoveAllChildrenHelper(pComponentDataObject);
pDomainForwardersNode->OnEnumerate(pComponentDataObject, FALSE);
}
if (m_pServInfoEx != NULL)
{
VERIFY(m_pServInfoEx->Query(GetRPCName()) == 0);
}
CDNSServerPropertyPageHolder* pHolder =
new CDNSServerPropertyPageHolder((CDNSRootData*)GetContainer(), this, pComponentDataObject);
ASSERT(pHolder != NULL);
pHolder->SetStartPageCode(m_nStartProppage);
pHolder->SetSheetTitle(IDS_PROP_SHEET_TITLE_FMT, this);
return pHolder->CreateModelessSheet(lpProvider, handle);
}
void CDNSServerNode::DecrementSheetLockCount()
{
CTreeNode::DecrementSheetLockCount();
m_nStartProppage = -1;
}
BOOL CDNSServerQueryObj::Enumerate()
{
// query the server to find out if it has a cache
BOOL bHasRootZone = FALSE;
DNS_STATUS err = ::ServerHasRootZone(m_szServerName, &bHasRootZone);
if (err != 0)
{
OnError(err);
return FALSE; // failed to get answer
}
CDNSRootHintsNode* pRootHintsNode = NULL;
// if there is not a root zone, the server is not authoritated for the root
// so create the root hints folder and ask it to query for NS and A records
if (!bHasRootZone)
{
pRootHintsNode = new CDNSRootHintsNode;
err = pRootHintsNode->QueryForRootHints(m_szServerName, m_dwServerVersion);
if (err != 0)
{
//
// NOTE: permissions are different for the Root Hints so we will
// fail this silently
//
// OnError(err);
delete pRootHintsNode;
pRootHintsNode = NULL;
// return FALSE; // failed in the query, exit without putting folders
}
}
// get server info
CDNSServerInfoEx* pServerInfoEx = new CDNSServerInfoEx;
err = pServerInfoEx->Query(m_szServerName);
if (err != 0)
{
OnError(err);
delete pServerInfoEx;
pServerInfoEx = NULL;
if (pRootHintsNode != NULL)
{
delete pRootHintsNode;
pRootHintsNode = NULL;
}
return FALSE; // stop if could not get server info
}
// all went well, finally send data
VERIFY(AddQueryResult(pServerInfoEx)); // server info data
if (!bHasRootZone)
{
ASSERT(pRootHintsNode != NULL);
VERIFY(AddQueryResult(pRootHintsNode));
}
//
// create cache data folder
//
VERIFY(AddQueryResult(new CDNSCacheNode));
//
// create the fwd/rev lookup zones folders
//
VERIFY(AddQueryResult(new CDNSForwardZonesNode));
VERIFY(AddQueryResult(new CDNSReverseZonesNode));
//
// Always add the domain forwarders folder here so that it can be enumerated immediately
//
VERIFY(AddQueryResult(new CDNSDomainForwardersNode));
return FALSE; // end thread
}
HRESULT CDNSServerNode::GetResultViewType(CComponentDataObject*,
LPOLESTR *ppViewType,
long *pViewOptions)
{
HRESULT hr = S_FALSE;
if ((!IsServerConfigured() ||
m_nState == accessDenied ||
m_nState == unableToLoad ||
!m_testResultList.LastQuerySuceeded()) &&
m_bShowMessages)
{
*pViewOptions = MMC_VIEW_OPTIONS_NOLISTVIEWS;
LPOLESTR psz = NULL;
StringFromCLSID(CLSID_MessageView, &psz);
USES_CONVERSION;
if (psz != NULL)
{
*ppViewType = psz;
hr = S_OK;
}
}
else
{
*pViewOptions = MMC_VIEW_OPTIONS_NONE;
*ppViewType = NULL;
hr = S_FALSE;
}
return hr;
}
HRESULT CDNSServerNode::OnShow(LPCONSOLE lpConsole)
{
CComPtr<IUnknown> spUnknown;
CComPtr<IMessageView> spMessageView;
HRESULT hr = lpConsole->QueryResultView(&spUnknown);
if (FAILED(hr))
return S_OK;
hr = spUnknown->QueryInterface(IID_IMessageView, (PVOID*)&spMessageView);
if (SUCCEEDED(hr))
{
CString szTitle, szMessage;
IconIdentifier iconID;
if (!IsServerConfigured())
{
VERIFY(szTitle.LoadString(IDS_MESSAGE_VIEW_CONFIG_SERVER_TITLE));
VERIFY(szMessage.LoadString(IDS_MESSAGE_VIEW_CONFIG_SERVER_MESSAGE));
iconID = Icon_Information;
}
else if (m_testResultList.LastQuerySuceeded())
{
if (m_nState == accessDenied)
{
VERIFY(szTitle.LoadString(IDS_MESSAGE_VIEW_ACCESS_DENIED_TITLE));
VERIFY(szMessage.LoadString(IDS_MESSAGE_VIEW_ACCESS_DENIED_MESSAGE));
iconID = Icon_Error;
}
else // Unable to load and other unknown errors
{
VERIFY(szTitle.LoadString(IDS_MESSAGE_VIEW_NOT_LOADED_TITLE));
VERIFY(szMessage.LoadString(IDS_MESSAGE_VIEW_NOT_LOADED_MESSAGE));
iconID = Icon_Error;
}
}
else
{
VERIFY(szTitle.LoadString(IDS_MESSAGE_VIEW_QUERY_FAILED_TITLE));
VERIFY(szMessage.LoadString(IDS_MESSAGE_VIEW_QUERY_FAILED_MESSAGE));
iconID = Icon_Error;
}
spMessageView->SetTitleText(szTitle);
spMessageView->SetBodyText(szMessage);
spMessageView->SetIcon(iconID);
}
return S_OK;
}
CQueryObj* CDNSServerNode::OnCreateQuery()
{
CDNSRootData* pRootData = (CDNSRootData*)GetRootContainer();
ASSERT(pRootData != NULL);
CDNSServerQueryObj* pQuery =
new CDNSServerQueryObj(pRootData->IsAdvancedView(), 0x0 /*version not known yet*/);
pQuery->m_szServerName = m_szDisplayName;
return pQuery;
}
BOOL CDNSServerNode::OnRefresh(CComponentDataObject* pComponentData,
CNodeList* pNodeList)
{
if (pNodeList->GetCount() > 1) // multiple selection
{
BOOL bRet = TRUE;
POSITION pos = pNodeList->GetHeadPosition();
while (pos != NULL)
{
CTreeNode* pNode = pNodeList->GetNext(pos);
ASSERT(pNode != NULL);
CNodeList nodeList;
nodeList.AddTail(pNode);
if (!pNode->OnRefresh(pComponentData, &nodeList))
{
bRet = FALSE;
}
}
return bRet;
}
//
// Single selections
//
if (CMTContainerNode::OnRefresh(pComponentData, pNodeList))
{
m_pCacheFolderNode = NULL;
m_pFwdZonesFolderNode = NULL;
m_pRevZonesFolderNode = NULL;
m_pDomainForwardersFolderNode = NULL;
FreeRootHints();
FreeServInfo();
return TRUE;
}
return FALSE;
}
void CDNSServerNode::OnHaveData(CObjBase* pObj, CComponentDataObject* pComponentDataObject)
{
// the first message coming should be server info struct, not kept in the list of children
if (IS_CLASS(*pObj, CDNSServerInfoEx))
{
AttachServerInfo(dynamic_cast<CDNSServerInfoEx*>(pObj));
return;
}
// the root hints node is special and not kept in the list of children
if (IS_CLASS(*pObj, CDNSRootHintsNode))
{
CDNSRootHintsNode* pNewRootHints = dynamic_cast<CDNSRootHintsNode*>(pObj);
if (pNewRootHints != NULL)
{
AttachRootHints(pNewRootHints);
}
ASSERT(m_pRootHintsNode != NULL);
return;
}
// set cached pointers for fdw/rev zones folders
if (IS_CLASS(*pObj, CDNSForwardZonesNode))
{
ASSERT(m_pFwdZonesFolderNode == NULL);
m_pFwdZonesFolderNode = dynamic_cast<CDNSForwardZonesNode*>(pObj);
ASSERT(m_pFwdZonesFolderNode != NULL);
}
else if (IS_CLASS(*pObj, CDNSReverseZonesNode))
{
ASSERT(m_pRevZonesFolderNode == NULL);
m_pRevZonesFolderNode = dynamic_cast<CDNSReverseZonesNode*>(pObj);
ASSERT(m_pRevZonesFolderNode != NULL);
}
else if (IS_CLASS(*pObj, CDNSCacheNode))
{
//
// the cache folder node can be shown or not, depending on the view options
//
ASSERT(m_pCacheFolderNode == NULL);
m_pCacheFolderNode = dynamic_cast<CDNSCacheNode*>(pObj);
ASSERT(m_pCacheFolderNode != NULL);
CDNSRootData* pRootData = (CDNSRootData*)pComponentDataObject->GetRootData();
if (!pRootData->IsAdvancedView())
{
m_pCacheFolderNode->SetFlagsDown(TN_FLAG_HIDDEN,TRUE); // mark it hidden, will not be added to UI
}
}
else if (IS_CLASS(*pObj, CDNSDomainForwardersNode))
{
//
// The domain forwarders node should never be shown
//
ASSERT(m_pDomainForwardersFolderNode == NULL);
m_pDomainForwardersFolderNode = dynamic_cast<CDNSDomainForwardersNode*>(pObj);
ASSERT(m_pDomainForwardersFolderNode != NULL);
//
// Make sure its hidden in the UI
//
m_pDomainForwardersFolderNode->SetFlagsDown(TN_FLAG_HIDDEN, TRUE);
}
CDNSMTContainerNode::OnHaveData(pObj,pComponentDataObject);
}
BOOL CDNSServerNode::OnAddMenuItem(LPCONTEXTMENUITEM2 pContextMenuItem2,
long*)
{
// gray out commands that need data from the server
if ((m_nState != loaded) && ( (pContextMenuItem2->lCommandID == IDM_SERVER_NEW_ZONE) ||
(pContextMenuItem2->lCommandID == IDM_SERVER_UPDATE_DATA_FILES) ||
(pContextMenuItem2->lCommandID == IDM_SERVER_CLEAR_CACHE) ||
(pContextMenuItem2->lCommandID == IDM_SERVER_SET_AGING) ||
(pContextMenuItem2->lCommandID == IDM_SERVER_SCAVENGE)
#ifdef USE_NDNC
||(pContextMenuItem2->lCommandID == IDM_SERVER_CREATE_NDNC)
#endif
) )
{
pContextMenuItem2->fFlags |= MF_GRAYED;
}
if ((pContextMenuItem2->lCommandID == IDM_SERVER_CONFIGURE) && IsServerConfigured())
{
return FALSE;
}
#ifdef USE_NDNC
if ((pContextMenuItem2->lCommandID == IDM_SERVER_CREATE_NDNC) &&
(m_nState != loaded ||
GetBuildNumber() < DNS_SRV_BUILD_NUMBER_WHISTLER ||
(GetMajorVersion() <= DNS_SRV_MAJOR_VERSION_NT_5 &&
GetMinorVersion() < DNS_SRV_MINOR_VERSION_WHISTLER) ||
ContainsDefaultNDNCs()))
{
return FALSE;
}
#endif
// this command might cause a refresh
if ( IsThreadLocked() && (pContextMenuItem2->lCommandID == IDM_SERVER_CLEAR_CACHE))
{
pContextMenuItem2->fFlags |= MF_GRAYED;
}
// add toggle menu item for advanced view
if (pContextMenuItem2->lCommandID == IDM_SNAPIN_ADVANCED_VIEW)
{
pContextMenuItem2->fFlags = ((CDNSRootData*)GetRootContainer())->IsAdvancedView() ? MF_CHECKED : 0;
return TRUE;
}
if (pContextMenuItem2->lCommandID == IDM_SNAPIN_FILTERING)
{
if (((CDNSRootData*)GetRootContainer())->IsFilteringEnabled())
{
pContextMenuItem2->fFlags = MF_CHECKED;
}
return TRUE;
}
if (pContextMenuItem2->lCommandID == IDM_SNAPIN_MESSAGE)
{
if (m_bShowMessages)
{
pContextMenuItem2->fFlags = MF_CHECKED;
}
}
return TRUE;
}
BOOL CDNSServerNode::OnSetDeleteVerbState(DATA_OBJECT_TYPES,
BOOL* pbHide,
CNodeList* pNodeList)
{
if (pNodeList->GetCount() > 1) // multiple selection
{
*pbHide = TRUE;
return FALSE;
}
if (((CDNSRootData*)GetRootContainer())->GetComponentDataObject()->IsExtensionSnapin())
{
// for extensions, remove the delete verb
*pbHide = TRUE;
return FALSE; // disable
}
*pbHide = FALSE;
TRACE(_T("CDNSServerNode::OnSetDeleteVerbState() IsThreadLocked() == %d\n"),
IsThreadLocked());
return !IsThreadLocked();
}
BOOL CDNSServerNode::OnSetRefreshVerbState(DATA_OBJECT_TYPES,
BOOL* pbHide,
CNodeList*)
{
*pbHide = FALSE;
return !IsThreadLocked();
}
CDNSZoneNode* CDNSServerNode::GetNewZoneNode()
{
CDNSZoneNode* pZoneNode = new CDNSZoneNode();
ASSERT(pZoneNode != NULL);
pZoneNode->SetServerNode(this);
return pZoneNode;
}
#ifdef USE_NDNC
DNS_STATUS CDNSServerNode::CreatePrimaryZone(LPCTSTR lpszName, LPCTSTR lpszFileName,
BOOL bLoadExisting,
BOOL bFwd,
BOOL bDSIntegrated,
UINT nDynamicUpdate,
CComponentDataObject* pComponentData,
ReplicationType replType,
PCWSTR pszPartitionName)
{
CDNSRootData* pRootData = (CDNSRootData*)pComponentData->GetRootData();
ASSERT(pRootData != NULL);
CDNSZoneNode* pZoneNode = GetNewZoneNode();
pZoneNode->SetNames(TRUE /* isZone*/, !bFwd, pRootData->IsAdvancedView(),
lpszName, lpszName);
DNS_STATUS err = 0;
if (bDSIntegrated && !(replType == none || replType == w2k))
{
err = pZoneNode->CreatePrimaryInDirectoryPartition(bLoadExisting,
nDynamicUpdate,
replType,
pszPartitionName);
}
else
{
err = pZoneNode->CreatePrimary(lpszFileName, bLoadExisting, bDSIntegrated, nDynamicUpdate);
}
if (err != 0)
{
// fail
delete pZoneNode;
return err;
}
// succeeded, need to add to the UI, if possible
if (IsExpanded())
{
CCathegoryFolderNode* pCathegoryFolder = GetAuthoritatedZoneFolder(bFwd);
if ( (pCathegoryFolder != NULL) && pCathegoryFolder->IsEnumerated() )
{
VERIFY(pCathegoryFolder->AddChildToListAndUI(pZoneNode, pComponentData));
pComponentData->SetDescriptionBarText(pCathegoryFolder);
}
else
{
delete pZoneNode; // the enumeration will add it
}
}
else
{
delete pZoneNode; // the expansion will get the zone from the RPC when expanding subfolders
}
return err;
}
#else
DNS_STATUS CDNSServerNode::CreatePrimaryZone(LPCTSTR lpszName, LPCTSTR lpszFileName,
BOOL bLoadExisting,
BOOL bFwd,
BOOL bDSIntegrated,
UINT nDynamicUpdate,
CComponentDataObject* pComponentData)
{
CDNSRootData* pRootData = (CDNSRootData*)pComponentData->GetRootData();
ASSERT(pRootData != NULL);
CDNSZoneNode* pZoneNode = GetNewZoneNode();
pZoneNode->SetNames(TRUE /* isZone*/, !bFwd, pRootData->IsAdvancedView(),
lpszName, lpszName);
DNS_STATUS err = pZoneNode->CreatePrimary(lpszFileName, bLoadExisting, bDSIntegrated, nDynamicUpdate);
if (err != 0)
{
// fail
delete pZoneNode;
return err;
}
// succeeded, need to add to the UI, if possible
if (IsExpanded())
{
CCathegoryFolderNode* pCathegoryFolder = GetAuthoritatedZoneFolder(bFwd);
if ( (pCathegoryFolder != NULL) && pCathegoryFolder->IsEnumerated() )
{
VERIFY(pCathegoryFolder->AddChildToListAndUI(pZoneNode, pComponentData));
pComponentData->SetDescriptionBarText(pCathegoryFolder);
}
else
{
delete pZoneNode; // the enumeration will add it
}
}
else
{
delete pZoneNode; // the expansion will get the zone from the RPC when expanding subfolders
}
return err;
}
#endif //USE_NDNC
DNS_STATUS CDNSServerNode::CreateSecondaryZone(LPCTSTR lpszName, LPCTSTR lpszFileName,
BOOL bLoadExisting, BOOL bFwd,
DWORD* ipMastersArray, int nIPMastersCount, CComponentDataObject* pComponentData)
{
CDNSRootData* pRootData = (CDNSRootData*)pComponentData->GetRootData();
ASSERT(pRootData != NULL);
CDNSZoneNode* pZoneNode = GetNewZoneNode();
pZoneNode->SetNames(TRUE /* isZone*/, !bFwd, pRootData->IsAdvancedView(),
lpszName, lpszName);
DNS_STATUS err = pZoneNode->CreateSecondary(ipMastersArray, nIPMastersCount,
lpszFileName, bLoadExisting);
if (err != 0)
{
// fail
delete pZoneNode;
return err;
}
// succeeded, need to add to the UI, if possible
if (IsExpanded())
{
CCathegoryFolderNode* pCathegoryFolder = GetAuthoritatedZoneFolder(bFwd);
if ( (pCathegoryFolder != NULL) && pCathegoryFolder->IsEnumerated() )
{
VERIFY(pCathegoryFolder->AddChildToListAndUI(pZoneNode, pComponentData));
pComponentData->SetDescriptionBarText(pCathegoryFolder);
}
else
{
delete pZoneNode; // the enumeration will add it
}
}
else
{
delete pZoneNode; // the expansion will get the zone from the RPC when expanding subfolders
}
return err;
}
#ifdef USE_NDNC
DNS_STATUS CDNSServerNode::CreateStubZone(LPCTSTR lpszName,
LPCTSTR lpszFileName,
BOOL bLoadExisting,
BOOL bDSIntegrated,
BOOL bFwd,
DWORD* ipMastersArray,
int nIPMastersCount,
BOOL bLocalListOfMasters,
CComponentDataObject* pComponentData,
ReplicationType replType,
PCWSTR pszPartitionName)
{
CDNSRootData* pRootData = (CDNSRootData*)pComponentData->GetRootData();
ASSERT(pRootData != NULL);
CDNSZoneNode* pZoneNode = GetNewZoneNode();
pZoneNode->SetNames(TRUE /* isZone*/, !bFwd, pRootData->IsAdvancedView(),
lpszName, lpszName);
USES_CONVERSION;
DNS_STATUS err = 0;
if (bDSIntegrated && !(replType == none || replType == w2k))
{
err = pZoneNode->CreateStubInDirectoryPartition(ipMastersArray,
nIPMastersCount,
bLoadExisting,
replType,
pszPartitionName);
}
else
{
err = pZoneNode->CreateStub(ipMastersArray,
nIPMastersCount,
lpszFileName,
bLoadExisting,
bDSIntegrated);
}
if (err != 0)
{
// fail
delete pZoneNode;
return err;
}
// succeeded, need to add to the UI, if possible
if (IsExpanded())
{
CCathegoryFolderNode* pCathegoryFolder = GetAuthoritatedZoneFolder(bFwd);
if ( (pCathegoryFolder != NULL) && pCathegoryFolder->IsEnumerated() )
{
VERIFY(pCathegoryFolder->AddChildToListAndUI(pZoneNode, pComponentData));
pComponentData->SetDescriptionBarText(pCathegoryFolder);
}
else
{
delete pZoneNode; // the enumeration will add it
}
}
else
{
delete pZoneNode; // the expansion will get the zone from the RPC when expanding subfolders
}
//
// Change to the local list of masters after the zone has been created
//
if (bLocalListOfMasters)
{
err = ::DnssrvResetZoneMastersEx(GetRPCName(), // Server name
W_TO_UTF8(pZoneNode->GetFullName()), // Zone name
nIPMastersCount,
ipMastersArray,
TRUE); // LocalListOfMasters
if (err != 0)
return err;
}
else
{
/*
err = ::DnssrvResetZoneMastersEx(GetRPCName(), // Server name
W_TO_UTF8(pZoneNode->GetFullName()), // Zone name
0,
NULL,
TRUE); // LocalListOfMasters
if (err != 0)
return err;
*/
}
return err;
}
#else
DNS_STATUS CDNSServerNode::CreateStubZone(LPCTSTR lpszName,
LPCTSTR lpszFileName,
BOOL bLoadExisting,
BOOL bDSIntegrated,
BOOL bFwd,
DWORD* ipMastersArray,
int nIPMastersCount,
BOOL bLocalListOfMasters,
CComponentDataObject* pComponentData)
{
CDNSRootData* pRootData = (CDNSRootData*)pComponentData->GetRootData();
ASSERT(pRootData != NULL);
CDNSZoneNode* pZoneNode = GetNewZoneNode();
pZoneNode->SetNames(TRUE /* isZone*/, !bFwd, pRootData->IsAdvancedView(),
lpszName, lpszName);
USES_CONVERSION;
DNS_STATUS err = pZoneNode->CreateStub(ipMastersArray,
nIPMastersCount,
lpszFileName,
bLoadExisting,
bDSIntegrated);
if (err != 0)
{
// fail
delete pZoneNode;
return err;
}
// succeeded, need to add to the UI, if possible
if (IsExpanded())
{
CCathegoryFolderNode* pCathegoryFolder = GetAuthoritatedZoneFolder(bFwd);
if ( (pCathegoryFolder != NULL) && pCathegoryFolder->IsEnumerated() )
{
VERIFY(pCathegoryFolder->AddChildToListAndUI(pZoneNode, pComponentData));
pComponentData->SetDescriptionBarText(pCathegoryFolder);
}
else
{
delete pZoneNode; // the enumeration will add it
}
}
else
{
delete pZoneNode; // the expansion will get the zone from the RPC when expanding subfolders
}
//
// Change to the local list of masters after the zone has been created
//
if (bLocalListOfMasters)
{
err = ::DnssrvResetZoneMastersEx(GetRPCName(), // Server name
W_TO_UTF8(pZoneNode->GetFullName()), // Zone name
nIPMastersCount,
ipMastersArray,
TRUE); // LocalListOfMasters
if (err != 0)
return err;
}
else
{
/*
err = ::DnssrvResetZoneMastersEx(GetRPCName(), // Server name
W_TO_UTF8(pZoneNode->GetFullName()), // Zone name
0,
NULL,
TRUE); // LocalListOfMasters
if (err != 0)
return err;
*/
}
return err;
}
#endif // USE_NDNC
DNS_STATUS CDNSServerNode::CreateForwarderZone(LPCTSTR lpszName,
DWORD* ipMastersArray,
int nIPMastersCount,
DWORD dwTimeout,
DWORD fSlave,
CComponentDataObject* pComponentData)
{
CDNSRootData* pRootData = (CDNSRootData*)pComponentData->GetRootData();
ASSERT(pRootData != NULL);
CDNSZoneNode* pZoneNode = GetNewZoneNode();
pZoneNode->SetNames(TRUE /* isZone*/,
TRUE,
pRootData->IsAdvancedView(),
lpszName,
lpszName);
DNS_STATUS err = pZoneNode->CreateForwarder(ipMastersArray,
nIPMastersCount,
dwTimeout,
fSlave);
if (err != 0)
{
//
// fail
//
delete pZoneNode;
return err;
}
//
// succeeded, need to add to the UI, if possible
//
if (IsExpanded())
{
CCathegoryFolderNode* pCathegoryFolder = GetDomainForwardersNode();
if ( (pCathegoryFolder != NULL) && pCathegoryFolder->IsEnumerated() )
{
VERIFY(pCathegoryFolder->AddChildToListAndUI(pZoneNode, pComponentData));
pComponentData->SetDescriptionBarText(pCathegoryFolder);
}
else
{
delete pZoneNode; // the enumeration will add it
}
}
else
{
delete pZoneNode; // the expansion will get the zone from the RPC when expanding subfolders
}
return err;
}
DNS_STATUS CDNSServerNode::WriteDirtyZones()
{
USES_CONVERSION;
return ::DnssrvWriteDirtyZones(GetServerNode()->GetRPCName());
}
BOOL CDNSServerNode::CanUseADS()
{
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
if (GetMajorVersion() <= DNS_SRV_MAJOR_VERSION_NT_4)
return FALSE;
return m_pServInfoEx->m_pServInfo->fDsAvailable;
}
DWORD CDNSServerNode::GetVersion()
{
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
if (m_pServInfoEx->m_pServInfo != NULL)
{
return m_pServInfoEx->m_pServInfo->dwVersion;
}
return (DWORD)-1;
}
void _CopyStringAndFree(CString& sz, LPWSTR lpsz)
{
sz = lpsz;
if (lpsz)
::DnssrvFreeRpcBuffer((PDNS_RPC_BUFFER)lpsz);
}
void _LdapPathFromX500(CString& szLdap, PDNS_RPC_SERVER_INFO pInfo, LPCWSTR lpszX500Name)
{
ASSERT(pInfo != NULL);
ASSERT(pInfo->pszServerName != NULL);
USES_CONVERSION;
LPCWSTR lpszServerName = UTF8_TO_W(pInfo->pszServerName);
szLdap.Format(L"LDAP://%s/%s", lpszServerName, lpszX500Name);
}
void CDNSServerNode::CreateDsServerLdapPath(CString& sz)
{
ASSERT(m_pServInfoEx != NULL);
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
if (m_pServInfoEx->m_pServInfo != NULL)
{
CString szX500;
_CopyStringAndFree(szX500,::DnssrvCreateDsServerName(m_pServInfoEx->m_pServInfo));
CreateLdapPathFromX500Name(szX500, sz);
}
else
sz.Empty();
}
void CDNSServerNode::CreateDsZoneLdapPath(CDNSZoneNode* pZoneNode, CString& sz)
{
PCWSTR pszDN = pZoneNode->GetDN();
if (!pszDN)
{
ASSERT(m_pServInfoEx != NULL);
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
if (m_pServInfoEx->m_pServInfo != NULL)
{
CString szX500;
_CopyStringAndFree(szX500, ::DnssrvCreateDsZoneName(m_pServInfoEx->m_pServInfo,
(LPWSTR)pZoneNode->GetFullName()));
CreateLdapPathFromX500Name( szX500, sz);
}
else
{
sz.Empty();
}
}
else
{
CreateLdapPathFromX500Name(pszDN, sz);
}
}
void CDNSServerNode::CreateDsZoneName(CDNSZoneNode* pZoneNode, CString& sz)
{
ASSERT(m_pServInfoEx != NULL);
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
if (m_pServInfoEx->m_pServInfo != NULL)
{
_CopyStringAndFree(sz, ::DnssrvCreateDsZoneName(m_pServInfoEx->m_pServInfo,
(LPWSTR)pZoneNode->GetFullName()));
}
else
sz.Empty();
}
void CDNSServerNode::CreateDsNodeLdapPath(CDNSZoneNode* pZoneNode, CDNSDomainNode* pDomainNode, CString& sz)
{
ASSERT(m_pServInfoEx != NULL);
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
if (m_pServInfoEx->m_pServInfo != NULL)
{
// need to get the relative path of the node wrt the zone
size_t nZoneLen = wcslen(pZoneNode->GetFullName());
size_t nDomainLen = wcslen(pDomainNode->GetFullName());
size_t nRelativeNameLen = nDomainLen - nZoneLen - 1; // remove a dot
CString szRelativeName(pDomainNode->GetFullName(), static_cast<int>(nRelativeNameLen));
CString szX500;
_CopyStringAndFree(szX500, ::DnssrvCreateDsNodeName(m_pServInfoEx->m_pServInfo,
(LPWSTR)pZoneNode->GetFullName(),
(LPWSTR)(LPCWSTR)szRelativeName));
CreateLdapPathFromX500Name(szX500, sz);
}
else
sz.Empty();
}
void CDNSServerNode::CreateLdapPathFromX500Name(LPCWSTR lpszX500Name, CString& szLdapPath)
{
ASSERT(m_pServInfoEx != NULL);
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
if (m_pServInfoEx->m_pServInfo != NULL)
{
_LdapPathFromX500(szLdapPath, m_pServInfoEx->m_pServInfo, lpszX500Name);
}
else
szLdapPath.Empty();
}
BOOL CDNSServerNode::DoesRecursion()
{
if (m_pServInfoEx == NULL || m_pServInfoEx->m_pServInfo == NULL)
{
ASSERT(FALSE);
return TRUE;
}
return !m_pServInfoEx->m_pServInfo->fNoRecursion;
}
void CDNSServerNode::GetAdvancedOptions(BOOL* bOptionsArray)
{
ASSERT(m_pServInfoEx != NULL);
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
bOptionsArray[SERVER_REGKEY_ARR_INDEX_NO_RECURSION] = m_pServInfoEx->m_pServInfo->fNoRecursion;
bOptionsArray[SERVER_REGKEY_ARR_INDEX_BIND_SECONDARIES] = m_pServInfoEx->m_pServInfo->fBindSecondaries;
bOptionsArray[SERVER_REGKEY_ARR_INDEX_STRICT_FILE_PARSING] = m_pServInfoEx->m_pServInfo->fStrictFileParsing;
bOptionsArray[SERVER_REGKEY_ARR_INDEX_ROUND_ROBIN] = m_pServInfoEx->m_pServInfo->fRoundRobin;
bOptionsArray[SERVER_REGKEY_ARR_LOCAL_NET_PRIORITY] = m_pServInfoEx->m_pServInfo->fLocalNetPriority;
bOptionsArray[SERVER_REGKEY_ARR_CACHE_POLLUTION] = m_pServInfoEx->m_pServInfo->fSecureResponses;
}
DNS_STATUS CDNSServerNode::ResetAdvancedOptions(BOOL* bOptionsArray, DNS_STATUS* dwRegKeyOptionsErrorArr)
{
ASSERT(m_pServInfoEx != NULL);
DNS_STATUS err = 0;
BOOL bChanged = FALSE;
ZeroMemory(dwRegKeyOptionsErrorArr, sizeof(DNS_STATUS )*SERVER_REGKEY_ARR_SIZE);
for (UINT iKey=0; iKey < SERVER_REGKEY_ARR_SIZE; iKey++)
{
BOOL bDirty = FALSE;
switch (iKey)
{
case SERVER_REGKEY_ARR_INDEX_NO_RECURSION:
bDirty = (bOptionsArray[iKey] != m_pServInfoEx->m_pServInfo->fNoRecursion);
break;
case SERVER_REGKEY_ARR_INDEX_BIND_SECONDARIES:
bDirty = (bOptionsArray[iKey] != m_pServInfoEx->m_pServInfo->fBindSecondaries);
break;
case SERVER_REGKEY_ARR_INDEX_STRICT_FILE_PARSING:
bDirty = (bOptionsArray[iKey] != m_pServInfoEx->m_pServInfo->fStrictFileParsing);
break;
case SERVER_REGKEY_ARR_INDEX_ROUND_ROBIN:
bDirty = (bOptionsArray[iKey] != m_pServInfoEx->m_pServInfo->fRoundRobin);
break;
case SERVER_REGKEY_ARR_LOCAL_NET_PRIORITY:
bDirty = (bOptionsArray[iKey] != m_pServInfoEx->m_pServInfo->fLocalNetPriority);
break;
case SERVER_REGKEY_ARR_CACHE_POLLUTION:
bDirty = (bOptionsArray[iKey] != m_pServInfoEx->m_pServInfo->fSecureResponses);
break;
default:
ASSERT(FALSE);
}
if (bDirty)
{
dwRegKeyOptionsErrorArr[iKey] = ::DnssrvResetDwordProperty(
GetServerNode()->GetRPCName(), // server name
NULL,
_DnsServerRegkeyStringArr[iKey],
bOptionsArray[iKey]);
if (dwRegKeyOptionsErrorArr[iKey] == 0)
bChanged = TRUE;
}
}
if (bChanged)
err = GetServInfo(); // update the info
return err;
}
UCHAR CDNSServerNode::GetBootMethod()
{
ASSERT(m_pServInfoEx != NULL);
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
return m_pServInfoEx->m_pServInfo->fBootMethod;
}
DNS_STATUS CDNSServerNode::ResetBootMethod(UCHAR fBootMethod)
{
ASSERT(m_pServInfoEx != NULL);
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
DWORD err = 0;
if(fBootMethod != m_pServInfoEx->m_pServInfo->fBootMethod)
{
err = ::DnssrvResetDwordProperty(GetServerNode()->GetRPCName(), // server name
NULL,
DNS_REGKEY_BOOT_METHOD,
fBootMethod);
if (err != 0)
return err;
// all fine, update the info
err = GetServInfo();
}
return err;
}
BOOL CDNSServerNode::ContainsDefaultNDNCs()
{
//
// Enumerate the available directory partitions
//
BOOL result = FALSE;
PDNS_RPC_DP_LIST pDirectoryPartitions = NULL;
DWORD dwErr = ::DnssrvEnumDirectoryPartitions(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(GetRPCName(),
pDirectoryPartitions->DpArray[dwIdx]->pszDpFqdn,
&pDirectoryPartition);
if (dwErr == 0 &&
pDirectoryPartition)
{
//
// Check to see if it was an autocreated partition
//
if (pDirectoryPartition->dwFlags & DNS_DP_AUTOCREATED)
{
result = TRUE;
::DnssrvFreeDirectoryPartitionInfo(pDirectoryPartition);
break;
}
::DnssrvFreeDirectoryPartitionInfo(pDirectoryPartition);
}
}
::DnssrvFreeDirectoryPartitionList(pDirectoryPartitions);
}
return result;
}
BOOL CDNSServerNode::IsServerConfigured()
{
ASSERT(m_pServInfoEx != NULL);
if (m_pServInfoEx != NULL && m_pServInfoEx->m_pServInfo != NULL)
{
return m_pServInfoEx->m_pServInfo->fAdminConfigured;
}
return TRUE;
}
DNS_STATUS CDNSServerNode::SetServerConfigured()
{
ASSERT(m_pServInfoEx != NULL);
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
DWORD err = 0;
if (TRUE != m_pServInfoEx->m_pServInfo->fAdminConfigured)
{
err = ::DnssrvResetDwordProperty(GetRPCName(),
NULL,
DNS_REGKEY_ADMIN_CONFIGURED,
TRUE);
if (err != 0)
return err;
err = GetServInfo();
}
return err;
}
BOOL CDNSServerNode::GetScavengingState()
{
ASSERT(m_pServInfoEx != NULL);
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
return m_pServInfoEx->m_pServInfo->dwScavengingInterval > 0;
}
DWORD CDNSServerNode::GetScavengingInterval()
{
ASSERT(m_pServInfoEx != NULL);
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
return m_pServInfoEx->m_pServInfo->dwScavengingInterval;
}
DNS_STATUS CDNSServerNode::ResetScavengingInterval(DWORD dwScavengingInterval)
{
ASSERT(m_pServInfoEx != NULL);
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
DWORD err = 0;
if (dwScavengingInterval != m_pServInfoEx->m_pServInfo->dwScavengingInterval)
{
DNS_RPC_NAME_AND_PARAM param;
param.dwParam = dwScavengingInterval;
param.pszNodeName = DNS_REGKEY_SCAVENGING_INTERVAL;
err = ::DnssrvOperation(
GetRPCName(),
NULL,
DNSSRV_OP_RESET_DWORD_PROPERTY,
DNSSRV_TYPEID_NAME_AND_PARAM,
& param
);
if (err != 0)
return err;
err = GetServInfo();
}
return err;
}
DWORD CDNSServerNode::GetDefaultRefreshInterval()
{
ASSERT(m_pServInfoEx != NULL);
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
return m_pServInfoEx->m_pServInfo->dwDefaultRefreshInterval;
}
DNS_STATUS CDNSServerNode::ResetDefaultRefreshInterval(DWORD dwRefreshInterval)
{
ASSERT(m_pServInfoEx != NULL);
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
DWORD err = 0;
if (dwRefreshInterval != m_pServInfoEx->m_pServInfo->dwDefaultRefreshInterval)
{
DNS_RPC_NAME_AND_PARAM param;
param.dwParam = dwRefreshInterval;
param.pszNodeName = DNS_REGKEY_DEFAULT_REFRESH_INTERVAL;
err = ::DnssrvOperation(
GetRPCName(),
NULL,
DNSSRV_OP_RESET_DWORD_PROPERTY,
DNSSRV_TYPEID_NAME_AND_PARAM,
& param
);
if (err != 0)
return err;
err = GetServInfo();
}
return err;
}
DWORD CDNSServerNode::GetDefaultNoRefreshInterval()
{
ASSERT(m_pServInfoEx != NULL);
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
return m_pServInfoEx->m_pServInfo->dwDefaultNoRefreshInterval;
}
DNS_STATUS CDNSServerNode::ResetDefaultNoRefreshInterval(DWORD dwNoRefreshInterval)
{
ASSERT(m_pServInfoEx != NULL);
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
DWORD err = 0;
if (dwNoRefreshInterval != m_pServInfoEx->m_pServInfo->dwDefaultNoRefreshInterval)
{
DNS_RPC_NAME_AND_PARAM param;
param.dwParam = dwNoRefreshInterval;
param.pszNodeName = DNS_REGKEY_DEFAULT_NOREFRESH_INTERVAL;
err = ::DnssrvOperation(
GetRPCName(),
NULL,
DNSSRV_OP_RESET_DWORD_PROPERTY,
DNSSRV_TYPEID_NAME_AND_PARAM,
& param
);
if (err != 0)
return err;
err = GetServInfo();
}
return err;
}
#ifdef USE_NDNC
PCSTR CDNSServerNode::GetDomainName()
{
ASSERT(m_pServInfoEx != NULL);
ASSERT(m_pServInfoEx->m_pServInfo);
return m_pServInfoEx->m_pServInfo->pszDomainName;
}
PCSTR CDNSServerNode::GetForestName()
{
ASSERT(m_pServInfoEx != NULL);
ASSERT(m_pServInfoEx->m_pServInfo);
return m_pServInfoEx->m_pServInfo->pszForestName;
}
#endif
DWORD CDNSServerNode::GetDefaultScavengingState()
{
ASSERT(m_pServInfoEx != NULL);
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
return m_pServInfoEx->m_pServInfo->fDefaultAgingState;
}
DNS_STATUS CDNSServerNode::ResetDefaultScavengingState(DWORD dwScavengingState)
{
ASSERT(m_pServInfoEx != NULL);
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
DWORD err = 0;
if (dwScavengingState != m_pServInfoEx->m_pServInfo->fDefaultAgingState)
{
DNS_RPC_NAME_AND_PARAM param;
param.dwParam = dwScavengingState;
param.pszNodeName = DNS_REGKEY_DEFAULT_AGING_STATE;
err = ::DnssrvOperation(
GetRPCName(),
NULL,
DNSSRV_OP_RESET_DWORD_PROPERTY,
DNSSRV_TYPEID_NAME_AND_PARAM,
& param
);
if (err != 0)
return err;
err = GetServInfo();
}
return err;
}
DWORD CDNSServerNode::GetNameCheckFlag()
{
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
return m_pServInfoEx->m_pServInfo->dwNameCheckFlag;
}
DNS_STATUS CDNSServerNode::ResetNameCheckFlag(DWORD dwNameCheckFlag)
{
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
DNS_STATUS err = 0;
// call only if the info is dirty
if (m_pServInfoEx->m_pServInfo->dwNameCheckFlag != dwNameCheckFlag)
{
USES_CONVERSION;
err = ::DnssrvResetDwordProperty(GetServerNode()->GetRPCName(), // server name
NULL,
DNS_REGKEY_NAME_CHECK_FLAG,
dwNameCheckFlag);
if (err != 0)
return err;
err = GetServInfo(); // update the info
}
return err;
}
PIP_ARRAY CDNSServerNode::GetDebugLogFilterList()
{
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
return m_pServInfoEx->m_pServInfo->aipLogFilter;
}
DNS_STATUS CDNSServerNode::ResetDebugLogFilterList(PIP_ARRAY pIPArray)
{
DNS_STATUS err = 0;
err = ::DnssrvResetIPListProperty(GetServerNode()->GetRPCName(), // server name
NULL,
DNS_REGKEY_LOG_IP_FILTER_LIST,
pIPArray,
0); // dwFlags
if (err != 0)
return err;
err = GetServInfo(); // update the info
return err;
}
PCWSTR CDNSServerNode::GetDebugLogFileName()
{
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
return m_pServInfoEx->m_pServInfo->pwszLogFilePath;
}
DNS_STATUS CDNSServerNode::ResetDebugLogFileName(PCWSTR pszLogFileName)
{
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
DNS_STATUS err = 0;
if (m_pServInfoEx->m_pServInfo->pwszLogFilePath == NULL ||
_wcsicmp(m_pServInfoEx->m_pServInfo->pwszLogFilePath, pszLogFileName) != 0)
{
err = ::DnssrvResetStringProperty(GetServerNode()->GetRPCName(), // server name
NULL,
DNS_REGKEY_LOG_FILE_PATH,
pszLogFileName,
0); // dwFlags
if (err != 0)
return err;
err = GetServInfo(); // update the info
}
return err;
}
DWORD CDNSServerNode::GetDebugLogFileMaxSize()
{
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
return m_pServInfoEx->m_pServInfo->dwLogFileMaxSize;
}
DNS_STATUS CDNSServerNode::ResetDebugLogFileMaxSize(DWORD dwMaxSize)
{
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
DNS_STATUS err = 0;
if (m_pServInfoEx->m_pServInfo->dwLogFileMaxSize != dwMaxSize)
{
err = ::DnssrvResetDwordProperty(GetServerNode()->GetRPCName(), // server name
NULL,
DNS_REGKEY_LOG_FILE_MAX_SIZE,
dwMaxSize);
if (err != 0)
return err;
err = GetServInfo(); // update the info
}
return err;
}
DWORD CDNSServerNode::GetLogLevelFlag()
{
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
return m_pServInfoEx->m_pServInfo->dwLogLevel;
}
DNS_STATUS CDNSServerNode::ResetLogLevelFlag(DWORD dwLogLevel)
{
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
DNS_STATUS err = 0;
// call only if the info is dirty
if (m_pServInfoEx->m_pServInfo->dwLogLevel != dwLogLevel)
{
USES_CONVERSION;
err = ::DnssrvResetDwordProperty(GetServerNode()->GetRPCName(), // server name
NULL,
DNS_REGKEY_LOG_LEVEL,
dwLogLevel);
if (err != 0)
return err;
err = GetServInfo(); // update the info
}
return err;
}
DWORD CDNSServerNode::GetEventLogLevelFlag()
{
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
return m_pServInfoEx->m_pServInfo->dwEventLogLevel;
}
DNS_STATUS CDNSServerNode::ResetEventLogLevelFlag(DWORD dwEventLogLevel)
{
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
DNS_STATUS err = 0;
if (m_pServInfoEx->m_pServInfo->dwEventLogLevel != dwEventLogLevel)
{
USES_CONVERSION;
err = ::DnssrvResetDwordProperty(GetServerNode()->GetRPCName(), // server name
NULL,
DNS_REGKEY_EVENTLOG_LEVEL,
dwEventLogLevel);
if (err != 0)
return err;
err = GetServInfo(); // update the info
}
return err;
}
DNS_STATUS CDNSServerNode::ResetListenAddresses(DWORD cAddrCount, PIP_ADDRESS pipAddrs)
{
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
USES_CONVERSION;
// make the call only if the data is dirty
DNS_STATUS err = 0;
if (!(m_pServInfoEx->m_pServInfo->aipListenAddrs == NULL && cAddrCount == 0) && // if still no addresses, skip
((m_pServInfoEx->m_pServInfo->aipListenAddrs == NULL && cAddrCount > 0) || // no addr --> more than one
(m_pServInfoEx->m_pServInfo->aipListenAddrs->AddrCount != cAddrCount) || // change the # of addresses
(memcmp(pipAddrs, m_pServInfoEx->m_pServInfo->aipListenAddrs->AddrArray, sizeof(IP_ADDRESS)*cAddrCount) != 0)
)
)
{
IP_ADDRESS dummy;
if (pipAddrs == NULL)
{
ASSERT(cAddrCount == 0);
pipAddrs = &dummy; // RPC wants non null ip array
}
err = ::DnssrvResetServerListenAddresses(GetRPCName(), cAddrCount, pipAddrs);
}
if (err != 0)
return err;
return GetServInfo(); // update the info
}
void CDNSServerNode::GetListenAddressesInfo(DWORD* pcAddrCount, PIP_ADDRESS* ppipAddrs)
{
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
ASSERT(pcAddrCount != NULL);
ASSERT(ppipAddrs != NULL);
// return pointers to struct fields, caller has to copy data elsewhere
if (m_pServInfoEx->m_pServInfo->aipListenAddrs == NULL)
{
*pcAddrCount = 0;
*ppipAddrs = NULL;
}
else
{
*pcAddrCount = m_pServInfoEx->m_pServInfo->aipListenAddrs->AddrCount;
*ppipAddrs = m_pServInfoEx->m_pServInfo->aipListenAddrs->AddrArray;
}
}
void CDNSServerNode::GetServerAddressesInfo(DWORD* pcAddrCount, PIP_ADDRESS* ppipAddrs)
{
//
// Validate parameters
//
ASSERT(pcAddrCount != NULL);
ASSERT(ppipAddrs != NULL);
if (pcAddrCount == NULL ||
ppipAddrs == NULL)
{
return;
}
if (!m_pServInfoEx->HasData())
{
DNS_STATUS err = GetServInfo();
if (err != 0)
{
*pcAddrCount = 0;
*ppipAddrs = NULL;
return;
}
}
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
// return pointers to struct fields, caller has to copy data elsewhere
if (m_pServInfoEx->m_pServInfo->aipServerAddrs == NULL)
{
*pcAddrCount = 0;
*ppipAddrs = NULL;
}
else
{
*pcAddrCount = m_pServInfoEx->m_pServInfo->aipServerAddrs->AddrCount;
*ppipAddrs = m_pServInfoEx->m_pServInfo->aipServerAddrs->AddrArray;
}
}
DNS_STATUS CDNSServerNode::ResetForwarders(DWORD cForwardersCount, PIP_ADDRESS aipForwarders,
DWORD dwForwardTimeout, DWORD fSlave)
{
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
// make the call only if the data is dirty
DNS_STATUS err = 0;
if (m_pServInfoEx->m_pServInfo->aipForwarders == NULL && cForwardersCount == 0)
return err; // there are no addresses
BOOL bDirty = (m_pServInfoEx->m_pServInfo->fSlave != fSlave) || (m_pServInfoEx->m_pServInfo->dwForwardTimeout != dwForwardTimeout) ||
(m_pServInfoEx->m_pServInfo->aipForwarders == NULL && cForwardersCount > 0) || // no addr --> more than one
(m_pServInfoEx->m_pServInfo->aipForwarders != NULL && cForwardersCount == 0) || // some addr --> no addr
(m_pServInfoEx->m_pServInfo->aipForwarders->AddrCount != cForwardersCount) || // change the # of addresses
(memcmp(aipForwarders, m_pServInfoEx->m_pServInfo->aipForwarders->AddrArray, sizeof(IP_ADDRESS)*cForwardersCount) != 0);
if (bDirty)
{
IP_ADDRESS dummy;
if (aipForwarders == NULL)
{
ASSERT(cForwardersCount == 0);
aipForwarders = &dummy; // RPC wants non null ip array
}
USES_CONVERSION;
err = ::DnssrvResetForwarders(GetRPCName(),
cForwardersCount, aipForwarders, dwForwardTimeout, fSlave);
if (err == 0)
err = GetServInfo(); // update the info
}
return err;
}
void CDNSServerNode::GetForwardersInfo(DWORD* pcForwardersCount, PIP_ADDRESS* paipForwarders,
DWORD* pdwForwardTimeout, DWORD* pfSlave)
{
ASSERT(m_pServInfoEx->m_pServInfo != NULL);
// return pointers to struct fields, caller has to copy data elsewhere
*pdwForwardTimeout = m_pServInfoEx->m_pServInfo->dwForwardTimeout;
*pfSlave = m_pServInfoEx->m_pServInfo->fSlave;
if (m_pServInfoEx->m_pServInfo->aipForwarders == NULL)
{
*pcForwardersCount = 0;
*paipForwarders = NULL;
}
else
{
*pcForwardersCount = m_pServInfoEx->m_pServInfo->aipForwarders->AddrCount;
*paipForwarders = m_pServInfoEx->m_pServInfo->aipForwarders->AddrArray;
}
}
CDNSRootHintsNode* CDNSServerNode::GetRootHints()
{
if (m_pRootHintsNode == NULL)
{
m_pRootHintsNode = new CDNSRootHintsNode;
ASSERT(m_pRootHintsNode != NULL);
m_pRootHintsNode->SetServerNode(GetServerNode());
}
return m_pRootHintsNode;
}
void CDNSServerNode::GetTestOptions(CDNSServerTestOptions* pOptions)
{
ASSERT(pOptions != NULL);
*pOptions = m_testOptions;
}
void CDNSServerNode::ResetTestOptions(CDNSServerTestOptions* pOptions)
{
ASSERT(pOptions != NULL);
m_testOptions = *pOptions;
CDNSRootData* pSnapinData = (CDNSRootData*)GetRootContainer();
pSnapinData->SetDirtyFlag(TRUE);
}
void CDNSServerNode::AddTestQueryResult(CDNSServerTestQueryResult* pTestResult,
CComponentDataObject* pComponentData)
{
// TRACE(_T("m_testResultList.GetCount() == %d\n"), m_testResultList.GetCount());
if (!pTestResult->m_bAsyncQuery)
m_bTestQueryPending = FALSE;
CDNSServerTestQueryResultList::addAction action =
m_testResultList.AddTestQueryResult(pTestResult);
// change icon, if necessary (GetImageIndex() will switch from/to alternative server icon set
if (action == CDNSServerTestQueryResultList::added ||
action == CDNSServerTestQueryResultList::addedAndRemoved)
{
ASSERT(IsVisible());
VERIFY(SUCCEEDED(pComponentData->ChangeNode(this, CHANGE_RESULT_ITEM_ICON)));
if (m_bPrevQuerySuccess != m_testResultList.LastQuerySuceeded())
{
pComponentData->UpdateResultPaneView(this);
}
m_bPrevQuerySuccess = m_testResultList.LastQuerySuceeded();
}
pComponentData->GetPropertyPageHolderTable()->BroadcastMessageToSheets(
this, SHEET_MSG_SERVER_TEST_DATA,
(LPARAM)action);
}
/////////////////////////////////////////////////////////////////////////////
///////// LOW LEVEL DNS UTILITIES ///////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
DNS_STATUS CDNSServerNode::EnumZoneInfo(CZoneInfoHolder* pZoneInfoHolder)
{
return EnumZoneInfo(m_szDisplayName, pZoneInfoHolder);
}
DNS_STATUS CDNSServerNode::EnumZoneInfo(LPCTSTR, CZoneInfoHolder* pZoneInfoHolder)
{
ASSERT(pZoneInfoHolder != NULL);
USES_CONVERSION;
DNS_STATUS err = 0;
do
{
ASSERT(pZoneInfoHolder->m_dwArrSize > 0);
ASSERT(pZoneInfoHolder->m_dwZoneCount == 0);
ASSERT(pZoneInfoHolder->m_zoneInfoArray != NULL);
if ((err == 0) || (err != ERROR_MORE_DATA))
{
break; // success or no need to retry
}
if (!pZoneInfoHolder->Grow())
{
break; // reached the limit for growth
}
} while (TRUE);
return err;
}
DNS_STATUS CDNSServerNode::ClearCache()
{
USES_CONVERSION;
return ::DnssrvOperation(GetRPCName(), // server name
NULL, // zone name, just pass null
DNSSRV_OP_CLEAR_CACHE,
DNSSRV_TYPEID_NULL,
NULL);
}
void CDNSServerNode::FreeServInfo()
{
ASSERT(m_pServInfoEx != NULL);
m_pServInfoEx->FreeInfo();
}
DNS_STATUS CDNSServerNode::GetServInfo()
{
ASSERT(m_pServInfoEx != NULL);
return m_pServInfoEx->Query(GetDisplayName());
}
void CDNSServerNode::AttachServerInfo(CDNSServerInfoEx* pNewInfo)
{
ASSERT(pNewInfo != NULL);
ASSERT(m_pServInfoEx != NULL);
delete m_pServInfoEx;
m_pServInfoEx = pNewInfo;
}
void CDNSServerNode::FreeRootHints()
{
if (m_pRootHintsNode != NULL)
{
//CNodeList* pChildList = m_pRootHintsNode->GetChildList();
//int n = pChildList->GetCount();
delete m_pRootHintsNode;
m_pRootHintsNode = NULL;
}
}
void CDNSServerNode::AttachRootHints(CDNSRootHintsNode* pNewRootHints)
{
ASSERT(pNewRootHints != NULL);
FreeRootHints();
m_pRootHintsNode = pNewRootHints;
// the display and full names were set already in the constructor
m_pRootHintsNode->SetServerNode(GetServerNode());
}
Reference in a new issue Copy permalink