windows-xp/Source/XPSP1/NT/admin/snapin/dnsmgr/snapdata.cpp

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (C) Microsoft Corporation, 1998 - 1999
//
//  File:       snapdata.cpp
//
//--------------------------------------------------------------------------


#include "preDNSsn.h"
#include <SnapBase.h>

#include "resource.h"
#include "DNSSnap.h"

#include "dnsutil.h"
#include "snapdata.h"
#include "server.h"
#include "servwiz.h"

#include <prsht.h>
#include <svcguid.h>

#ifdef DEBUG_ALLOCATOR
	#ifdef _DEBUG
	#define new DEBUG_NEW
	#undef THIS_FILE
	static char THIS_FILE[] = __FILE__;
	#endif
#endif



///////////////////////////////////////////////////////////////////////////////
// GLOBAL FUNCTIONS

HRESULT SaveStringHelper(LPCWSTR pwsz, IStream* pStm)
{
	ASSERT(pStm);
	ULONG nBytesWritten;
	HRESULT hr;

	DWORD nLen = static_cast<DWORD>(wcslen(pwsz)+1); // WCHAR including NULL
	hr = pStm->Write((void*)&nLen, sizeof(DWORD),&nBytesWritten);
	ASSERT(nBytesWritten == sizeof(DWORD));
	if (FAILED(hr))
		return hr;
	
	hr = pStm->Write((void*)pwsz, sizeof(WCHAR)*nLen,&nBytesWritten);
	ASSERT(nBytesWritten == sizeof(WCHAR)*nLen);
	TRACE(_T("SaveStringHelper(<%s> nLen = %d\n"),pwsz,nLen);
	return hr;
}

HRESULT LoadStringHelper(CString& sz, IStream* pStm)
{
	ASSERT(pStm);
	HRESULT hr;
	ULONG nBytesRead;
	DWORD nLen = 0;

	hr = pStm->Read((void*)&nLen,sizeof(DWORD), &nBytesRead);
	ASSERT(nBytesRead == sizeof(DWORD));
	if (FAILED(hr) || (nBytesRead != sizeof(DWORD)))
		return hr;

	hr = pStm->Read((void*)sz.GetBuffer(nLen),sizeof(WCHAR)*nLen, &nBytesRead);
	ASSERT(nBytesRead == sizeof(WCHAR)*nLen);
	sz.ReleaseBuffer();
	TRACE(_T("LoadStringHelper(<%s> nLen = %d\n"),(LPCTSTR)sz,nLen);
	
	return hr;
}

HRESULT SaveDWordHelper(IStream* pStm, DWORD dw)
{
	ULONG nBytesWritten;
	HRESULT hr = pStm->Write((void*)&dw, sizeof(DWORD),&nBytesWritten);
	if (nBytesWritten < sizeof(DWORD))
		hr = STG_E_CANTSAVE;
	return hr;
}

HRESULT LoadDWordHelper(IStream* pStm, DWORD* pdw)
{
	ULONG nBytesRead;
	HRESULT hr = pStm->Read((void*)pdw,sizeof(DWORD), &nBytesRead);
	ASSERT(nBytesRead == sizeof(DWORD));
	return hr;
}



//////////////////////////////////////////////////////////////////////
// CDNSQueryFilterPageBase

class CDNSQueryFilterSheet; // fwd decl

class CDNSQueryFilterPageBase : public CPropertyPage
{
public:
  CDNSQueryFilterPageBase(UINT nIDD, CDNSQueryFilterSheet* pSheet)
     		: CPropertyPage(nIDD)
  {
    m_pSheet = pSheet;
    m_bDirty = FALSE;
    m_bInit = FALSE;
  }
protected:
  CDNSQueryFilterSheet* m_pSheet;

  void SetDirty();
  void Init();
  BOOL IsDirty() { return m_bDirty;}

  virtual BOOL OnInitDialog();

  afx_msg void OnContextMenu(CWnd* pWnd, CPoint point);
	afx_msg void OnWhatsThis();
  afx_msg BOOL OnHelp(WPARAM wParam, LPARAM lParam);

private:
  BOOL m_bInit;
  BOOL m_bDirty;

  HWND  m_hWndWhatsThis;  // hwnd of right click "What's this" help

  DECLARE_MESSAGE_MAP()
};



//////////////////////////////////////////////////////////////////////
// CDNSQueryFilterNamePage

class CDNSQueryFilterNamePage : public CDNSQueryFilterPageBase
{
public:
  CDNSQueryFilterNamePage(CDNSQueryFilterSheet* pSheet)
     		: CDNSQueryFilterPageBase(IDD_FILTERING_NAME, pSheet)
  {
  }

protected:
	virtual BOOL OnInitDialog();
	virtual BOOL OnApply();

  afx_msg void OnRadioClicked();
  afx_msg void OnEditChange();

private:
  CEdit* GetStartsStringEdit() { return (CEdit*)GetDlgItem(IDC_EDIT_FILTER_STARTS);}
  CEdit* GetContainsStringEdit() { return (CEdit*)GetDlgItem(IDC_EDIT_FILTER_CONTAINS);}
  CEdit* GetRangeFromStringEdit() { return (CEdit*)GetDlgItem(IDC_EDIT_FILTER_RANGE_FROM);}
  CEdit* GetRangeToStringEdit() { return (CEdit*)GetDlgItem(IDC_EDIT_FILTER_RANGE_TO);}

  CButton* GetRadioNone() { return (CButton*)GetDlgItem(IDC_RADIO_FILTER_NONE);}
  CButton* GetRadioStarts() { return (CButton*)GetDlgItem(IDC_RADIO_FILTER_STARTS);}
  CButton* GetRadioContains() { return (CButton*)GetDlgItem(IDC_RADIO_FILTER_CONTAINS);}
  CButton* GetRadioRange() { return (CButton*)GetDlgItem(IDC_RADIO_FILTER_RANGE);}

  // utility methods
  UINT GetSelectedRadioButtonID();
  void SyncControls(UINT nRadioID);
  void GetEditText(UINT nID, CString& s);

  DECLARE_MESSAGE_MAP()
};

//////////////////////////////////////////////////////////////////////
// CDNSQueryFilterAdvancedPage

class CDNSQueryFilterAdvancedPage : public CDNSQueryFilterPageBase
{
public:
  CDNSQueryFilterAdvancedPage(CDNSQueryFilterSheet* pSheet)
     		: CDNSQueryFilterPageBase(IDD_FILTERING_LIMITS, pSheet)
  {
  }

protected:
	virtual BOOL OnInitDialog();
	virtual BOOL OnApply();

  afx_msg void OnCountEditChange();

  CDNSUnsignedIntEdit m_maxCountEdit;

