archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
4.9 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/admin/snapin/domain/cdomain.cpp

2007 lines
55 KiB
Raw Permalink Blame History

//+-------------------------------------------------------------------------
//
// Microsoft Windows
//
// Copyright (C) Microsoft Corporation, 1998 - 1999
//
// File: cdomain.cpp
//
//--------------------------------------------------------------------------
#include "stdafx.h"
//#include "afxdlgs.h"
#include <lm.h>
#include "activeds.h"
#include <dnsapi.h> // for DnsFlushResolverCache()
#include "domobj.h"
#include "Cdomain.h"
#include "DataObj.h"
#include "notify.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#define DOMADMIN_LINKED_HELP_FILE L"ADconcepts.chm"
#define DOMADMIN_SNAPIN_HELP_FILE L"domadmin.chm"
int _MessageBox(HWND hWnd, // handle to owner window
LPCTSTR lpText, // pointer to text in message box
UINT uType); // style of message box
/////////////////////////////////////////////////////////////////////////////
// macros
#define ARRAYLEN(x) (sizeof(x) / sizeof((x)[0]))
/////////////////////////////////////////////////////////////////////////////
// constants
// {19B9A3F8-F975-11d1-97AD-00A0C9A06D2D}
static const GUID CLSID_DomainSnapinAbout =
{ 0x19b9a3f8, 0xf975, 0x11d1, { 0x97, 0xad, 0x0, 0xa0, 0xc9, 0xa0, 0x6d, 0x2d } };
const CLSID CLSID_DomainAdmin = { /* ebc53a38-a23f-11d0-b09b-00c04fd8dca6 */
0xebc53a38,
0xa23f,
0x11d0,
{0xb0, 0x9b, 0x00, 0xc0, 0x4f, 0xd8, 0xdc, 0xa6}
};
const GUID cDefaultNodeType = { /* 4c06495e-a241-11d0-b09b-00c04fd8dca6 */
0x4c06495e,
0xa241,
0x11d0,
{0xb0, 0x9b, 0x00, 0xc0, 0x4f, 0xd8, 0xdc, 0xa6}
};
const wchar_t* cszDefaultNodeType = _T("4c06495e-a241-11d0-b09b-00c04fd8dca6");
// Internal private format
const wchar_t* CCF_DS_DOMAIN_TREE_SNAPIN_INTERNAL = L"DS_DOMAIN_TREE_SNAPIN_INTERNAL";
/////////////////////////////////////////////////////////////////////////////
// global functions
//forward decl
void PrintColumn(
PADS_SEARCH_COLUMN pColumn,
LPWSTR pszColumnName
);
BOOL IsMMCMultiSelectDataObject(IDataObject* pDataObject)
{
if (pDataObject == NULL)
return FALSE;
static UINT s_cf = 0;
if (s_cf == 0)
{
USES_CONVERSION;
s_cf = RegisterClipboardFormat(W2T(CCF_MMC_MULTISELECT_DATAOBJECT));
}
FORMATETC fmt = {(CLIPFORMAT)s_cf, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
return (pDataObject->QueryGetData(&fmt) == S_OK);
}
#define NEXT_HELP_TABLE_ENTRY(p) ((p)+2)
#define TABLE_ENTRY_CTRL_ID(p) (*p)
#define TABLE_ENTRY_HELP_ID(p) (*(p+1))
#define IS_LAST_TABLE_ENTRY(p) (TABLE_ENTRY_CTRL_ID(p) == 0)
BOOL FindDialogContextTopic(/*IN*/ DWORD* pTable,
/*IN*/ HELPINFO* pHelpInfo,
/*OUT*/ ULONG* pnContextTopic)
{
ASSERT(pHelpInfo != NULL);
*pnContextTopic = 0;
// look inside the table
while (!IS_LAST_TABLE_ENTRY(pTable))
{
if (TABLE_ENTRY_CTRL_ID(pTable) == (DWORD)pHelpInfo->iCtrlId)
{
*pnContextTopic = TABLE_ENTRY_HELP_ID(pTable);
return TRUE;
}
pTable = NEXT_HELP_TABLE_ENTRY(pTable);
}
return FALSE;
}
void DialogContextHelp(DWORD* pTable, HELPINFO* pHelpInfo)
{
ULONG nContextTopic;
if (FindDialogContextTopic(pTable, pHelpInfo, &nContextTopic))
{
CString szHelpFilePath;
LPTSTR lpszBuffer = szHelpFilePath.GetBuffer(2*MAX_PATH+1);
UINT nLen = ::GetSystemWindowsDirectory(lpszBuffer, 2*MAX_PATH);
if (nLen == 0)
return;
// NOTICE-2002/03/07-ericb - SecurityPush: using wcsncpy now. GetBuffer above null terminates the buffer.
wcsncpy(&lpszBuffer[nLen], L"\\HELP\\DOMADMIN.HLP", 2*MAX_PATH - nLen);
szHelpFilePath.ReleaseBuffer();
::WinHelp((HWND) pHelpInfo->hItemHandle,
szHelpFilePath, HELP_CONTEXTPOPUP, nContextTopic);
}
}
LPCWSTR GetServerNameFromCommandLine()
{
const WCHAR szOverrideSrvCommandLine[] = L"/Server="; // Not subject to localization
const int cchOverrideSrvCommandLine = (sizeof(szOverrideSrvCommandLine)/sizeof(WCHAR)) - 1;
static CString g_strOverrideServerName;
// retrieve the command line arguments
LPCWSTR* lpServiceArgVectors; // Array of pointers to string
int cArgs = 0; // Count of arguments
lpServiceArgVectors = (LPCWSTR *)CommandLineToArgvW(GetCommandLineW(), OUT &cArgs);
if (lpServiceArgVectors == NULL)
{
return NULL;
}
CString str;
for (int i = 1; i < cArgs; i++)
{
ASSERT(lpServiceArgVectors[i] != NULL);
str = lpServiceArgVectors[i]; // Copy the string
TRACE (_T("command line arg: %s\n"), lpServiceArgVectors[i]);
str = str.Left(cchOverrideSrvCommandLine);
if (str.CompareNoCase(szOverrideSrvCommandLine) == 0)
{
g_strOverrideServerName = lpServiceArgVectors[i] + cchOverrideSrvCommandLine;
break;
}
} // for
LocalFree(lpServiceArgVectors);
TRACE(L"GetServerNameFromCommandLine() returning <%s>\n", (LPCWSTR)g_strOverrideServerName);
return g_strOverrideServerName.IsEmpty() ? NULL : (LPCWSTR)g_strOverrideServerName;
}
/////////////////////////////////////////////////////////////////////////////
// CInternalFormatCracker
BOOL CInternalFormatCracker::Extract(LPDATAOBJECT lpDataObject)
{
if (m_pInternalFormat != NULL)
{
FREE_INTERNAL(m_pInternalFormat);
m_pInternalFormat = NULL;
}
if (lpDataObject == NULL)
return FALSE;
STGMEDIUM stgmedium = { TYMED_HGLOBAL, NULL };
FORMATETC formatetc = { (CLIPFORMAT)CDataObject::m_cfInternal, NULL,
DVASPECT_CONTENT, -1, TYMED_HGLOBAL
};
// Allocate memory for the stream
stgmedium.hGlobal = ::GlobalAlloc(GMEM_SHARE, sizeof(INTERNAL));
// Attempt to get data from the object
do
{
if (stgmedium.hGlobal == NULL)
break;
if (FAILED(lpDataObject->GetDataHere(&formatetc, &stgmedium)))
break;
m_pInternalFormat = reinterpret_cast<INTERNAL*>(stgmedium.hGlobal);
if (m_pInternalFormat == NULL)
return FALSE;
} while (FALSE);
return TRUE;
}
BOOL CInternalFormatCracker::GetContext(LPDATAOBJECT pDataObject, // input
CFolderObject** ppFolderObject, // output
DATA_OBJECT_TYPES* pType // output
)
{
*ppFolderObject = NULL;
*pType = CCT_UNINITIALIZED;
BOOL bRet = FALSE;
if (!Extract(pDataObject))
return bRet;
// have to figure out which kind of cookie we have
if ( (GetInternal()->m_type == CCT_RESULT) || (GetInternal()->m_type == CCT_SCOPE) )
{
if (GetInternal()->m_cookie == 0)
{
// this is the root
*ppFolderObject = m_pCD->GetRootFolder();
bRet = TRUE;
}
else
{
// regular cookie (scope or result pane)
*ppFolderObject = reinterpret_cast<CFolderObject*>(GetInternal()->m_cookie);
_ASSERTE(*ppFolderObject != NULL);
*pType = GetInternal()->m_type;
bRet = TRUE;
}
}
else if (GetInternal()->m_type == CCT_UNINITIALIZED)
{
// no data in the object, just ignore
if(GetInternal()->m_cookie == -1)
{
bRet = TRUE;
}
else
{
// secondary page cookie
*ppFolderObject = reinterpret_cast<CFolderObject*>(GetInternal()->m_cookie);
bRet = TRUE;
}
}
else //CCT_SNAPIN_MANAGER
{
ASSERT(GetInternal()->m_type == CCT_SNAPIN_MANAGER);
bRet = TRUE;
*pType = GetInternal()->m_type;
}
return bRet;
}
///////////////////////////////////////////////////////////////////////////////
////////////////////////// CComponentDataImpl (i.e. scope pane side) //////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// IComponentData implementation
DEBUG_DECLARE_INSTANCE_COUNTER(CComponentDataImpl);
CComponentDataImpl::CComponentDataImpl() : m_rootFolder(this)
{
DEBUG_INCREMENT_INSTANCE_COUNTER(CComponentDataImpl);
m_bInitSuccess = FALSE;
m_hDomainIcon = NULL;
m_pConsoleNameSpace = NULL;
m_pConsole = NULL;
/* HACK WARNING: this is a gross hack to get around a blunder
in dsuiext.dll. in order to see get DS extension information,
we MUST have USERDNSDOMAIN set in the environment
*/
{
WCHAR * pszUDD = NULL;
pszUDD = _wgetenv (L"USERDNSDOMAIN");
if (pszUDD == NULL) {
_wputenv (L"USERDNSDOMAIN=not-present");
}
}
}
HRESULT CComponentDataImpl::FinalConstruct()
{
// create and initialize hidden window
m_pHiddenWnd = new CHiddenWnd(this);
ASSERT(m_pHiddenWnd);
if (!m_pHiddenWnd->Create())
{
TRACE(_T("Failed to create hidden window\n"));
ASSERT(FALSE);
}
return S_OK;
}
CComponentDataImpl::~CComponentDataImpl()
{
DEBUG_DECREMENT_INSTANCE_COUNTER(CComponentDataImpl);
ASSERT(m_pConsoleNameSpace == NULL);
}
void CComponentDataImpl::FinalRelease()
{
_DeleteHiddenWnd();
}
STDMETHODIMP CComponentDataImpl::Initialize(LPUNKNOWN pUnknown)
{
ASSERT(pUnknown != NULL);
HRESULT hr;
AFX_MANAGE_STATE(AfxGetStaticModuleState());
// MMC should only call ::Initialize once!
ASSERT(m_pConsoleNameSpace == NULL);
pUnknown->QueryInterface(IID_IConsoleNameSpace,
reinterpret_cast<void**>(&m_pConsoleNameSpace));
// add the images for the scope tree
CBitmap bmp16x16;
LPIMAGELIST lpScopeImage;
hr = pUnknown->QueryInterface(IID_IConsole, reinterpret_cast<void**>(&m_pConsole));
ASSERT(hr == S_OK);
if (FAILED(hr))
{
return hr;
}
hr = m_pConsole->QueryScopeImageList(&lpScopeImage);
ASSERT(hr == S_OK);
if (FAILED(hr))
{
return hr;
}
// Load the bitmaps from the dll
bmp16x16.LoadBitmap(IDB_DOMAIN_SMALL);
// Set the images
lpScopeImage->ImageListSetStrip(reinterpret_cast<LONG_PTR*>(static_cast<HBITMAP>(bmp16x16)),
reinterpret_cast<LONG_PTR*>(static_cast<HBITMAP>(bmp16x16)),
0, RGB(128, 0, 0));
lpScopeImage->Release();
// bind to the path info
hr = GetBasePathsInfo()->InitFromName(GetServerNameFromCommandLine());
m_bInitSuccess = SUCCEEDED(hr);
if (FAILED(hr))
{
HWND hWndParent;
GetMainWindow(&hWndParent);
ReportError(hWndParent, IDS_CANT_GET_PARTITIONS_INFORMATION, hr);
// TODO: error handling, change icon
}
return S_OK;
}
HWND CComponentDataImpl::GetHiddenWindow()
{
ASSERT(m_pHiddenWnd != NULL);
ASSERT(::IsWindow(m_pHiddenWnd->m_hWnd));
return m_pHiddenWnd->m_hWnd;
}
void CComponentDataImpl::_DeleteHiddenWnd()
{
if (m_pHiddenWnd == NULL)
return;
AFX_MANAGE_STATE(AfxGetStaticModuleState());
if (m_pHiddenWnd->m_hWnd != NULL)
{
VERIFY(m_pHiddenWnd->DestroyWindow());
}
delete m_pHiddenWnd;
m_pHiddenWnd = NULL;
}
STDMETHODIMP CComponentDataImpl::CreateComponent(LPCOMPONENT* ppComponent)
{
ASSERT(ppComponent != NULL);
CComObject<CComponentImpl>* pObject;
HRESULT hr = CComObject<CComponentImpl>::CreateInstance(&pObject);
if (FAILED(hr))
{
ASSERT(FALSE && "CComObject<CComponentImpl>::CreateInstance(&pObject) failed");
return hr;
}
ASSERT(pObject != NULL);
// Store IComponentData
pObject->SetIComponentData(this);
return pObject->QueryInterface(IID_IComponent,
reinterpret_cast<void**>(ppComponent));
}
STDMETHODIMP CComponentDataImpl::Notify(LPDATAOBJECT lpDataObject, MMC_NOTIFY_TYPE event, LPARAM arg, LPARAM param)
{
ASSERT(m_pConsoleNameSpace != NULL);
HRESULT hr = S_OK;
// Since it's my folder it has an internal format.
// Design Note: for extension. I can use the fact, that the data object doesn't have
// my internal format and I should look at the node type and see how to extend it.
if (event == MMCN_PROPERTY_CHANGE)
{
hr = OnPropertyChange(param);
}
else
{
if (lpDataObject == NULL)
return S_OK;
CFolderObject* pFolderObject = NULL;
DATA_OBJECT_TYPES type;
CInternalFormatCracker dobjCracker(this);
if (!dobjCracker.GetContext(lpDataObject, &pFolderObject, &type))
{
// Extensions not supported.
ASSERT(FALSE);
return S_OK;
}
switch(event)
{
case MMCN_EXPAND:
hr = OnExpand(pFolderObject, arg, param);
break;
case MMCN_REFRESH:
OnRefreshVerbHandler(pFolderObject, NULL);
break;
default:
break;
}
}
return hr;
}
STDMETHODIMP CComponentDataImpl::Destroy()
{
SAFE_RELEASE(m_pConsoleNameSpace);
SAFE_RELEASE(m_pConsole);
return S_OK;
}
STDMETHODIMP CComponentDataImpl::QueryDataObject(MMC_COOKIE cookie, DATA_OBJECT_TYPES type, LPDATAOBJECT* ppDataObject)
{
ASSERT(ppDataObject != NULL);
if (ppDataObject == NULL)
return E_INVALIDARG;
// create data object
CComObject<CDataObject>* pObject = NULL;
CComObject<CDataObject>::CreateInstance(&pObject);
ASSERT(pObject != NULL);
if ( !pObject )
return E_OUTOFMEMORY;
// Save cookie and type for delayed rendering
pObject->SetType(type);
pObject->SetCookie(cookie);
// set pointer to IComponentData
pObject->SetIComponentData(this);
if (cookie != NULL)
{
// object is not the root
CDomainObject * pDomain = (CDomainObject *)cookie;
pObject->SetClass( pDomain->GetClass());
}
return pObject->QueryInterface(IID_IDataObject,
reinterpret_cast<void**>(ppDataObject));
}
///////////////////////////////////////////////////////////////////////////////
//// Notify handlers for IComponentData
HRESULT CComponentDataImpl::OnExpand(CFolderObject* pFolderObject, LPARAM arg, LPARAM param)
{
if (arg == TRUE)
{
// Did Initialize get called?
ASSERT(m_pConsoleNameSpace != NULL);
EnumerateScopePane(pFolderObject,
param);
}
return S_OK;
}
HRESULT CComponentDataImpl::OnPropertyChange(LPARAM param)
{
return S_OK;
}
void CComponentDataImpl::EnumerateScopePane(CFolderObject* pFolderObject, HSCOPEITEM pParent)
{
ASSERT(m_pConsoleNameSpace != NULL); // make sure we QI'ed for the interface
HRESULT hr = S_OK;
HWND hWndParent;
GetMainWindow(&hWndParent);
AFX_MANAGE_STATE(AfxGetStaticModuleState());
CWaitCursor cWait;
CRootFolderObject* pRootFolder = GetRootFolder();
if (pFolderObject == pRootFolder) // asked to enumerate the root
{
pRootFolder->SetScopeID(pParent);
if (m_bInitSuccess && (!pRootFolder->HasData()))
{
hr = GetDsDisplaySpecOptionsCFHolder()->Init(GetBasePathsInfo());
ASSERT(SUCCEEDED(hr));
hr = pRootFolder->Bind();
if (FAILED(hr))
{
ReportError(hWndParent, IDS_CANT_GET_PARTITIONS_INFORMATION, hr);
// TODO: error handling, change icon
return;
}
hr = pRootFolder->GetData();
if (FAILED(hr))
{
ReportError(hWndParent, IDS_CANT_GET_PARTITIONS_INFORMATION, hr);
return;
}
}
pRootFolder->EnumerateRootFolder(this);
}
else // asked to enumerate a subfolder of the root
{
if (pRootFolder->HasData())
{
pRootFolder->EnumerateFolder(pFolderObject, pParent, this);
}
}
}
STDMETHODIMP CComponentDataImpl::GetDisplayInfo(SCOPEDATAITEM* pScopeDataItem)
{
ASSERT(pScopeDataItem != NULL);
if (pScopeDataItem == NULL)
return E_POINTER;
CDomainObject* pDomain = reinterpret_cast<CDomainObject*>(pScopeDataItem->lParam);
ASSERT(pScopeDataItem->mask & SDI_STR);
pScopeDataItem->displayname = (LPWSTR)pDomain->GetDisplayString(0);
ASSERT(pScopeDataItem->displayname != NULL);
return S_OK;
}
class CCompareDomainObjectByDN
{
public:
CCompareDomainObjectByDN(LPCWSTR lpszDN) { m_lpszDN = lpszDN;}
bool operator()(CDomainObject* p)
{
// NOTICE-2002/03/07-ericb - SecurityPush: checking both strings for null before dereferencing.
if (!m_lpszDN || !p || !p->GetNCName())
{
ASSERT(m_lpszDN);
ASSERT(p);
ASSERT(p->GetNCName());
return false;
}
return (_wcsicmp(m_lpszDN, p->GetNCName()) == 0);
}
private:
LPCWSTR m_lpszDN;
};
STDMETHODIMP CComponentDataImpl::CompareObjects(LPDATAOBJECT lpDataObjectA, LPDATAOBJECT lpDataObjectB)
{
if (lpDataObjectA == NULL || lpDataObjectB == NULL)
return E_POINTER;
CFolderObject *pFolderObjectA, *pFolderObjectB;
DATA_OBJECT_TYPES typeA, typeB;
CInternalFormatCracker dobjCrackerA(this), dobjCrackerB(this);
if ( (!dobjCrackerA.GetContext(lpDataObjectA, &pFolderObjectA, &typeA)) ||
(!dobjCrackerB.GetContext(lpDataObjectB, &pFolderObjectB, &typeB)) )
return E_INVALIDARG; // something went wrong
// must have valid cookies
if ( (pFolderObjectA == NULL) || (pFolderObjectB == NULL) )
{
return S_FALSE;
}
if (pFolderObjectA == pFolderObjectB)
{
// same pointer, they are the same (either both from real nodes
// or both from secondary pages)
return S_OK;
}
// the two cookies are different, but one of them might be from a secondary property page
// and another from a real node
CDomainObject* pA = dynamic_cast<CDomainObject*>(pFolderObjectA);
CDomainObject* pB = dynamic_cast<CDomainObject*>(pFolderObjectB);
if ((pA == NULL) || (pB == NULL))
{
return S_FALSE;
}
BOOL bSecondaryA = m_secondaryPagesManager.IsCookiePresent(pA);
BOOL bSecondaryB = m_secondaryPagesManager.IsCookiePresent(pB);
BOOL bTheSame = FALSE;
if (bSecondaryA && !bSecondaryB)
{
bTheSame = m_secondaryPagesManager.FindCookie(CCompareDomainObjectByDN(pB->GetNCName())) != NULL;
}
else if (!bSecondaryA && bSecondaryB)
{
bTheSame = m_secondaryPagesManager.FindCookie(CCompareDomainObjectByDN(pA->GetNCName())) != NULL;
}
return bTheSame ? S_OK : S_FALSE;
}
HRESULT CComponentDataImpl::AddFolder(CFolderObject* pFolderObject,
HSCOPEITEM pParentScopeItem,
BOOL bHasChildren)
{
TRACE(L"CComponentDataImpl::AddFolder(%s)\n", pFolderObject->GetDisplayString(0));
SCOPEDATAITEM scopeItem;
// NOTICE-2002/03/07-ericb - SecurityPush: zeroing a struct.
memset(&scopeItem, 0, sizeof(SCOPEDATAITEM));
// set parent scope item
scopeItem.mask |= SDI_PARENT;
scopeItem.relativeID = pParentScopeItem;
// Add node name, we implement callback
scopeItem.mask |= SDI_STR;
scopeItem.displayname = MMC_CALLBACK;
// Add the lParam
scopeItem.mask |= SDI_PARAM;
scopeItem.lParam = reinterpret_cast<LPARAM>(pFolderObject);
// Add close image
scopeItem.mask |= SDI_IMAGE;
scopeItem.nImage = pFolderObject->GetImageIndex();
// Add open image
scopeItem.mask |= SDI_OPENIMAGE;
scopeItem.nOpenImage = pFolderObject->GetImageIndex();
// Add button to node if the folder has children
if (bHasChildren == TRUE)
{
scopeItem.mask |= SDI_CHILDREN;
scopeItem.cChildren = 1;
}
pFolderObject->SetScopeID(0);
HRESULT hr = m_pConsoleNameSpace->InsertItem(&scopeItem);
if (SUCCEEDED(hr))
pFolderObject->SetScopeID(scopeItem.ID);
return hr;
}
HRESULT CComponentDataImpl::AddDomainIcon()
{
if (m_hDomainIcon != NULL)
return S_OK;
m_hDomainIcon = GetBasePathsInfo()->GetIcon(L"domainDNS",
DSGIF_ISNORMAL | DSGIF_GETDEFAULTICON,
0, 0);
if (m_hDomainIcon == NULL)
return S_OK;
LPIMAGELIST lpScopeImage;
HRESULT hr = m_pConsole->QueryScopeImageList(&lpScopeImage);
ASSERT(SUCCEEDED(hr));
if (FAILED(hr))
return hr;
// Set the images
hr = lpScopeImage->ImageListSetIcon((LONG_PTR*)m_hDomainIcon,DOMAIN_IMAGE_IDX);
lpScopeImage->Release();
return hr;
}
HRESULT CComponentDataImpl::AddDomainIconToResultPane(LPIMAGELIST lpImageList)
{
if (m_hDomainIcon == NULL)
return S_OK;
return lpImageList->ImageListSetIcon((LONG_PTR*)m_hDomainIcon,DOMAIN_IMAGE_IDX);
}
int CComponentDataImpl::GetDomainImageIndex()
{
return (m_hDomainIcon != NULL) ? DOMAIN_IMAGE_IDX : DOMAIN_IMAGE_DEFAULT_IDX;
}
/////////////////////////////////////////////////////////////////////////////
// IExtendPropertySheet Implementation
//+----------------------------------------------------------------------------
//
// Function: AddPageProc
//
// Synopsis: The IShellPropSheetExt->AddPages callback.
//
//-----------------------------------------------------------------------------
BOOL CALLBACK
AddPageProc(HPROPSHEETPAGE hPage, LPARAM pCall)
{
TRACE(_T("xx.%03x> AddPageProc()\n"), GetCurrentThreadId());
HRESULT hr;
hr = ((LPPROPERTYSHEETCALLBACK)pCall)->AddPage(hPage);
return hr == S_OK;
}
STDMETHODIMP CComponentDataImpl::CreatePropertyPages(LPPROPERTYSHEETCALLBACK lpProvider,
LONG_PTR handle,
LPDATAOBJECT lpIDataObject)
{
TRACE(_T("xx.%03x> CComponentDataImpl::CreatePropertyPages()\n"),
GetCurrentThreadId());
// Validate Inputs
if (lpProvider == NULL)
{
return E_INVALIDARG;
}
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = S_OK;
CWaitCursor wait;
CFolderObject* pFolderObject = NULL;
DATA_OBJECT_TYPES type;
CInternalFormatCracker dobjCracker(this);
if ( (!dobjCracker.GetContext(lpIDataObject, &pFolderObject, &type)) ||
(pFolderObject == NULL))
return E_NOTIMPL; // unknown format
// special case the root
if (pFolderObject == GetRootFolder())
{
return GetRootFolder()->OnAddPages(lpProvider, handle);
}
// See if a sheet is already up for this object.
//
if (IsSheetAlreadyUp(lpIDataObject))
{
return S_OK;
}
if (pFolderObject->GetParentFolder() == GetRootFolder())
{
TRACE(L"\t!!!!! This is the root domain\n");
}
// See if a PDC is available.
//
CDomainObject * pDomainObject = (CDomainObject *)pFolderObject;
PCWSTR wzDomain = pDomainObject->GetDomainName();
// If the domain name is null, then launching a secondary page. The domain
// object properties have already been set in _OnSheetCreate.
//
if (wzDomain && *wzDomain)
{
TRACE(L"Calling DsGetDcName on %s\n", wzDomain);
CString strCachedPDC;
PDOMAIN_CONTROLLER_INFOW pDCInfo = NULL;
// Get the cached PDC name for display later if the PDC can't be contacted.
//
DWORD dwRet = DsGetDcNameW(NULL, wzDomain, NULL, NULL, DS_PDC_REQUIRED, &pDCInfo);
int nID = IDS_NO_PDC_MSG;
if (ERROR_SUCCESS == dwRet)
{
strCachedPDC = pDCInfo->DomainControllerName + 2;
NetApiBufferFree(pDCInfo);
}
// Now do a NetLogon cache update (with the force flag) to see if the PDC
// is actually available.
//
dwRet = DsGetDcNameW(NULL, wzDomain, NULL, NULL,
DS_PDC_REQUIRED | DS_FORCE_REDISCOVERY, &pDCInfo);
if (ERROR_SUCCESS == dwRet)
{
CString strPDC;
strPDC = pDCInfo->DomainControllerName + 2; // skip the UNC backslashes.
NetApiBufferFree(pDCInfo);
TRACE(L"PDC: %s\n", (PCWSTR)strPDC);
if (strPDC.IsEmpty())
{
return E_OUTOFMEMORY;
}
pDomainObject->SetPDC(strPDC);
pDomainObject->SetPdcAvailable(true);
}
else
{
pDomainObject->SetPdcAvailable(false);
CString strMsg;
if (strCachedPDC.IsEmpty())
{
strMsg.LoadString(IDS_UNKNOWN_PDC_MSG);
}
else
{
strMsg.Format(IDS_NO_PDC_MSG, strCachedPDC);
}
HWND hWndParent;
GetMainWindow(&hWndParent);
_MessageBox(hWndParent, strMsg, MB_OK | MB_ICONEXCLAMATION);
}
}
//
// Pass the Notify Handle to the data object.
//
PROPSHEETCFG SheetCfg = {handle};
FORMATETC fe = {CDataObject::m_cfGetIPropSheetCfg, NULL, DVASPECT_CONTENT,
-1, TYMED_HGLOBAL};
STGMEDIUM sm = {TYMED_HGLOBAL, NULL, NULL};
sm.hGlobal = (HGLOBAL)&SheetCfg;
lpIDataObject->SetData(&fe, &sm, FALSE);
//
// Initialize and create the pages.
//
// Bind to the property sheet COM object at startup and hold its pointer
// until shutdown so that its cache can live as long as us.
//
CComPtr<IShellExtInit> spShlInit;
hr = CoCreateInstance(CLSID_DsPropertyPages, NULL, CLSCTX_INPROC_SERVER,
IID_IShellExtInit, (void **)&spShlInit);
if (FAILED(hr))
{
TRACE(TEXT("CoCreateInstance on CLSID_DsPropertyPages failed, hr: 0x%x\n "), hr);
return hr;
}
hr = spShlInit->Initialize(NULL, lpIDataObject, 0);
if (FAILED(hr))
{
TRACE(TEXT("spShlInit->Initialize failed, hr: 0x%x\n"), hr);
return hr;
}
CComPtr<IShellPropSheetExt> spSPSE;
hr = spShlInit->QueryInterface(IID_IShellPropSheetExt, (void **)&spSPSE);
if (FAILED(hr))
{
TRACE(TEXT("spShlInit->QI for IID_IShellPropSheetExt failed, hr: 0x%x\n"), hr);
return hr;
}
hr = spSPSE->AddPages(AddPageProc, (LONG_PTR)lpProvider);
if (FAILED(hr))
{
TRACE(TEXT("pSPSE->AddPages failed, hr: 0x%x\n"), hr);
return hr;
}
_SheetLockCookie(pFolderObject);
return hr;
}
// Sheet locking and unlocking add by JEFFJON 1/26/99
//
void CComponentDataImpl::_OnSheetClose(CFolderObject* pCookie)
{
ASSERT(pCookie != NULL);
_SheetUnlockCookie(pCookie);
CDomainObject* pDomObj = dynamic_cast<CDomainObject*>(pCookie);
if (pDomObj != NULL)
m_secondaryPagesManager.OnSheetClose(pDomObj);
}
void CComponentDataImpl::_OnSheetCreate(PDSA_SEC_PAGE_INFO pDsaSecondaryPageInfo,
PWSTR pwzDC)
{
ASSERT(pDsaSecondaryPageInfo != NULL);
// get the info from the packed structure
HWND hwndParent = pDsaSecondaryPageInfo->hwndParentSheet;
LPCWSTR lpszTitle = (LPCWSTR)((BYTE*)pDsaSecondaryPageInfo + pDsaSecondaryPageInfo->offsetTitle);
DSOBJECTNAMES* pDsObjectNames = &(pDsaSecondaryPageInfo->dsObjectNames);
ASSERT(pDsObjectNames->cItems == 1);
DSOBJECT* pDsObject = &(pDsObjectNames->aObjects[0]);
LPCWSTR lpszName = (LPCWSTR)((BYTE*)pDsObject + pDsObject->offsetName);
LPCWSTR lpszClass = (LPCWSTR)((BYTE*)pDsObject + pDsObject->offsetClass);
// with the given info, create a cookie and set it
CDomainObject* pNewCookie = new CDomainObject();
pNewCookie->InitializeForSecondaryPage(lpszName, lpszClass, GetDomainImageIndex());
// The parent sheet will be in read-only mode if a PDC is not available.
pNewCookie->SetPdcAvailable(!(pDsObject->dwFlags & DSOBJECT_READONLYPAGES));
if (pwzDC && !IsBadReadPtr(pwzDC, sizeof(PWSTR)))
{
pNewCookie->SetPDC(pwzDC);
}
// with the cookie, can call into ourselves to get a data object
CComPtr<IDataObject> spDataObject;
MMC_COOKIE cookie = reinterpret_cast<MMC_COOKIE>(pNewCookie);
HRESULT hr = QueryDataObject(cookie, CCT_UNINITIALIZED, &spDataObject);
if (FAILED(hr) || (spDataObject == NULL) || IsSheetAlreadyUp(spDataObject))
{
// we failed to create a data object (rare)
// or the sheet is already up
delete pNewCookie;
return;
}
//
// Pass the parent sheet handle to the data object.
//
PROPSHEETCFG SheetCfg = {0};
SheetCfg.hwndParentSheet = hwndParent;
FORMATETC fe = {CDataObject::m_cfGetIPropSheetCfg, NULL, DVASPECT_CONTENT,
-1, TYMED_HGLOBAL};
STGMEDIUM sm = {TYMED_HGLOBAL, NULL, NULL};
sm.hGlobal = (HGLOBAL)&SheetCfg;
hr = spDataObject->SetData(&fe, &sm, FALSE);
ASSERT(SUCCEEDED(hr));
// with the data object, call into MMC to get the sheet
hr = m_secondaryPagesManager.CreateSheet(GetHiddenWindow(),
m_pConsole,
GetUnknown(),
pNewCookie,
spDataObject,
lpszTitle);
// if failed, the cookie can be discarded,
// if succeeded, the cookie has been inserted into
// the secondary pages manager cookie list
if (FAILED(hr))
{
delete pNewCookie;
}
}
void CComponentDataImpl::_SheetLockCookie(CFolderObject* pCookie)
{
pCookie->IncrementSheetLockCount();
m_sheetCookieTable.Add(pCookie);
}
void CComponentDataImpl::_SheetUnlockCookie(CFolderObject* pCookie)
{
pCookie->DecrementSheetLockCount();
m_sheetCookieTable.Remove(pCookie);
}
STDMETHODIMP CComponentDataImpl::QueryPagesFor(LPDATAOBJECT lpDataObject)
{
CFolderObject* pFolderObject;
DATA_OBJECT_TYPES type;
CInternalFormatCracker dobjCracker(this);
if (!dobjCracker.GetContext(lpDataObject, &pFolderObject, &type))
{
// not internal format, not ours
return S_FALSE;
}
// this is the MMC snzpin wizard, we do not have one
if (type == CCT_SNAPIN_MANAGER)
{
return S_FALSE;
}
// if NULL no pages
if (pFolderObject == NULL)
{
return S_FALSE;
}
// secondary pages data objects have to be checked first,
// because they look like the root (no parents, but they
// have CCT_UNINITIALIZED
if ( (pFolderObject->GetParentFolder() == NULL) || (type == CCT_UNINITIALIZED) )
{
return S_OK;
}
// check if this is the root
if (GetRootFolder() == pFolderObject)
{
// this is the root
ASSERT(type == CCT_SCOPE);
return S_OK;
}
// default case, have DSPROP property pages
return S_OK;
}
BOOL CComponentDataImpl::IsScopePaneNode(LPDATAOBJECT lpDataObject)
{
CFolderObject* pFolderObject;
DATA_OBJECT_TYPES type;
CInternalFormatCracker dobjCracker(this);
if (!dobjCracker.GetContext(lpDataObject, &pFolderObject, &type))
return FALSE;
return (dobjCracker.GetInternal()->m_type == CCT_SCOPE);
}
///////////////////////////////////////////////////////////////////////////////
// IExtendContextMenu implementation
//
STDMETHODIMP CComponentDataImpl::AddMenuItems(LPDATAOBJECT pDataObject,
LPCONTEXTMENUCALLBACK pContextMenuCallback,
long *pInsertionAllowed)
{
HRESULT hr = S_OK;
CFolderObject* pFolderObject;
DATA_OBJECT_TYPES type;
CInternalFormatCracker dobjCracker(this);
if (!dobjCracker.GetContext(pDataObject, &pFolderObject, &type))
return E_FAIL;
return pFolderObject->OnAddMenuItems(pContextMenuCallback, pInsertionAllowed);
}
STDMETHODIMP CComponentDataImpl::Command(long nCommandID, LPDATAOBJECT pDataObject)
{
// Note - snap-ins need to look at the data object and determine
// in what context the command is being called.
CFolderObject* pFolderObject;
DATA_OBJECT_TYPES type;
CInternalFormatCracker dobjCracker(this);
if (!dobjCracker.GetContext(pDataObject, &pFolderObject, &type))
return E_FAIL;
return pFolderObject->OnCommand(this, nCommandID);
}
/////////////////////////////////////////////////////////////////////////////
// CComponentDataImpl::ISnapinHelp2 members
STDMETHODIMP CComponentDataImpl::GetHelpTopic(LPOLESTR* lpCompiledHelpFile)
{
if (lpCompiledHelpFile == NULL)
{
return E_INVALIDARG;
}
CString szHelpFilePath;
LPTSTR lpszBuffer = szHelpFilePath.GetBuffer(2*MAX_PATH);
UINT nLen = ::GetSystemWindowsDirectory(lpszBuffer, 2*MAX_PATH);
if (nLen == 0)
{
return E_FAIL;
}
szHelpFilePath.ReleaseBuffer();
szHelpFilePath += L"\\help\\";
szHelpFilePath += DOMADMIN_SNAPIN_HELP_FILE;
UINT nBytes = (szHelpFilePath.GetLength()+1) * sizeof(WCHAR);
*lpCompiledHelpFile = (LPOLESTR)::CoTaskMemAlloc(nBytes);
if (NULL == *lpCompiledHelpFile)
{
return E_OUTOFMEMORY;
}
// NOTICE-2002/03/07-ericb - SecurityPush: reviewed, usage is safe.
memcpy(*lpCompiledHelpFile, (LPCWSTR)szHelpFilePath, nBytes);
return S_OK;
}
// CODEWORK-2002/03/07-ericb - use a common helper for these two functions.
STDMETHODIMP CComponentDataImpl::GetLinkedTopics(LPOLESTR* lpCompiledHelpFile)
{
if (lpCompiledHelpFile == NULL)
{
return E_INVALIDARG;
}
CString szHelpFilePath;
LPTSTR lpszBuffer = szHelpFilePath.GetBuffer(2*MAX_PATH);
UINT nLen = ::GetSystemWindowsDirectory(lpszBuffer, 2*MAX_PATH);
if (nLen == 0)
{
return E_FAIL;
}
szHelpFilePath.ReleaseBuffer();
szHelpFilePath += L"\\help\\";
szHelpFilePath += DOMADMIN_LINKED_HELP_FILE;
UINT nBytes = (szHelpFilePath.GetLength()+1) * sizeof(WCHAR);
*lpCompiledHelpFile = (LPOLESTR)::CoTaskMemAlloc(nBytes);
if (NULL == *lpCompiledHelpFile)
{
return E_OUTOFMEMORY;
}
// NOTICE-2002/03/07-ericb - SecurityPush: reviewed, usage is safe.
memcpy(*lpCompiledHelpFile, (LPCWSTR)szHelpFilePath, nBytes);
return S_OK;
}
/////////////////////////////////////////////////////////////////////
void CComponentDataImpl::HandleStandardVerbsHelper(CComponentImpl* pComponentImpl,
LPCONSOLEVERB pConsoleVerb,
BOOL bScope, BOOL bSelect,
CFolderObject* pFolderObject,
DATA_OBJECT_TYPES type)
{
// You should crack the data object and enable/disable/hide standard
// commands appropriately. The standard commands are reset everytime you get
// called. So you must reset them back.
ASSERT(pConsoleVerb != NULL);
ASSERT(pComponentImpl != NULL);
ASSERT(pFolderObject != NULL);
// reset the selection
pComponentImpl->SetSelection(NULL, CCT_UNINITIALIZED);
if (bSelect)
{
// special case the root
BOOL bIsRoot = (pFolderObject == GetRootFolder());
// setting the selection, if any
pComponentImpl->SetSelection(pFolderObject, type);
// the default just disables all the non implemented verbs
pConsoleVerb->SetVerbState(MMC_VERB_COPY, HIDDEN, TRUE);
pConsoleVerb->SetVerbState(MMC_VERB_COPY, ENABLED, FALSE);
pConsoleVerb->SetVerbState(MMC_VERB_PASTE, HIDDEN, TRUE);
pConsoleVerb->SetVerbState(MMC_VERB_PASTE, ENABLED, FALSE);
pConsoleVerb->SetVerbState(MMC_VERB_RENAME, HIDDEN, TRUE);
pConsoleVerb->SetVerbState(MMC_VERB_RENAME, ENABLED, FALSE);
pConsoleVerb->SetVerbState(MMC_VERB_PRINT, HIDDEN, TRUE);
pConsoleVerb->SetVerbState(MMC_VERB_PRINT, ENABLED, FALSE);
// handling of standard verbs
// MMC_VERB_DELETE (always disabled)
pConsoleVerb->SetVerbState(MMC_VERB_DELETE, ENABLED, FALSE);
pConsoleVerb->SetVerbState(MMC_VERB_DELETE, HIDDEN, TRUE);
// MMC_VERB_REFRESH (enabled only for root)
if (bIsRoot)
{
pConsoleVerb->SetVerbState(MMC_VERB_REFRESH, ENABLED, TRUE);
pConsoleVerb->SetVerbState(MMC_VERB_REFRESH, HIDDEN, FALSE);
}
else
{
pConsoleVerb->SetVerbState(MMC_VERB_REFRESH, ENABLED, FALSE);
pConsoleVerb->SetVerbState(MMC_VERB_REFRESH, HIDDEN, TRUE);
}
// MMC_VERB_PROPERTIES
// passing NULL pFolderObject means multiple selection
BOOL bHasProperties = (pFolderObject != NULL);
BOOL bHideProperties = !bHasProperties;
pConsoleVerb->SetVerbState(MMC_VERB_PROPERTIES, ENABLED, bHasProperties);
pConsoleVerb->SetVerbState(MMC_VERB_PROPERTIES, HIDDEN, bHideProperties);
// SET DEFAULT VERB
// assume only folders: only one default verb (i.e. will not have MMC_VERB_PROPERTIES)
pConsoleVerb->SetDefaultVerb(MMC_VERB_OPEN);
}
}
void CComponentDataImpl::OnRefreshVerbHandler(CFolderObject* pFolderObject,
CComponentImpl* pComponentImpl,
BOOL bBindAgain)
{
TRACE(L"CComponentDataImpl::OnRefreshVerbHandler(...,..., %d)\n", bBindAgain);
if (pFolderObject->_WarningOnSheetsUp(this))
return;
// make sure the DNS cache is flushed, in case a somain was added.
VERIFY(::DnsFlushResolverCache());
// NOTICE: only the root folder allows refresh
ASSERT(pFolderObject == GetRootFolder());
// remove all the children of the root from the UI
m_pConsoleNameSpace->DeleteItem(m_rootFolder.GetScopeID(), /*fDeleteThis*/ FALSE);
HRESULT hr = S_OK;
if (bBindAgain)
{
// the server name has changed
hr = m_rootFolder.Bind();
TRACE(L"m_rootFolder.Bind() returned hr = 0x%x\n", hr);
}
if (SUCCEEDED(hr))
{
// refresh the data from the server
hr = m_rootFolder.GetData();
TRACE(L"m_rootFolder.GetData() returned hr = 0x%x\n", hr);
}
if (FAILED(hr))
{
HWND hWndParent;
GetMainWindow(&hWndParent);
ReportError(hWndParent, IDS_CANT_GET_PARTITIONS_INFORMATION, hr);
}
if (FAILED(hr))
return;
// re-enumerate
m_rootFolder.EnumerateRootFolder(this);
}
//+---------------------------------------------------------------------------
//
// Function: LocaleStrCmp
//
// Synopsis: Do a case insensitive string compare that is safe for any
// locale.
//
// Arguments: [ptsz1] - strings to compare
// [ptsz2]
//
// Returns: -1, 0, or 1 just like lstrcmpi
//
// History: 10-28-96 DavidMun Created
//
// Notes: This is slower than lstrcmpi, but will work when sorting
// strings even in Japanese.
//
//----------------------------------------------------------------------------
int
LocaleStrCmp(LPCTSTR ptsz1, LPCTSTR ptsz2)
{
int iRet = 0;
iRet = CompareString(LOCALE_USER_DEFAULT,
NORM_IGNORECASE |
NORM_IGNOREKANATYPE |
NORM_IGNOREWIDTH,
ptsz1,
-1,
ptsz2,
-1);
if (iRet)
{
iRet -= 2; // convert to lstrcmpi-style return -1, 0, or 1
if ( 0 == iRet )
{
UNICODE_STRING unistr1;
unistr1.Length = (USHORT)(::lstrlen(ptsz1)*sizeof(WCHAR));
unistr1.MaximumLength = unistr1.Length;
unistr1.Buffer = (LPWSTR)ptsz1;
UNICODE_STRING unistr2;
unistr2.Length = (USHORT)(::lstrlen(ptsz2)*sizeof(WCHAR));
unistr2.MaximumLength = unistr2.Length;
unistr2.Buffer = (LPWSTR)ptsz2;
iRet = ::RtlCompareUnicodeString(
&unistr1,
&unistr2,
FALSE );
}
}
else
{
DWORD dwErr = GetLastError ();
if (dwErr != 0)
{
TRACE(L"CompareString (%s, %s) failed: 0x%x\n", ptsz1, ptsz2, dwErr);
}
}
return iRet;
}
///////////////////////////////////////////////////////////////////////////////
///////////////////// CComponentImpl (i.e. result pane side) //////////////////
///////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CComponentImpl::CompareObjects(LPDATAOBJECT lpDataObjectA, LPDATAOBJECT lpDataObjectB)
{
return S_FALSE;
}
//+---------------------------------------------------------------------------
//
// Function: CComponentImpl::IResultDataCompareEx::Compare
//
// Synopsis: This compare is used to sort the item's in the listview
//
// Note: Assume sort is ascending when comparing.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CComponentImpl::Compare(RDCOMPARE* prdc, int* pnResult)
{
if (pnResult == NULL)
{
ASSERT(FALSE);
return E_POINTER;
}
if (prdc == NULL)
{
ASSERT(FALSE);
return E_POINTER;
}
*pnResult = 0;
LPCTSTR szStringA;
LPCTSTR szStringB;
CDomainObject* pDataA = reinterpret_cast<CDomainObject*>(prdc->prdch1->cookie);
CDomainObject* pDataB = reinterpret_cast<CDomainObject*>(prdc->prdch2->cookie);
ASSERT(pDataA != NULL && pDataB != NULL);
// Currently DomAdmin has just two columns, Name and Type. The value of
// the type column is always "DomainDNS", so there is nothing to compare
// for that column and the default *pnResult, set to zero above, is
// returned.
if (0 == prdc->nColumn)
{
szStringA = pDataA->GetDomainName();
szStringB = pDataB->GetDomainName();
ASSERT(szStringA != NULL);
ASSERT(szStringB != NULL);
*pnResult = LocaleStrCmp(szStringA, szStringB);
}
return S_OK;
}
void CComponentImpl::HandleStandardVerbs(BOOL bScope, BOOL bSelect,
CFolderObject* pFolderObject, DATA_OBJECT_TYPES type)
{
// delegate it to the IComponentData helper function
ASSERT(m_pCD != NULL);
m_pCD->HandleStandardVerbsHelper(
this, m_pConsoleVerb, bScope, bSelect, pFolderObject, type);
}
void CComponentImpl::Refresh(CFolderObject* pFolderObject)
{
ASSERT(m_pComponentData != NULL);
// delegate it to the IComponentData helper function
((CComponentDataImpl*)m_pComponentData)->OnRefreshVerbHandler(pFolderObject, this);
}
// utility routines
////////////////////////////////////////////////////////////////////
//
// Print the data depending on its type.
//
#ifdef DBG
void
PrintColumn(
PADS_SEARCH_COLUMN pColumn,
LPWSTR pszColumnName
)
{
ULONG i, j, k;
if (!pColumn) {
return;
}
TRACE(_T(
"%s = "),
pszColumnName
);
for (k=0; k < pColumn->dwNumValues; k++) {
if (k > 0)
TRACE(_T("# "));
switch(pColumn->dwADsType) {
case ADSTYPE_DN_STRING :
TRACE(_T(
"%s "),
(LPWSTR) pColumn->pADsValues[k].DNString
);
break;
case ADSTYPE_CASE_EXACT_STRING :
TRACE(_T(
"%s "),
(LPWSTR) pColumn->pADsValues[k].CaseExactString
);
break;
case ADSTYPE_CASE_IGNORE_STRING:
TRACE(_T(
"%s "),
(LPWSTR) pColumn->pADsValues[k].CaseIgnoreString
);
break;
case ADSTYPE_PRINTABLE_STRING :
TRACE(_T(
"%s "),
(LPWSTR) pColumn->pADsValues[k].PrintableString
);
break;
case ADSTYPE_NUMERIC_STRING :
TRACE(_T(
"%s "),
(LPWSTR) pColumn->pADsValues[k].NumericString
);
break;
case ADSTYPE_BOOLEAN :
TRACE(_T(
"%s "),
(DWORD) pColumn->pADsValues[k].Boolean ?
L"TRUE" : L"FALSE"
);
break;
case ADSTYPE_INTEGER :
TRACE(_T(
"%d "),
(DWORD) pColumn->pADsValues[k].Integer
);
break;
case ADSTYPE_OCTET_STRING :
for (j=0; j<pColumn->pADsValues[k].OctetString.dwLength; j++) {
TRACE(_T(
"%02x"),
((BYTE *)pColumn->pADsValues[k].OctetString.lpValue)[j]
);
}
break;
case ADSTYPE_LARGE_INTEGER :
TRACE(_T(
"%e = "),
(double) pColumn->pADsValues[k].Integer
);
break;
case ADSTYPE_UTC_TIME :
TRACE(_T(
"(date value) "
));
break;
case ADSTYPE_PROV_SPECIFIC :
TRACE(_T(
"(provider specific value) "
));
break;
}
}
TRACE(_T("\n"));
}
#endif
/////////////////////////////////////////////////////////////////////////////
// Return TRUE if we are enumerating our main folder
BOOL CComponentImpl::IsEnumerating(LPDATAOBJECT lpDataObject)
{
BOOL bResult = FALSE;
STGMEDIUM stgmedium = { TYMED_HGLOBAL, NULL };
FORMATETC formatetc = { (CLIPFORMAT)CDataObject::m_cfNodeType, NULL,
DVASPECT_CONTENT, -1, TYMED_HGLOBAL
};
// Allocate memory for the stream
stgmedium.hGlobal = GlobalAlloc(GMEM_SHARE, sizeof(GUID));
// Attempt to get data from the object
do
{
if (stgmedium.hGlobal == NULL)
break;
if (FAILED(lpDataObject->GetDataHere(&formatetc, &stgmedium)))
break;
GUID* nodeType = reinterpret_cast<GUID*>(stgmedium.hGlobal);
if (nodeType == NULL)
break;
// Is this my main node (static folder node type)
if (*nodeType == cDefaultNodeType)
bResult = TRUE;
} while (FALSE);
// Free resources
if (stgmedium.hGlobal != NULL)
GlobalFree(stgmedium.hGlobal);
return bResult;
}
/////////////////////////////////////////////////////////////////////////////
// CComponentImpl's IComponent implementation
STDMETHODIMP CComponentImpl::GetResultViewType(MMC_COOKIE cookie, LPOLESTR* ppViewType,
long *pViewOptions)
{
// Use default view
*pViewOptions = 0;
return S_FALSE;
}
STDMETHODIMP CComponentImpl::Initialize(LPCONSOLE lpConsole)
{
ASSERT(lpConsole != NULL);
AFX_MANAGE_STATE(AfxGetStaticModuleState());
// Save the IConsole pointer
m_pConsole = lpConsole;
m_pConsole->AddRef();
// Load resource strings
LoadResources();
// QI for a IHeaderCtrl
HRESULT hr = m_pConsole->QueryInterface(IID_IHeaderCtrl,
reinterpret_cast<void**>(&m_pHeader));
// Give the console the header control interface pointer
if (SUCCEEDED(hr))
m_pConsole->SetHeader(m_pHeader);
m_pConsole->QueryInterface(IID_IResultData,
reinterpret_cast<void**>(&m_pResult));
hr = m_pConsole->QueryResultImageList(&m_pImageResult);
ASSERT(hr == S_OK);
hr = m_pConsole->QueryConsoleVerb(&m_pConsoleVerb);
ASSERT(hr == S_OK);
//InitializeHeaders(NULL);
//InitializeBitmaps(NULL);
return S_OK;
}
STDMETHODIMP CComponentImpl::Notify(LPDATAOBJECT lpDataObject, MMC_NOTIFY_TYPE event, LPARAM arg, LPARAM param)
{
HRESULT hr = S_OK;
AFX_MANAGE_STATE(AfxGetStaticModuleState());
if (event == MMCN_PROPERTY_CHANGE)
{
hr = OnPropertyChange(lpDataObject);
}
else if (event == MMCN_VIEW_CHANGE)
{
hr = OnUpdateView(lpDataObject);
}
else if (event == MMCN_CONTEXTHELP)
{
CComPtr<IDisplayHelp> spHelp;
hr = m_pConsole->QueryInterface(IID_IDisplayHelp, (void **)&spHelp);
ASSERT(SUCCEEDED(hr));
if (SUCCEEDED(hr))
{
TRACE(L"Setting the help topic to adconcepts.chm::/domadmin_top.htm\n");
spHelp->ShowTopic(L"adconcepts.chm::/domadmin_top.htm");
}
}
else
{
if (lpDataObject == NULL)
return S_OK;
CFolderObject* pFolderObject = NULL;
DATA_OBJECT_TYPES type;
CInternalFormatCracker dobjCracker(m_pCD);
if (!dobjCracker.GetContext(lpDataObject, &pFolderObject, &type))
{
// Extensions not supported.
ASSERT(FALSE);
return S_OK;
}
ASSERT(pFolderObject != NULL);
switch(event)
{
case MMCN_SHOW:
hr = OnShow(pFolderObject, arg, param);
break;
case MMCN_ADD_IMAGES:
hr = OnAddImages(pFolderObject, arg, param);
break;
case MMCN_SELECT:
if (IsMMCMultiSelectDataObject(lpDataObject) == TRUE)
pFolderObject = NULL;
HandleStandardVerbs( (BOOL) LOWORD(arg)/*bScope*/,
(BOOL) HIWORD(arg)/*bSelect*/, pFolderObject, type);
break;
case MMCN_REFRESH:
Refresh(pFolderObject);
break;
default:
break;
} // switch
} // else
if (m_pResult)
{
// should put something here, someday?
;
}
return hr;
}
STDMETHODIMP CComponentImpl::Destroy(MMC_COOKIE cookie)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
// Release the interfaces that we QI'ed
if (m_pConsole != NULL)
{
// Tell the console to release the header control interface
m_pConsole->SetHeader(NULL);
SAFE_RELEASE(m_pHeader);
SAFE_RELEASE(m_pResult);
SAFE_RELEASE(m_pImageResult);
// Release the IConsole interface last
SAFE_RELEASE(m_pConsole);
SAFE_RELEASE(m_pComponentData); // QI'ed in IComponentDataImpl::CreateComponent
SAFE_RELEASE(m_pConsoleVerb);
}
return S_OK;
}
STDMETHODIMP CComponentImpl::QueryDataObject(MMC_COOKIE cookie, DATA_OBJECT_TYPES type,
LPDATAOBJECT* ppDataObject)
{
// Delegate it to the IComponentData
ASSERT(m_pComponentData != NULL);
return m_pComponentData->QueryDataObject(cookie, type, ppDataObject);
}
/////////////////////////////////////////////////////////////////////////////
// CComponentImpl's implementation specific members
DEBUG_DECLARE_INSTANCE_COUNTER(CComponentImpl);
CComponentImpl::CComponentImpl()
{
DEBUG_INCREMENT_INSTANCE_COUNTER(CComponentImpl);
Construct();
}
CComponentImpl::~CComponentImpl()
{
#if DBG==1
ASSERT(dbg_cRef == 0);
#endif
DEBUG_DECREMENT_INSTANCE_COUNTER(CComponentImpl);
// Make sure the interfaces have been released
ASSERT(m_pConsole == NULL);
ASSERT(m_pHeader == NULL);
Construct();
}
void CComponentImpl::Construct()
{
#if DBG==1
dbg_cRef = 0;
#endif
m_pConsole = NULL;
m_pHeader = NULL;
m_pResult = NULL;
m_pImageResult = NULL;
m_pComponentData = NULL;
m_pCD = NULL;
m_pConsoleVerb = NULL;
m_selectedType = CCT_UNINITIALIZED;
m_pSelectedFolderObject = NULL;
}
void CComponentImpl::LoadResources()
{
// Load strings from resources
m_column1.LoadString(IDS_NAME);
m_column2.LoadString(IDS_TYPE);
}
HRESULT CComponentImpl::InitializeHeaders(CFolderObject* pFolderObject)
{
HRESULT hr = S_OK;
ASSERT(m_pHeader);
// NOTICE: we ignore the cookie, keep always the same columns
m_pHeader->InsertColumn(0, m_column1, LVCFMT_LEFT, 200); // Name
m_pHeader->InsertColumn(1, m_column2, LVCFMT_LEFT, 80); // Type
return hr;
}
HRESULT CComponentImpl::InitializeBitmaps(CFolderObject* pFolderObject)
{
ASSERT(m_pImageResult != NULL);
AFX_MANAGE_STATE(AfxGetStaticModuleState());
CBitmap bmp16x16;
CBitmap bmp32x32;
// Load the bitmaps from the dll
VERIFY(bmp16x16.LoadBitmap(IDB_DOMAIN_SMALL));
VERIFY(bmp32x32.LoadBitmap(IDB_DOMAIN_LARGE));
// Set the images
HRESULT hr = m_pImageResult->ImageListSetStrip(reinterpret_cast<LONG_PTR*>(static_cast<HBITMAP>(bmp16x16)),
reinterpret_cast<LONG_PTR*>(static_cast<HBITMAP>(bmp32x32)),
0, RGB(128, 0, 0));
if (FAILED(hr))
return hr;
return ((CComponentDataImpl*)m_pComponentData)->AddDomainIconToResultPane(m_pImageResult);
}
STDMETHODIMP CComponentImpl::GetDisplayInfo(LPRESULTDATAITEM pResult)
{
ASSERT(pResult != NULL);
CDomainObject* pDomain = reinterpret_cast<CDomainObject*>(pResult->lParam);
if ( (pDomain != NULL) && (pResult->mask & RDI_STR) )
{
pResult->str = (LPWSTR)pDomain->GetDisplayString(pResult->nCol);
TRACE(L"pResult->str = %s\n", pResult->str);
}
if ((pResult->mask & RDI_IMAGE) && (pResult->nCol == 0))
{
pResult->nImage = pDomain->GetImageIndex();
}
return S_OK;
}
/////////////////////////////////////////////////////////////////////////////
// IExtendContextMenu Implementation
STDMETHODIMP CComponentImpl::AddMenuItems(LPDATAOBJECT pDataObject,
LPCONTEXTMENUCALLBACK pContextMenuCallback,
long * pInsertionAllowed)
{
return dynamic_cast<CComponentDataImpl*>(m_pComponentData)->
AddMenuItems(pDataObject, pContextMenuCallback, pInsertionAllowed);
}
STDMETHODIMP CComponentImpl::Command(long nCommandID, LPDATAOBJECT pDataObject)
{
return dynamic_cast<CComponentDataImpl*>(m_pComponentData)->
Command(nCommandID, pDataObject);
}
HRESULT CComponentImpl::OnShow(CFolderObject* pFolderObject, LPARAM arg, LPARAM param)
{
// Note - arg is TRUE when it is time to enumerate
if (arg == TRUE)
{
// Show the headers for this nodetype
InitializeHeaders(pFolderObject);
Enumerate(pFolderObject, param);
}
return S_OK;
}
HRESULT CComponentImpl::OnAddImages(CFolderObject* pFolderObject, LPARAM arg, LPARAM param)
{
return InitializeBitmaps(pFolderObject);
}
HRESULT CComponentImpl::OnPropertyChange(LPDATAOBJECT lpDataObject)
{
return S_OK;
}
HRESULT CComponentImpl::OnUpdateView(LPDATAOBJECT lpDataObject)
{
return S_OK;
}
void CComponentImpl::Enumerate(CFolderObject* pFolderObject, HSCOPEITEM pParent)
{
}
//////////////////////////////////////////////////////////////////////////
// CDomainSnapinAbout
CDomainSnapinAbout::CDomainSnapinAbout():
CSnapinAbout(IDS_SNAPINABOUT_DESCRIPTION,
IDI_DOMAIN,
IDB_DOMAIN_SMALL,
IDB_DOMAIN_SMALL,
IDB_DOMAIN_LARGE,
RGB(255,0,255))
{
}
////////////////////////////////////////////////////////////////////
// CHiddenWnd
const UINT CHiddenWnd::s_SheetCloseNotificationMessage = WM_DSA_SHEET_CLOSE_NOTIFY;
const UINT CHiddenWnd::s_SheetCreateNotificationMessage = WM_DSA_SHEET_CREATE_NOTIFY;
BOOL CHiddenWnd::Create()
{
RECT rcPos;
// NOTICE-2002/03/07-ericb - SecurityPush: zeroing a struct
ZeroMemory(&rcPos, sizeof(RECT));
HWND hWnd = CWindowImpl<CHiddenWnd>::Create( NULL, //HWND hWndParent,
rcPos, //RECT& rcPos,
NULL, //LPCTSTR szWindowName = NULL,
WS_POPUP, //DWORD dwStyle = WS_CHILD | WS_VISIBLE,
0x0, //DWORD dwExStyle = 0,
0 //UINT nID = 0
);
if (!hWnd)
{
TRACE(L"Hidden Window creation failed with error %d\n", GetLastError());
return FALSE;
}
return TRUE;
}
LRESULT CHiddenWnd::OnSheetCloseNotification(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
ASSERT(m_pCD != NULL);
CFolderObject* pCookie = reinterpret_cast<CFolderObject*>(wParam);
m_pCD->_OnSheetClose(pCookie);
return 1;
}
LRESULT CHiddenWnd::OnSheetCreateNotification(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
ASSERT(m_pCD != NULL);
PDSA_SEC_PAGE_INFO pDsaSecondaryPageInfo = reinterpret_cast<PDSA_SEC_PAGE_INFO>(wParam);
ASSERT(pDsaSecondaryPageInfo != NULL);
PWSTR pwzDC = (PWSTR)lParam;
m_pCD->_OnSheetCreate(pDsaSecondaryPageInfo, pwzDC);
::LocalFree(pDsaSecondaryPageInfo);
if (pwzDC && !IsBadReadPtr(pwzDC, sizeof(PWSTR)))
{
::LocalFree(pwzDC);
}
return 1;
}