  DECLARE_MESSAGE_MAP()
};


//////////////////////////////////////////////////////////////////////
// CDNSQueryFilterSheet

class CDNSQueryFilterSheet : public CPropertySheet
{
public:
  CDNSQueryFilterSheet(CDNSQueryFilter* pQueryFilter, CComponentDataObject* pComponentData)
    : CPropertySheet(IDS_SNAPIN_FILTERING_TITLE),
      m_namePage(this), m_advancedPage(this), m_pComponentData(pComponentData)
  {
    m_psh.dwFlags |= PSH_NOAPPLYNOW;
    m_pQueryFilter = pQueryFilter;
    AddPage(&m_namePage);
    AddPage(&m_advancedPage);
    m_bInit = FALSE;
  }

  CDNSQueryFilter* GetQueryFilter() { return m_pQueryFilter;}
  CComponentDataObject* GetComponentData() { return m_pComponentData; }

  void SetSheetStyle()
  {
    DWORD dwStyle = ::GetWindowLong(GetSafeHwnd(), GWL_EXSTYLE);
    dwStyle |= WS_EX_CONTEXTHELP; // force the [?] button
    ::SetWindowLong(GetSafeHwnd(), GWL_EXSTYLE, dwStyle);
  }

private:
  void Init()
  {
    if (m_bInit)
      return;
    m_bInit = TRUE;
    CWnd* p = GetDlgItem(IDOK);
    if (p)
      p->EnableWindow(FALSE);
  }

  void SetDirty()
  {
    if (!m_bInit)
      return;
    GetDlgItem(IDOK)->EnableWindow(TRUE);
  }

  BOOL m_bInit;
  CComponentDataObject* m_pComponentData;
  CDNSQueryFilter* m_pQueryFilter;
  CDNSQueryFilterNamePage m_namePage;
  CDNSQueryFilterAdvancedPage m_advancedPage;

  friend class CDNSQueryFilterPageBase;
  friend class CDNSQueryFilterNamePage;
  friend class CDNSQueryFilterAdvancedPage;

};


//////////////////////////////////////////////////////////////////////
// CDNSQueryFilterPageBase IMPLEMENTATION

BOOL CDNSQueryFilterPageBase::OnInitDialog()
{
  BOOL bRet = CPropertyPage::OnInitDialog();

  m_pSheet->SetSheetStyle();

  return bRet;
}

void CDNSQueryFilterPageBase::SetDirty()
{
  if (!m_bInit)
    return;
  m_bDirty = TRUE;
  m_pSheet->SetDirty();
}


void CDNSQueryFilterPageBase::Init()
{
  m_bInit = TRUE;
  m_pSheet->Init();
}

BEGIN_MESSAGE_MAP(CDNSQueryFilterPageBase, CPropertyPage)
	ON_WM_CONTEXTMENU()
  ON_MESSAGE(WM_HELP, OnHelp)
  ON_COMMAND(IDM_WHATS_THIS, OnWhatsThis)
END_MESSAGE_MAP()


void CDNSQueryFilterPageBase::OnWhatsThis()
{
  //
  // Display context help for a control
  //
  if ( m_hWndWhatsThis )
  {
    //
    // Build our own HELPINFO struct to pass to the underlying
    // CS help functions built into the framework
    //
    int iCtrlID = ::GetDlgCtrlID(m_hWndWhatsThis);
    HELPINFO helpInfo;
    ZeroMemory(&helpInfo, sizeof(HELPINFO));
    helpInfo.cbSize = sizeof(HELPINFO);
    helpInfo.hItemHandle = m_hWndWhatsThis;
    helpInfo.iCtrlId = iCtrlID;

	  m_pSheet->GetComponentData()->OnDialogContextHelp(m_nIDHelp, &helpInfo);
  }
}

BOOL CDNSQueryFilterPageBase::OnHelp(WPARAM /*wParam*/, LPARAM lParam)
{
  const LPHELPINFO pHelpInfo = (LPHELPINFO)lParam;

  if (pHelpInfo && pHelpInfo->iContextType == HELPINFO_WINDOW)
  {
    //
    // Display context help for a control
    //
	  m_pSheet->GetComponentData()->OnDialogContextHelp(m_nIDHelp, pHelpInfo);
  }

  return TRUE;
}

void CDNSQueryFilterPageBase::OnContextMenu(CWnd* /*pWnd*/, CPoint point) 
{
  //
  // point is in screen coordinates
  //

  CMenu bar;
	if ( bar.LoadMenu(IDR_WHATS_THIS_CONTEXT_MENU1) )
	{
		CMenu& popup = *bar.GetSubMenu (0);
		ASSERT(popup.m_hMenu);

		if ( popup.TrackPopupMenu (TPM_RIGHTBUTTON | TPM_LEFTBUTTON,
			   point.x,     // in screen coordinates
				 point.y,     // in screen coordinates
			   this) )      // route commands through main window
		{
			m_hWndWhatsThis = 0;
			ScreenToClient (&point);
			CWnd* pChild = ChildWindowFromPoint (point,  // in client coordinates
					                                 CWP_SKIPINVISIBLE | CWP_SKIPTRANSPARENT);
			if ( pChild )
      {
				m_hWndWhatsThis = pChild->m_hWnd;
      }
	  }
	}
}

//////////////////////////////////////////////////////////////////////
// CDNSQueryFilterNamePage IMPLEMENTATION

BEGIN_MESSAGE_MAP(CDNSQueryFilterNamePage, CDNSQueryFilterPageBase)
	ON_BN_CLICKED(IDC_RADIO_FILTER_NONE, OnRadioClicked)
	ON_BN_CLICKED(IDC_RADIO_FILTER_STARTS, OnRadioClicked)
  ON_BN_CLICKED(IDC_RADIO_FILTER_CONTAINS, OnRadioClicked)
  ON_BN_CLICKED(IDC_RADIO_FILTER_RANGE, OnRadioClicked)

  ON_EN_CHANGE(IDC_EDIT_FILTER_STARTS, OnEditChange)
  ON_EN_CHANGE(IDC_EDIT_FILTER_CONTAINS, OnEditChange)
  ON_EN_CHANGE(IDC_EDIT_FILTER_RANGE_FROM, OnEditChange)
  ON_EN_CHANGE(IDC_EDIT_FILTER_RANGE_TO, OnEditChange)
END_MESSAGE_MAP()


UINT CDNSQueryFilterNamePage::GetSelectedRadioButtonID()
{
  return GetCheckedRadioButton(IDC_RADIO_FILTER_NONE, IDC_RADIO_FILTER_RANGE);
}



void CDNSQueryFilterNamePage::OnRadioClicked()
{
  UINT nRadioID = GetSelectedRadioButtonID();
  SyncControls(nRadioID);
}

void CDNSQueryFilterNamePage::SyncControls(UINT nRadioID)
{
  BOOL bStartsStringEditEnabled = FALSE;
  BOOL bContainsStringEditEnabled = FALSE;
  BOOL bRangeEnabled = FALSE;

  if (nRadioID == IDC_RADIO_FILTER_STARTS)
  {
    bStartsStringEditEnabled = TRUE;
  }
  else if (nRadioID == IDC_RADIO_FILTER_CONTAINS)
  {
    bContainsStringEditEnabled = TRUE;
  }
  else if (nRadioID == IDC_RADIO_FILTER_RANGE)
  {
    bRangeEnabled = TRUE;
  }
  GetStartsStringEdit()->SetReadOnly(!bStartsStringEditEnabled);
  GetContainsStringEdit()->SetReadOnly(!bContainsStringEditEnabled);
  GetRangeFromStringEdit()->SetReadOnly(!bRangeEnabled);
  GetRangeToStringEdit()->SetReadOnly(!bRangeEnabled);

  SetDirty();
}

void CDNSQueryFilterNamePage::GetEditText(UINT nID, CString& s)
{
  GetDlgItemText(nID, s);
  s.TrimLeft();
  s.TrimRight();
}

void CDNSQueryFilterNamePage::OnEditChange()
{
  SetDirty();
}



BOOL CDNSQueryFilterNamePage::OnInitDialog()
{
	CDNSQueryFilterPageBase::OnInitDialog();

  // write data to edit fields
  SetDlgItemText(IDC_EDIT_FILTER_STARTS, m_pSheet->m_pQueryFilter->m_szStartsString);
  SetDlgItemText(IDC_EDIT_FILTER_CONTAINS, m_pSheet->m_pQueryFilter->m_szContainsString);
  SetDlgItemText(IDC_EDIT_FILTER_RANGE_FROM, m_pSheet->m_pQueryFilter->m_szRangeFrom);
  SetDlgItemText(IDC_EDIT_FILTER_RANGE_TO, m_pSheet->m_pQueryFilter->m_szRangeTo);

  // set the radio buttons
  UINT nRadioID = IDC_RADIO_FILTER_NONE;
  switch(m_pSheet->m_pQueryFilter->m_nFilterOption)
  {
  case DNS_QUERY_FILTER_NONE:
    {
      GetRadioNone()->SetCheck(TRUE);
      nRadioID = IDC_RADIO_FILTER_NONE;
    }
    break;
  case DNS_QUERY_FILTER_STARTS:
    {
      GetRadioStarts()->SetCheck(TRUE);
      nRadioID = IDC_RADIO_FILTER_STARTS;
    }
    break;
  case DNS_QUERY_FILTER_CONTAINS:
    {
      GetRadioContains()->SetCheck(TRUE);
      nRadioID = IDC_RADIO_FILTER_CONTAINS;
    }
    break;
  case DNS_QUERY_FILTER_RANGE:
    {
      GetRadioRange()->SetCheck(TRUE);
      nRadioID = IDC_RADIO_FILTER_RANGE;
    }
    break;

  default:
    ASSERT(FALSE);
  }

  // enable/disable the edit fields
  SyncControls(nRadioID);

  Init();

	return TRUE;  // return TRUE unless you set the focus to a control
}

BOOL CDNSQueryFilterNamePage::OnApply()
{
  if (!IsDirty())
    return TRUE;

  UINT nRadioID = GetSelectedRadioButtonID();

  // get data from edit controls
  GetEditText(IDC_EDIT_FILTER_STARTS, m_pSheet->m_pQueryFilter->m_szStartsString);
  GetEditText(IDC_EDIT_FILTER_CONTAINS, m_pSheet->m_pQueryFilter->m_szContainsString);
  GetEditText(IDC_EDIT_FILTER_RANGE_FROM, m_pSheet->m_pQueryFilter->m_szRangeFrom);
  GetEditText(IDC_EDIT_FILTER_RANGE_TO, m_pSheet->m_pQueryFilter->m_szRangeTo);

  // get radio button selection
  switch(nRadioID)
  {
  case IDC_RADIO_FILTER_NONE:
    {
      m_pSheet->m_pQueryFilter->m_nFilterOption = DNS_QUERY_FILTER_NONE;
    }
    break;
  case IDC_RADIO_FILTER_STARTS:
    {
      if (m_pSheet->m_pQueryFilter->m_szStartsString.IsEmpty())
        m_pSheet->m_pQueryFilter->m_nFilterOption = DNS_QUERY_FILTER_NONE;
      else
        m_pSheet->m_pQueryFilter->m_nFilterOption = DNS_QUERY_FILTER_STARTS;
    }
    break;
  case IDC_RADIO_FILTER_CONTAINS:
    {
      if (m_pSheet->m_pQueryFilter->m_szContainsString.IsEmpty())
        m_pSheet->m_pQueryFilter->m_nFilterOption = DNS_QUERY_FILTER_NONE;
      else
        m_pSheet->m_pQueryFilter->m_nFilterOption = DNS_QUERY_FILTER_CONTAINS;
    }
    break;
  case IDC_RADIO_FILTER_RANGE:
    {
      if (m_pSheet->m_pQueryFilter->m_szRangeFrom.IsEmpty() &&
          m_pSheet->m_pQueryFilter->m_szRangeTo.IsEmpty() )
        m_pSheet->m_pQueryFilter->m_nFilterOption = DNS_QUERY_FILTER_NONE;
      else
        m_pSheet->m_pQueryFilter->m_nFilterOption = DNS_QUERY_FILTER_RANGE;
    }
    break;
  default:
    ASSERT(FALSE);
  }

  return TRUE;
}



//////////////////////////////////////////////////////////////////////
// CDNSQueryFilterAdvancedPage IMPLEMENTATION

BEGIN_MESSAGE_MAP(CDNSQueryFilterAdvancedPage, CDNSQueryFilterPageBase)
  ON_EN_CHANGE(IDC_EDIT_COUNT, OnCountEditChange)
END_MESSAGE_MAP()

void CDNSQueryFilterAdvancedPage::OnCountEditChange()
{
  SetDirty();
}

BOOL CDNSQueryFilterAdvancedPage::OnInitDialog()
{
  CDNSQueryFilterPageBase::OnInitDialog();

  // set the range of the edit control for range validation
  VERIFY(m_maxCountEdit.SubclassDlgItem(IDC_EDIT_COUNT, this));
  m_maxCountEdit.SetRange(DNS_QUERY_OBJ_COUNT_MIN, DNS_QUERY_OBJ_COUNT_MAX);

  // Disable IME support on the control
  ImmAssociateContext(m_maxCountEdit.GetSafeHwnd(), NULL);

  // set limit on the # of digits based on the max value
  CString s;
  s.Format(_T("%u"), DNS_QUERY_OBJ_COUNT_MAX);
  m_maxCountEdit.LimitText(s.GetLength());

  // set the value
  m_maxCountEdit.SetVal(m_pSheet->m_pQueryFilter->m_nMaxObjectCount);

  Init();

  return TRUE;
}

BOOL CDNSQueryFilterAdvancedPage::OnApply()
{
  if (!IsDirty())
    return TRUE;

  m_pSheet->m_pQueryFilter->m_nMaxObjectCount = m_maxCountEdit.GetVal();

  return TRUE;
}

//////////////////////////////////////////////////////////////////////
// CDNSQueryFilter

BOOL CDNSQueryFilter::EditFilteringOptions(CComponentDataObject* pComponentData)
{
  CDNSQueryFilterSheet dlg(this, pComponentData);
  return IDOK == dlg.DoModal();
}

HRESULT CDNSQueryFilter::Load(IStream* pStm)
{
  HRESULT hr;
  // name filtering
  if (FAILED(hr = LoadDWordHelper(pStm, (DWORD*)(&m_nFilterOption))))
    return hr;

  if (FAILED(hr = LoadStringHelper(m_szStartsString, pStm)))
    return hr;
  if (FAILED(hr = LoadStringHelper(m_szContainsString, pStm)))
    return hr;
  if (FAILED(hr = LoadStringHelper(m_szRangeFrom, pStm)))
    return hr;
  if (FAILED(hr = LoadStringHelper(m_szRangeTo, pStm)))
    return hr;

  // query limit
  if (FAILED(hr = LoadDWordHelper(pStm, (DWORD*)(&m_nMaxObjectCount))))
    return hr;
  return LoadDWordHelper(pStm, (DWORD*)(&m_bGetAll));
}

HRESULT CDNSQueryFilter::Save(IStream* pStm)
{
  HRESULT hr;

  // name filtering
  if (FAILED(hr = SaveDWordHelper(pStm, (DWORD)m_nFilterOption)))
    return hr;

  if (FAILED(hr = SaveStringHelper(m_szStartsString, pStm)))
    return hr;
  if (FAILED(hr = SaveStringHelper(m_szContainsString, pStm)))
    return hr;
  if (FAILED(hr = SaveStringHelper(m_szRangeFrom, pStm)))
    return hr;
  if (FAILED(hr = SaveStringHelper(m_szRangeTo, pStm)))
    return hr;

  // query limit
  if (FAILED(hr = SaveDWordHelper(pStm, (DWORD)(m_nMaxObjectCount))))
    return hr;
  return SaveDWordHelper(pStm, (DWORD)(m_bGetAll));

}


//////////////////////////////////////////////////////////////////////
// CDNSRootData

const GUID CDNSRootData::NodeTypeGUID =
{ 0x2faebfa3, 0x3f1a, 0x11d0, { 0x8c, 0x65, 0x0, 0xc0, 0x4f, 0xd8, 0xfe, 0xcb } };

BEGIN_TOOLBAR_MAP(CDNSRootData)
  TOOLBAR_EVENT(toolbarNewServer, OnConnectToServer)
END_TOOLBAR_MAP()

CDNSRootData::CDNSRootData(CComponentDataObject* pComponentData) : CRootData(pComponentData)
{
	m_bAdvancedView = FALSE;
  m_pColumnSet = NULL;
  m_szDescriptionBar = _T("");
  m_bCreatePTRWithHost = FALSE;
}

CDNSRootData::~CDNSRootData()
{
	TRACE(_T("~CDNSRootData(), name <%s>\n"),GetDisplayName());
}



STDAPI DnsSetup(LPCWSTR lpszFwdZoneName,
                 LPCWSTR lpszFwdZoneFileName,
                 LPCWSTR lpszRevZoneName,
                 LPCWSTR lpszRevZoneFileName,
                 DWORD dwFlags);

BOOL CDNSRootData::OnAddMenuItem(LPCONTEXTMENUITEM2 pContextMenuItem2, 
                                 long*)
{
	CComponentDataObject* pComponentData = GetComponentDataObject();
	if (pContextMenuItem2->lCommandID == IDM_SNAPIN_CONNECT_TO_SERVER)
	{
		ASSERT(pComponentData != NULL);

		if (pComponentData->IsExtensionSnapin())
			return FALSE; // extensions do not have this menu item
		
		return TRUE;
	}
	// add toggle menu item for advanced view
	if (pContextMenuItem2->lCommandID == IDM_SNAPIN_ADVANCED_VIEW)
  {
    pContextMenuItem2->fFlags = IsAdvancedView() ? MF_CHECKED : 0;
  }
  if (pContextMenuItem2->lCommandID == IDM_SNAPIN_FILTERING)
  {
		if (IsFilteringEnabled())
		{
			pContextMenuItem2->fFlags = MF_CHECKED;
		}
		return TRUE;
  }
	return TRUE;
}

HRESULT CDNSRootData::GetResultViewType(CComponentDataObject*, 
                                        LPOLESTR *ppViewType, 
                                        long *pViewOptions)
{
  HRESULT hr = S_FALSE;

  if (m_containerChildList.IsEmpty() && m_leafChildList.IsEmpty())
  {
    *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 CDNSRootData::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))
  {
    // Load and set the title text of the message view
    CString szTitle;
    VERIFY(szTitle.LoadString(IDS_MESSAGE_VIEW_NO_SERVER_TITLE));
    spMessageView->SetTitleText(szTitle);

    // Load and set the body text of the message view
    CString szMessage;
    VERIFY(szMessage.LoadString(IDS_MESSAGE_VIEW_NO_SERVER_MESSAGE));
    spMessageView->SetBodyText(szMessage);

    // Use the standard information icon
    spMessageView->SetIcon(Icon_Information);
  }
  
  return S_OK;
}

BOOL CDNSRootData::IsFilteringEnabled()
{
	UINT nFilterOption = GetFilter()->GetFilterOption();
	if (nFilterOption == DNS_QUERY_FILTER_DISABLED || nFilterOption == DNS_QUERY_FILTER_NONE)
	{
		return FALSE;
	}
	return TRUE;
}

BOOL CDNSRootData::OnSetRefreshVerbState(DATA_OBJECT_TYPES, 
                                         BOOL* pbHide,
                                         CNodeList*)
{
	*pbHide = FALSE;
	return !IsThreadLocked();
}

HRESULT CDNSRootData::OnSetToolbarVerbState(IToolbar* pToolbar, 
                                              CNodeList*)
{
  HRESULT hr = S_OK;

  //
  // Set the button state for each button on the toolbar
  //
  hr = pToolbar->SetButtonState(toolbarNewServer, ENABLED, TRUE);
  ASSERT(SUCCEEDED(hr));

  hr = pToolbar->SetButtonState(toolbarNewRecord, ENABLED, FALSE);
  ASSERT(SUCCEEDED(hr));

  hr = pToolbar->SetButtonState(toolbarNewZone, ENABLED, FALSE);
  ASSERT(SUCCEEDED(hr));

  return hr;
}  

HRESULT CDNSRootData::OnCommand(long nCommandID, 
                                DATA_OBJECT_TYPES,
								                CComponentDataObject* pComponentData,
                                CNodeList* pNodeList)
{
  if (pNodeList->GetCount() > 1) // multiple selection
  {
    return E_FAIL;
  }

	switch (nCommandID)
	{
		case IDM_SNAPIN_CONNECT_TO_SERVER:
			OnConnectToServer(pComponentData, pNodeList);
			break;
		case IDM_SNAPIN_ADVANCED_VIEW:
			OnViewOptions(pComponentData);
			break;
		case IDM_SNAPIN_FILTERING:
      {
        if (OnFilteringOptions(pComponentData))
        {
          pComponentData->SetDescriptionBarText(this);
        }
      }
      break;
		default:
			ASSERT(FALSE); // Unknown command!
			return E_FAIL;
	}
    return S_OK;
}


BOOL CDNSRootData::OnEnumerate(CComponentDataObject* pComponentData, BOOL)
{
	if (m_containerChildList.IsEmpty())
	{
		// the list is empty, need to add
		ASSERT(pComponentData != NULL);
		// create a modal dialog + possibly the wizard proper
		AFX_MANAGE_STATE(AfxGetStaticModuleState());
		CDNSServerWizardHolder holder(this, pComponentData, NULL);
		holder.DoModalConnectOnLocalComputer();
		return FALSE;
	}
	return TRUE; // there are already children, add them to the UI now
}


#define DNS_STREAM_VERSION_W2K ((DWORD)0x06)
#define DNS_STREAM_VERSION     ((DWORD)0x07)

// IStream manipulation helpers overrides
HRESULT CDNSRootData::Load(IStream* pStm)
{
	// assume never get multiple loads
	if(!m_containerChildList.IsEmpty() || !m_leafChildList.IsEmpty())
		return E_FAIL;

	WCHAR szBuffer[256];
	ULONG nLen; // WCHAR counting NULL

	UINT nCount;
	ULONG cbRead;
	// read the version ##
	DWORD dwVersion;
	VERIFY(SUCCEEDED(pStm->Read((void*)&dwVersion,sizeof(DWORD), &cbRead)));
	ASSERT(cbRead == sizeof(DWORD));
	if (dwVersion != DNS_STREAM_VERSION && dwVersion != DNS_STREAM_VERSION_W2K)
		return E_FAIL;

  // load filtering options
  VERIFY(SUCCEEDED(m_filterObj.Load(pStm)));

	// load view option
	VERIFY(SUCCEEDED(pStm->Read((void*)&m_bAdvancedView,sizeof(BOOL), &cbRead)));
	ASSERT(cbRead == sizeof(BOOL));

  //
  // load the Create PTR record with host flag
  //
  if (dwVersion > DNS_STREAM_VERSION_W2K)
  {
	  VERIFY(SUCCEEDED(pStm->Read((void*)&m_bCreatePTRWithHost,sizeof(BOOL), &cbRead)));
	  ASSERT(cbRead == sizeof(BOOL));
  }

	// load the name of the snapin root display string
	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);
	SetDisplayName(szBuffer);
	
	// load the list of servers
	VERIFY(SUCCEEDED(pStm->Read((void*)&nCount,sizeof(UINT), &cbRead)));
	ASSERT(cbRead == sizeof(UINT));

	CComponentDataObject* pComponentData = GetComponentDataObject();
	for (int k=0; k< (int)nCount; k++)
	{
		CDNSServerNode* p = NULL;
		VERIFY(SUCCEEDED(CDNSServerNode::CreateFromStream(pStm, &p)));
		ASSERT(p != NULL);
		VERIFY(AddChildToList(p));
		AddServerToThreadList(p, pComponentData);
	}
	if (nCount > 0)
		MarkEnumerated();
	ASSERT(m_containerChildList.GetCount() == (int)nCount);

	return S_OK;
}

HRESULT CDNSRootData::Save(IStream* pStm, BOOL fClearDirty)
{
	UINT nCount;
	ULONG cbWrite;
	// write the version ##
	DWORD dwVersion = DNS_STREAM_VERSION;
	VERIFY(SUCCEEDED(pStm->Write((void*)&dwVersion, sizeof(DWORD),&cbWrite)));
	ASSERT(cbWrite == sizeof(DWORD));

  // save filtering options
  VERIFY(SUCCEEDED(m_filterObj.Save(pStm)));

	// save view options
	VERIFY(SUCCEEDED(pStm->Write((void*)&m_bAdvancedView, sizeof(BOOL),&cbWrite)));
	ASSERT(cbWrite == sizeof(BOOL));

  //
  // save the create PTR record with host flag
  //
	VERIFY(SUCCEEDED(pStm->Write((void*)&m_bCreatePTRWithHost, sizeof(BOOL),&cbWrite)));
	ASSERT(cbWrite == sizeof(BOOL));

	// save the name of the snapin root display string
	ULONG 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);

	// write # of servers
	nCount = (UINT)m_containerChildList.GetCount();
	VERIFY(SUCCEEDED(pStm->Write((void*)&nCount, sizeof(UINT),&cbWrite)));
	ASSERT(cbWrite == sizeof(UINT));

	// loop through the list of servers and serialize them
	POSITION pos;
	for (pos = m_containerChildList.GetHeadPosition(); pos != NULL; )
	{
		CDNSServerNode* pServerNode = (CDNSServerNode*)m_containerChildList.GetNext(pos);
		VERIFY(SUCCEEDED(pServerNode->SaveToStream(pStm)));
	}

	if (fClearDirty)
		SetDirtyFlag(FALSE);
	return S_OK;
}


HRESULT CDNSRootData::IsDirty()
{
  return CRootData::IsDirty();
}


HRESULT CDNSRootData::OnConnectToServer(CComponentDataObject* pComponentData,
                                        CNodeList*)
{
	ASSERT(pComponentData != NULL);
	// create a modal dialog + possibly the wizard proper
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	CDNSServerWizardHolder holder(this, pComponentData, NULL);
	holder.DoModalConnect();
  pComponentData->UpdateResultPaneView(this);
	return S_OK;
}

void CDNSRootData::AddServer(CDNSServerNode* p, CComponentDataObject* pComponentData)
{
	ASSERT(p != NULL);
	AddChildToListAndUISorted(p, pComponentData);
	AddServerToThreadList(p, pComponentData);
  pComponentData->UpdateResultPaneView(this);
  pComponentData->SetDescriptionBarText(this);
}


BOOL CDNSRootData::VerifyServerName(LPCTSTR lpszServerName)
{
	POSITION pos;
	for (pos = m_containerChildList.GetHeadPosition(); pos != NULL; )
	{
		CTreeNode* pNode = m_containerChildList.GetNext(pos);
		ASSERT(pNode->IsContainer());

    //
		// case insensitive compare
    //
		if (_wcsicmp(pNode->GetDisplayName(), lpszServerName) == 0)
    {
			return FALSE;
    }
	}
	return TRUE;
}


BOOL CDNSRootData::OnViewOptions(CComponentDataObject* pComponentData)
{

	// make sure there are not property sheets up: we do this because:
	// a) some folders might be removed and might have sheets up
	// b) some RR property pages (PTR) might not be switchable
	//    on the fly between view types
	if (IsSheetLocked())
	{
		if (!CanCloseSheets())
			return TRUE;
		pComponentData->GetPropertyPageHolderTable()->DeleteSheetsOfNode(this);
	}
	ASSERT(!IsSheetLocked());
	
	// toggle the view state
	m_bAdvancedView = !m_bAdvancedView;

	// loop through the servers
	POSITION pos;
	for (pos = m_containerChildList.GetHeadPosition(); pos != NULL; )
	{
		CTreeNode* pNode = m_containerChildList.GetNext(pos);
		ASSERT(pNode->IsContainer());
		CDNSServerNode* pServerNode = (CDNSServerNode*)pNode;
		// pass the new view option
		pServerNode->ChangeViewOption(m_bAdvancedView, pComponentData);
	}
	// dirty the MMC document
	SetDirtyFlag(TRUE);
	return TRUE;
}



BOOL CDNSRootData::OnFilteringOptions(CComponentDataObject* pComponentData)
{
  BOOL bRet = m_filterObj.EditFilteringOptions(pComponentData);
  if (bRet)
  {
    SetDirtyFlag(TRUE);
  }
  return bRet;
}


BOOL CDNSRootData::CanCloseSheets()
{
	return (IDCANCEL != DNSMessageBox(IDS_MSG_CONT_CLOSE_SHEET, MB_OKCANCEL));
}

BOOL CDNSRootData::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;
  }

	if (IsSheetLocked())
	{
		if (!CanCloseSheets())
			return FALSE;
		pComponentData->GetPropertyPageHolderTable()->DeleteSheetsOfNode(this);
	}
	ASSERT(!IsSheetLocked());

	POSITION pos;
	for (pos = m_containerChildList.GetHeadPosition(); pos != NULL; )
	{
		CTreeNode* pNode = m_containerChildList.GetNext(pos);
		ASSERT(pNode->IsContainer());

    CNodeList nodeList;
    nodeList.AddTail(pNode);
		((CDNSServerNode*)pNode)->OnRefresh(pComponentData, &nodeList);
	}
	return TRUE;
}

LPWSTR CDNSRootData::GetDescriptionBarText()
{
  static CString szFilterEnabled;
  static CString szServersFormat;

  INT_PTR nContainerCount = GetContainerChildList()->GetCount();
  INT_PTR nLeafCount = GetLeafChildList()->GetCount();

  //
  // If not already loaded, then load the format string L"%d record(s)"
  //
  if (szServersFormat.IsEmpty())
  {
    szServersFormat.LoadString(IDS_FORMAT_SERVERS);
  }

  //
  // Format the child count into the description bar text
  //
  m_szDescriptionBar.Format(szServersFormat, nContainerCount + nLeafCount);

  //
  // Add L"[Filter Activated]" if the filter is on
  //
  if(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;
}

void CDNSRootData::TestServers(DWORD dwCurrTime, DWORD dwTimeInterval,
							   CComponentDataObject* pComponentData)
{
	//TRACE(_T("CDNSRootData::TestServers()\n"));
	POSITION pos;
	for (pos = m_containerChildList.GetHeadPosition(); pos != NULL; )
	{
		CTreeNode* pNode = m_containerChildList.GetNext(pos);
		ASSERT(pNode->IsContainer());
		CDNSServerNode* pServerNode = (CDNSServerNode*)pNode;
		if (pServerNode->IsTestEnabled() && !pServerNode->m_bTestQueryPending
							&& (pServerNode->m_dwTestTime <= dwCurrTime))
		{
			DWORD dwQueryFlags =
				CDNSServerTestQueryResult::Pack(pServerNode->IsTestSimpleQueryEnabled(),
												pServerNode->IsRecursiveQueryEnabled());
			pComponentData->PostMessageToTimerThread(WM_TIMER_THREAD_SEND_QUERY,
													(WPARAM)pServerNode,
													(WPARAM)dwQueryFlags);
			pServerNode->m_dwTestTime = dwCurrTime + pServerNode->GetTestInterval();
		}
	}

	// check if the time counter has wrapped (it should be very unlikely, because
	// the timeline is on a DWORD in seconds (about 47000 days) from the console startup.
	if ((dwCurrTime + dwTimeInterval) < dwCurrTime)
	{
		// just reset the whole set of server times (not accurate, but acceptable)
		for (pos = m_containerChildList.GetHeadPosition(); pos != NULL; )
		{
			CTreeNode* pNode = m_containerChildList.GetNext(pos);
			ASSERT(pNode->IsContainer());
			CDNSServerNode* pServerNode = (CDNSServerNode*)pNode;
			pServerNode->m_dwTestTime = 0;
		}
	}
}

void CDNSRootData::OnServerTestData(WPARAM wParam, LPARAM lParam, CComponentDataObject* pComponentData)
{
	ASSERT(lParam == 0);
	CDNSServerTestQueryResult* pTestResult = (CDNSServerTestQueryResult*)wParam;
	ASSERT(pTestResult != NULL);

	// loop through the list of servers to find where it belongs
	POSITION pos;
	for (pos = m_containerChildList.GetHeadPosition(); pos != NULL; )
	{
		CTreeNode* pNode = m_containerChildList.GetNext(pos);
		ASSERT(pNode->IsContainer());
		CDNSServerNode* pServerNode = (CDNSServerNode*)pNode;
		if ( (CDNSServerNode*)(pTestResult->m_serverCookie) == pServerNode)
		{
			pServerNode->AddTestQueryResult(pTestResult, pComponentData);
			return;
		}
	}
}

void CDNSRootData::AddServerToThreadList(CDNSServerNode* pServerNode,
										 CComponentDataObject* pComponentData)
{
	CDNSServerTestQueryInfo* pInfo = new CDNSServerTestQueryInfo;
  if (pInfo)
  {
	  pInfo->m_szServerName = pServerNode->GetDisplayName();
	  pInfo->m_serverCookie = (MMC_COOKIE)pServerNode;
	  pComponentData->PostMessageToTimerThread(WM_TIMER_THREAD_ADD_SERVER, (WPARAM)pInfo,0);
  }
}

void CDNSRootData::RemoveServerFromThreadList(CDNSServerNode* pServerNode,
											  CComponentDataObject* pComponentData)
{
	WPARAM serverCookie = (WPARAM)pServerNode;
	pComponentData->PostMessageToTimerThread(WM_TIMER_THREAD_REMOVE_SERVER, serverCookie,0);
}


///////////////////////////////////////////////////////////////////
// CDNSServerTestTimerThread

int CDNSServerTestTimerThread::Run()
{
	MSG msg;
	// initialize the message pump
	::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
	
	// get let the main thread know we are entering the loop
	// (0,0) means just acknowkedge
	PostMessageToWnd(0,0);
	while(::GetMessage(&msg, NULL, 0, 0))
	{
		switch(msg.message)
		{
		case WM_TIMER_THREAD_SEND_QUERY:
		case WM_TIMER_THREAD_SEND_QUERY_TEST_NOW:
			{
				long serverCookie = (long)msg.wParam;
				ASSERT(serverCookie != NULL);
				POSITION pos;
				for (pos = m_serverInfoList.GetHeadPosition(); pos != NULL; )
				{
					CDNSServerTestQueryInfo* pCurrInfo =
								(CDNSServerTestQueryInfo*)m_serverInfoList.GetNext(pos);
					if (serverCookie == pCurrInfo->m_serverCookie)
					{
						OnExecuteQuery(pCurrInfo, (DWORD)msg.lParam,
							(msg.message == WM_TIMER_THREAD_SEND_QUERY_TEST_NOW));
						break;
					}
				}
			}				
			break;
		case WM_TIMER_THREAD_ADD_SERVER:
			{
				CDNSServerTestQueryInfo* pInfo = (CDNSServerTestQueryInfo*)msg.wParam;
				ASSERT(pInfo != NULL);
				m_serverInfoList.AddTail(pInfo);
			}
			break;
		case WM_TIMER_THREAD_REMOVE_SERVER:
			{
				long serverCookie = (long)msg.wParam;
				ASSERT(serverCookie != NULL);
				POSITION pos;
				POSITION posDel = NULL;
				CDNSServerTestQueryInfo* pInfo = NULL;
				for (pos = m_serverInfoList.GetHeadPosition(); pos != NULL; )
				{
					posDel = pos;
					CDNSServerTestQueryInfo* pCurrInfo =
								(CDNSServerTestQueryInfo*)m_serverInfoList.GetNext(pos);
					if (serverCookie == pCurrInfo->m_serverCookie)
					{
						pInfo = pCurrInfo;
						break;
					}
				}
				if (pInfo != NULL)
				{
					ASSERT(posDel != NULL);
					m_serverInfoList.RemoveAt(posDel);
					delete pInfo;
				}
			}
			break;
		//default:
			//ASSERT(FALSE);
		}
	}
	return 0;
}


void CDNSServerTestTimerThread::OnExecuteQuery(CDNSServerTestQueryInfo* pInfo,
											   DWORD dwQueryFlags,
											   BOOL bAsyncQuery)
{
	// initialize a query result object
	CDNSServerTestQueryResult* pTestResult = new CDNSServerTestQueryResult;
  if (!pTestResult)
  {
    return;
  }

	pTestResult->m_serverCookie = pInfo->m_serverCookie;
	pTestResult->m_dwQueryFlags = dwQueryFlags;
	pTestResult->m_bAsyncQuery = bAsyncQuery;
	::GetLocalTime(&(pTestResult->m_queryTime));

	// execute query
	BOOL bPlainQuery, bRecursiveQuery;
	CDNSServerTestQueryResult::Unpack(dwQueryFlags, &bPlainQuery, &bRecursiveQuery);

	IP_ADDRESS* ipArray;
	int nIPCount;
	pTestResult->m_dwAddressResolutionResult = FindIP(pInfo->m_szServerName, &ipArray, &nIPCount);

	if (pTestResult->m_dwAddressResolutionResult == 0)
	{
		ASSERT(ipArray != NULL);
		ASSERT(nIPCount > 0);
      PIP_ARRAY pipArr = (PIP_ARRAY)malloc(sizeof(DWORD)+sizeof(IP_ADDRESS)*nIPCount);
      if (pipArr && ipArray)
	  {
		  pipArr->AddrCount = nIPCount;
		  memcpy(pipArr->AddrArray, ipArray, sizeof(IP_ADDRESS)*nIPCount);

		  if (bPlainQuery)
		  {
			  pTestResult->m_dwPlainQueryResult = DoNothingQuery(pipArr, TRUE);
		  }
		  if (bRecursiveQuery)
		  {
			  pTestResult->m_dwRecursiveQueryResult = DoNothingQuery(pipArr, FALSE);
		  }
        free(pipArr);
        pipArr = 0;
	  }
	}

	if (!PostMessageToWnd((WPARAM)pTestResult, 0))
			delete pTestResult; // could not deliver

	if (ipArray != NULL)
		free(ipArray);
}

DNS_STATUS CDNSServerTestTimerThread::FindIP(LPCTSTR lpszServerName, IP_ADDRESS** pipArray, int* pnIPCount)
{
	DNS_STATUS dwErr = 0;
	*pipArray = NULL;
	*pnIPCount = 0;
	// try to see if the name is already an IP address
	IP_ADDRESS ipAddr = IPStringToAddr(lpszServerName);
	if (ipAddr != INADDR_NONE)
	{
		*pnIPCount = 1;
		*pipArray = (IP_ADDRESS*)malloc((*pnIPCount)*sizeof(IP_ADDRESS));
    if (*pipArray != NULL)
    {
		  *pipArray[0] = ipAddr;
    }
	}
	else
	{

    //
    // Originally we were doing a DnsQuery() to retrieve the IP address of the server so that we
    // could perform a query to that server to monitor its response.  The problem with this is that
    // if the user enters a single label hostname as the server and they are administering remotely
    // and the two machines have different domain suffixes, then the DnsQuery() to get the IP address
    // of the server would fail.  DnsQuery() appends the name of the Domain suffix to the single label
    // host name and then tries to resolve the using that FQDN which is incorrect.  So instead of 
    // performing a DnsQuery() to get the IP address, the following uses WSALookupServiceBegin(),
    // Next(), and End() to get the IP address.  This has a better chance of resolving the name because
    // it uses DNS, WINS, etc.  I am leaving in the old stuff just in case we run into some problems.
    //
	  HANDLE			  hLookup;
	  WSAQUERYSET 	qsQuery;
	  DWORD			    dwBufLen = 0;
	  GUID			 	  gHostAddrByName = SVCID_INET_HOSTADDRBYNAME;
    WSAQUERYSET*  pBuffer = NULL;

    //
    // Initialize the query structure
    //
	  memset(&qsQuery, 0, sizeof(WSAQUERYSET));
	  qsQuery.dwSize = sizeof(WSAQUERYSET);   // the dwSize field has to be initialised like this
	  qsQuery.dwNameSpace = NS_ALL;
	  qsQuery.lpServiceClassId = &gHostAddrByName;  // this is the GUID to perform forward name resolution (name to IP)
    qsQuery.lpszServiceInstanceName = (LPWSTR)lpszServerName; // this is the name queried for.

    hLookup = NULL;

    //
    // Get the handle for the query
    //
    int iStartupRet = 0;
	  int iResult = WSALookupServiceBegin(&qsQuery,LUP_RETURN_ALL,&hLookup);
    if (iResult != 0)
    {
      //
      // Find out what socket error it was
      //
      int iErrorRet = WSAGetLastError();

      //
      // If the service wasn't started try starting it
      //
      if (iErrorRet == WSANOTINITIALISED)
      {
        WSADATA wsaData;
        WORD wVersion = MAKEWORD(2,0);
        iStartupRet = WSAStartup(wVersion, &wsaData);
        if (iStartupRet == 0)
        {
          //
          // Startup succeeded, lets try to begin again
          //
          iResult = WSALookupServiceBegin(&qsQuery,LUP_RETURN_ALL,&hLookup);
        }
      }


      //
      // Clear the error
      //
      WSASetLastError(0);
    }

	  if(0 == iResult)
	  {
      //
      // Get the size of the first data block from the query
      //
		  iResult = WSALookupServiceNext(hLookup, LUP_RETURN_ALL | LUP_FLUSHCACHE, &dwBufLen,
												  pBuffer);

      //
      // Allocate the required space for the query data
      //
      pBuffer = (WSAQUERYSET*)malloc(dwBufLen);
      ASSERT(pBuffer != NULL);

      if (pBuffer == NULL)
      {
        return E_OUTOFMEMORY;
      }
      else
      {
        //
        // Get the first data block from the query
        //
        iResult = WSALookupServiceNext(hLookup, LUP_RETURN_ALL | LUP_FLUSHCACHE, &dwBufLen,
										  pBuffer);

        //
        // Loop through all the data in the query but stop if we get a valid IP address
        // for the remote machine.
        //
		    while(0 == iResult)
		    {
          if (pBuffer->lpcsaBuffer != NULL && pBuffer->lpcsaBuffer->RemoteAddr.lpSockaddr != NULL)
          {
            //
            // We are only interested in the socket address so get a pointer to the sockaddr structure
            //
            sockaddr_in* pSockAddr = (sockaddr_in*)pBuffer->lpcsaBuffer->RemoteAddr.lpSockaddr;
            ASSERT(pSockAddr != NULL);

            //
            // Pull the IP address of the remote machine and pack it into a DWORD
            //
            DWORD dwIP = 0;
            dwIP = pSockAddr->sin_addr.S_un.S_un_b.s_b1;
            dwIP |= pSockAddr->sin_addr.S_un.S_un_b.s_b2 << 8;
            dwIP |= pSockAddr->sin_addr.S_un.S_un_b.s_b3 << 16;
            dwIP |= pSockAddr->sin_addr.S_un.S_un_b.s_b4 << 24;

            //
            // Increment the IP count and allocate space for the address
            //
            (*pnIPCount)++;
       		  *pipArray = (IP_ADDRESS*)malloc((*pnIPCount)*sizeof(IP_ADDRESS));
            if (*pipArray != NULL)
            {

              //
              // Copy the IP address into the IP array
              //
      		    PIP_ADDRESS pCurrAddr = *pipArray;
              *pCurrAddr = dwIP;
            }

            //
            // Break since we were able to obtain an IP address
            //
            break;
          }

          //
          // Free the buffer if it is still there
          //
          if (pBuffer != NULL)
          {
            free(pBuffer);
            pBuffer = NULL;
            dwBufLen = 0;
          }

          //
          // Get the size of the next data block from the query
          //
          iResult = WSALookupServiceNext(hLookup, LUP_RETURN_ALL | LUP_FLUSHCACHE, &dwBufLen,
										  pBuffer);

          //
          // Allocate enough space for the next data block from the query
          //
          pBuffer = (WSAQUERYSET*)malloc(dwBufLen);
          ASSERT(pBuffer != NULL);

          //
          // Get the next data block from the query
          //
          iResult = WSALookupServiceNext(hLookup, LUP_RETURN_ALL, &dwBufLen,
										    pBuffer);
		    }

        //
        // Free the buffer if it hasn't already been freed
        //
        if (pBuffer != NULL)
        {
          free(pBuffer);
          pBuffer = NULL;
        }
	    }

      //
      // Close the handle to the query
      //
      iResult = WSALookupServiceEnd(hLookup);
      ASSERT(iResult == 0);

      //
      // If we didn't get an IP address return an error
      //
      dwErr = (*pnIPCount < 1) ? -1 : 0;

	  }
  }
	return dwErr;
}

DNS_STATUS CDNSServerTestTimerThread::DoNothingQuery(PIP_ARRAY pipArr, BOOL bSimple)
{
	PDNS_RECORD pRecordList = NULL;
	DNS_STATUS dwErr = 0;
	if (bSimple)
	{
		dwErr = ::DnsQuery(_T("1.0.0.127.in-addr.arpa"),
					DNS_TYPE_PTR,
					DNS_QUERY_NO_RECURSION | DNS_QUERY_BYPASS_CACHE | DNS_QUERY_ACCEPT_PARTIAL_UDP,
					pipArr, &pRecordList, NULL);
	}
	else
	{
		dwErr = ::DnsQuery(_T("."),
					DNS_TYPE_NS,
					DNS_QUERY_STANDARD | DNS_QUERY_BYPASS_CACHE | DNS_QUERY_ACCEPT_PARTIAL_UDP,
					pipArr, &pRecordList, NULL);
	}
	if (pRecordList != NULL)
		::DnsRecordListFree(pRecordList, DnsFreeRecordListDeep);
	return dwErr;
}