able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/snapin/dsadmin/dssnap.cpp
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

8011 lines
212 KiB
C++
Raw Blame History

//+-------------------------------------------------------------------------
//
// Windows NT Directory Service Administration SnapIn
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1999
//
// File: dssnap.cpp
//
// Contents: DS App
//
// History: 02-Oct-96 WayneSc Created
// 06-Mar-97 EricB - added Property Page Extension support
// 24-Jul-97 Dan Morin - Integrated "Generic Create" wizard
//
//--------------------------------------------------------------------------
#include "stdafx.h"
#include "resource.h"
#include "util.h"
#include "uiutil.h"
#include "dsutil.h"
#include "dssnap.h"
#include "ContextMenu.h"
#include "DataObj.h"
#include "dsctx.h"
#include "DSdirect.h"
#include "dsdlgs.h"
#include "DSEvent.h"
#include "dsfilter.h"
#include "dsthread.h"
#include "fsmoui.h"
#include "helpids.h"
#include "newobj.h" // CNewADsObjectCreateInfo
#include "query.h"
#include "queryui.h"
#include "querysup.h"
#include "rename.h"
#include <notify.h>
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#define STRING_LEN (32 * sizeof(OLECHAR))
extern LPWSTR g_lpszLoggedInUser;
#define INITGUID
#include <initguid.h>
#include <dsadminp.h>
const wchar_t* SNAPIN_INTERNAL = L"DS_ADMIN_INTERNAL";
// Define the profiling statics
IMPLEMENT_PROFILING;
//////////////////////////////////////////////////////////////////////////////////
// standard attributes array (for queries)
const INT g_nStdCols = 8;
const LPWSTR g_pStandardAttributes[g_nStdCols] = {L"ADsPath",
L"name",
L"displayName",
L"objectClass",
L"groupType",
L"description",
L"userAccountControl",
L"systemFlags"};
extern const INT g_nADsPath = 0;
extern const INT g_nName = 1;
extern const INT g_nDisplayName = 2;
extern const INT g_nObjectClass = 3;
extern const INT g_nGroupType = 4;
extern const INT g_nDescription = 5;
extern const INT g_nUserAccountControl = 6;
extern const INT g_nSystemFlags = 7;
///////////////////////////////////////////////////////////////////////////////////
HRESULT WINAPI CDsAdminModule::UpdateRegistryCLSID(const CLSID& clsid, BOOL bRegister)
{
static const WCHAR szIPS32[] = _T("InprocServer32");
static const WCHAR szCLSID[] = _T("CLSID");
static const WCHAR szThreadingModel[] = _T("ThreadingModel");
static const WCHAR szThreadModelValue[] = _T("Both");
HRESULT hRes = S_OK;
LPOLESTR lpOleStrCLSIDValue;
::StringFromCLSID(clsid, &lpOleStrCLSIDValue);
CRegKey key;
if (bRegister)
{
LONG lRes = key.Open(HKEY_CLASSES_ROOT, szCLSID);
if (lRes == ERROR_SUCCESS)
{
lRes = key.Create(key, lpOleStrCLSIDValue);
if (lRes == ERROR_SUCCESS)
{
WCHAR szModule[_MAX_PATH];
::GetModuleFileName(m_hInst, szModule, _MAX_PATH);
lRes = key.SetKeyValue(szIPS32, szModule);
if (lRes == ERROR_SUCCESS)
{
lRes = key.Open(key, szIPS32);
if (lRes == ERROR_SUCCESS)
{
key.SetValue(szThreadModelValue, szThreadingModel);
}
}
}
}
if (lRes != ERROR_SUCCESS)
hRes = HRESULT_FROM_WIN32(lRes);
}
else
{
key.Attach(HKEY_CLASSES_ROOT);
if (key.Open(key, szCLSID) == ERROR_SUCCESS)
key.RecurseDeleteKey(lpOleStrCLSIDValue);
}
::CoTaskMemFree(lpOleStrCLSIDValue);
return hRes;
}
CDsAdminModule _Module;
BEGIN_OBJECT_MAP(ObjectMap)
OBJECT_ENTRY(CLSID_DSSnapin, CDSSnapin)
OBJECT_ENTRY(CLSID_DSSnapinEx, CDSSnapinEx)
OBJECT_ENTRY(CLSID_SiteSnapin, CSiteSnapin)
OBJECT_ENTRY(CLSID_DSAboutSnapin, CDSSnapinAbout)
OBJECT_ENTRY(CLSID_SitesAboutSnapin, CSitesSnapinAbout)
OBJECT_ENTRY(CLSID_DSContextMenu, CDSContextMenu)
OBJECT_ENTRY(CLSID_DsAdminCreateObj, CDsAdminCreateObj)
OBJECT_ENTRY(CLSID_DsAdminChooseDCObj, CDsAdminChooseDCObj)
OBJECT_ENTRY(CLSID_DSAdminQueryUIForm, CQueryFormBase)
END_OBJECT_MAP()
CCommandLineOptions _commandLineOptions;
class CDSApp : public CWinApp
{
public:
virtual BOOL InitInstance();
virtual int ExitInstance();
};
CDSApp theApp;
BOOL CDSApp::InitInstance()
{
_Module.Init(ObjectMap, m_hInstance);
InitGroupTypeStringTable();
_commandLineOptions.Initialize();
return CWinApp::InitInstance();
}
int CDSApp::ExitInstance()
{
_Module.Term();
return CWinApp::ExitInstance();
}
/////////////////////////////////////////////////////////////////////////////
// DLL Entry Point
#if (FALSE)
extern "C"
BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID /*lpReserved*/)
{
if (dwReason == DLL_PROCESS_ATTACH)
{
_Module.Init(ObjectMap, hInstance);
DisableThreadLibraryCalls(hInstance);
}
else if (dwReason == DLL_PROCESS_DETACH)
_Module.Term();
return TRUE; // ok
}
#endif
/////////////////////////////////////////////////////////////////////////////
// Used to determine whether the DLL can be unloaded by OLE
STDAPI DllCanUnloadNow(void)
{
#ifdef _USE_MFC
AFX_MANAGE_STATE(AfxGetStaticModuleState());
return (AfxDllCanUnloadNow()==S_OK && _Module.GetLockCount()==0) ? S_OK : S_FALSE;
#else
return (_Module.GetLockCount()==0) ? S_OK : S_FALSE;
#endif
}
/////////////////////////////////////////////////////////////////////////////
// Returns a class factory to create an object of the requested type
STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv)
{
return _Module.GetClassObject(rclsid, riid, ppv);
}
LPCTSTR g_cszBasePath = _T("Software\\Microsoft\\MMC\\SnapIns");
LPCTSTR g_cszNameString = _T("NameString");
LPCTSTR g_cszNameStringIndirect = _T("NameStringIndirect");
LPCTSTR g_cszProvider = _T("Provider");
LPCTSTR g_cszVersion = _T("Version");
LPCTSTR g_cszAbout = _T("About");
LPCTSTR g_cszStandAlone = _T("StandAlone");
LPCTSTR g_cszExtension = _T("Extension");
LPCTSTR g_cszNodeTypes = _T("NodeTypes");
LPCTSTR GUIDToCString(REFGUID guid, CString & str)
{
USES_CONVERSION;
OLECHAR lpszGUID[128];
int nChars = ::StringFromGUID2(guid, lpszGUID, 128);
LPTSTR lpString = OLE2T(lpszGUID);
LPTSTR lpGUID = str.GetBuffer(nChars);
if (lpGUID)
{
CopyMemory(lpGUID, lpString, nChars*sizeof(TCHAR));
str.ReleaseBuffer();
}
return str;
}
HRESULT _RegisterSnapinHelper(CRegKey& rkBase, REFGUID guid,
REFGUID about, UINT nNameStringID,
BOOL bStandalone, CRegKey& rkCLSID)
{
HRESULT hr = S_OK;
CString strKey;
AFX_MANAGE_STATE(AfxGetStaticModuleState());
try
{
CString str;
BOOL result;
// Create snapin GUID key and set properties
rkCLSID.Create(rkBase, GUIDToCString(guid, str));
result = str.LoadString (nNameStringID);
rkCLSID.SetValue(str, g_cszNameString);
// JonN 4/26/00 100624: MUI: MMC: Shared Folders snap-in
// stores its display information in the registry
{
WCHAR szModule[_MAX_PATH];
::GetModuleFileName(AfxGetInstanceHandle(), szModule, _MAX_PATH);
str.Format( _T("@%s,-%d"), szModule, nNameStringID );
rkCLSID.SetValue(str, g_cszNameStringIndirect);
}
str.LoadString (IDS_SNAPIN_PROVIDER);
rkCLSID.SetValue(str, g_cszProvider);
rkCLSID.SetValue(CString(_T("1.0")), g_cszVersion);
// Create "StandAlone" or "Extension" key
CRegKey rkStandAloneOrExtension;
rkStandAloneOrExtension.Create(rkCLSID, bStandalone ? g_cszStandAlone : g_cszExtension);
rkCLSID.SetValue (GUIDToCString(about, str),
g_cszAbout);
}
catch(CMemoryException * e)
{
e->Delete();
hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
}
catch(COleException * e)
{
e->Delete();
hr = SELFREG_E_CLASS;
}
return hr;
}
void _RegisterNodeTypes(CRegKey& rkCLSID, UINT)
{
// Create "NodeTypes" key
CRegKey rkNodeTypes;
rkNodeTypes.Create(rkCLSID, g_cszNodeTypes);
// NodeTypes guids
CString str;
str.LoadString (IDS_SNAPIN_PROVIDER);
CRegKey rkN1;
rkN1.Create(rkNodeTypes, GUIDToCString(cDefaultNodeType, str));
}
void _RegisterQueryForms()
{
PWSTR pszDSQueryCLSID = NULL;
::StringFromCLSID(CLSID_DsQuery, &pszDSQueryCLSID);
ASSERT(pszDSQueryCLSID != NULL);
if (pszDSQueryCLSID != NULL)
{
CString szForms = pszDSQueryCLSID;
::CoTaskMemFree(pszDSQueryCLSID);
szForms = L"CLSID\\" + szForms;
CRegKey rkCLSID_DSQUERY_FORM;
LONG status = rkCLSID_DSQUERY_FORM.Open(HKEY_CLASSES_ROOT, szForms);
if (status != ERROR_SUCCESS)
{
return;
}
CRegKey rkDSUIFormKey;
status = rkDSUIFormKey.Create(rkCLSID_DSQUERY_FORM, L"Forms");
if (status == ERROR_SUCCESS)
{
PWSTR pszDSAFormCLSID = NULL;
::StringFromCLSID(CLSID_DSAdminQueryUIForm, &pszDSAFormCLSID);
ASSERT(pszDSAFormCLSID != NULL);
if (pszDSAFormCLSID != NULL)
{
CRegKey rkDSAdminFormKey;
status = rkDSAdminFormKey.Create(rkDSUIFormKey, pszDSAFormCLSID);
if (status == ERROR_SUCCESS)
{
rkDSAdminFormKey.SetValue(pszDSAFormCLSID, L"CLSID");
}
::CoTaskMemFree(pszDSAFormCLSID);
}
}
}
}
HRESULT RegisterSnapin()
{
HRESULT hr = S_OK;
CString strKey;
AFX_MANAGE_STATE(AfxGetStaticModuleState());
try
{
CString str;
CRegKey rkBase;
INT status;
status = rkBase.Open(HKEY_LOCAL_MACHINE, g_cszBasePath);
if (status || !rkBase.m_hKey)
return hr;
// REGISTER DS ADMIN STANDALONE
CRegKey rkCLSID_DS;
hr = _RegisterSnapinHelper(rkBase, CLSID_DSSnapin, CLSID_DSAboutSnapin,
IDS_DS_MANAGER, TRUE, rkCLSID_DS);
if (SUCCEEDED(hr))
{
_RegisterNodeTypes(rkCLSID_DS, IDS_DS_MANAGER);
}
// REGISTER DS ADMIN EXTENSION
CRegKey rkCLSID_DS_EX;
hr = _RegisterSnapinHelper(rkBase, CLSID_DSSnapinEx, GUID_NULL,
IDS_DS_MANAGER_EX, FALSE, rkCLSID_DS_EX);
if (SUCCEEDED(hr) && rkCLSID_DS_EX.m_hKey != NULL)
{
_RegisterNodeTypes(rkCLSID_DS_EX, IDS_DS_MANAGER_EX);
}
// REGISTER SITE ADMIN STANDALONE
CRegKey rkCLSID_SITE;
hr = _RegisterSnapinHelper(rkBase, CLSID_SiteSnapin, CLSID_SitesAboutSnapin,
IDS_SITE_MANAGER, TRUE, rkCLSID_SITE);
if (SUCCEEDED(hr) && rkCLSID_SITE.m_hKey != NULL)
{
_RegisterNodeTypes(rkCLSID_SITE, IDS_SITE_MANAGER);
}
//
// Register dsquery forms extension
//
_RegisterQueryForms();
}
catch(CMemoryException * e)
{
e->Delete();
hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
}
catch(COleException * e)
{
e->Delete();
hr = SELFREG_E_CLASS;
}
return hr;
}
HRESULT UnregisterSnapin()
{
HRESULT hr = S_OK;
try
{
CRegKey rkBase;
rkBase.Open(HKEY_LOCAL_MACHINE, g_cszBasePath);
if (rkBase.m_hKey != NULL)
{
CString str;
rkBase.RecurseDeleteKey(GUIDToCString(CLSID_DSSnapin, str));
rkBase.RecurseDeleteKey(GUIDToCString(CLSID_DSSnapinEx, str));
rkBase.RecurseDeleteKey(GUIDToCString(CLSID_SiteSnapin, str));
}
}
catch(CException * e)
{
DWORD err = ::GetLastError();
hr = HRESULT_FROM_WIN32(err);
e->Delete();
}
return hr;
}
/////////////////////////////////////////////////////////////////////////////
// DllRegisterServer - Adds entries to the system registry
STDAPI DllRegisterServer(void)
{
HRESULT hRes = S_OK;
// registers objects
hRes = _Module.RegisterServer(FALSE);
if (FAILED(hRes))
return hRes;
hRes = RegisterSnapin();
return hRes;
}
/////////////////////////////////////////////////////////////////////////////
// DllUnregisterServer - Removes entries from the system registry
STDAPI DllUnregisterServer(void)
{
_Module.UnregisterServer();
UnregisterSnapin();
return S_OK;
}
/////////////////////////////////////////////////////////////////////////////
// CTargetingInfo
const DWORD CTargetingInfo::m_dwSaveDomainFlag = 0x1;
#ifdef _MMC_ISNAPIN_PROPERTY
// properties the snapin supports
LPCWSTR g_szServer = L"Server";
LPCWSTR g_szDomain = L"Domain";
LPCWSTR g_szRDN = L"RDN";
HRESULT CTargetingInfo::InitFromSnapinProperties(long cProps, //property count
MMC_SNAPIN_PROPERTY* pProps) //properties array
{
TRACE(L"CTargetingInfo::InitFromSnapinProperties()\n");
// loop through the list of properties and set the variables
BOOL bDomainSpecified = FALSE;
for (long k=0; k< cProps; k++)
{
if (!bDomainSpecified && (_wcsicmp(pProps[k].pszPropName, g_szServer) == 0))
{
m_szStoredTargetName = pProps[k].varValue.bstrVal;
}
else if (_wcsicmp(pProps[k].pszPropName, g_szDomain) == 0)
{
// domain takes the precedence over server name
bDomainSpecified = TRUE;
m_szStoredTargetName = pProps[k].varValue.bstrVal;
}
else if (_wcsicmp(pProps[k].pszPropName, g_szRDN) == 0)
{
m_szRootRDN = pProps[k].varValue.bstrVal;
}
}
// remove leading and trailing blanks
m_szStoredTargetName.TrimLeft();
m_szStoredTargetName.TrimRight();
return S_OK;
}
#endif // _MMC_ISNAPIN_PROPERTY
void CTargetingInfo::_InitFromCommandLine()
{
// get the command line switches /Domain or /Server
LPCWSTR lpszDomainRoot = _commandLineOptions.GetDomainOverride();
LPCWSTR lpszServerName = _commandLineOptions.GetServerOverride();
// domain takes the precedence over server name
m_szStoredTargetName = (lpszDomainRoot != NULL) ? lpszDomainRoot : lpszServerName;
// remove leading and trailing blanks
m_szStoredTargetName.TrimLeft();
m_szStoredTargetName.TrimRight();
m_szRootRDN = _commandLineOptions.GetRDNOverride();
}
HRESULT CTargetingInfo::Load(IStream* pStm)
{
DWORD dwFlagsTemp;
HRESULT hr = LoadDWordHelper(pStm, (DWORD*)&dwFlagsTemp);
if (FAILED(hr))
return hr;
if (dwFlagsTemp == 0)
return S_OK;
if (m_szStoredTargetName.IsEmpty())
{
// no command line parameters:
// read flags and string from stream
m_dwFlags = dwFlagsTemp;
hr = LoadStringHelper(m_szStoredTargetName, pStm);
}
else
{
// have command line parameters:
// we do the load to preserve the loading sequence,
// but we discard the results
CString szThrowAway;
hr = LoadStringHelper(szThrowAway, pStm);
}
return hr;
}
HRESULT CTargetingInfo::Save(IStream* pStm, LPCWSTR lpszCurrentTargetName)
{
HRESULT hr = SaveDWordHelper(pStm, m_dwFlags);
if (FAILED(hr))
return hr;
if (m_dwFlags == 0)
return S_OK;
CString szTemp = lpszCurrentTargetName;
return SaveStringHelper(szTemp, pStm);
}
/////////////////////////////////////////////////////////////////////////////
// CIconManager
HRESULT CIconManager::Init(IImageList* pScpImageList, SnapinType snapintype)
{
if (pScpImageList == NULL)
return E_INVALIDARG;
m_pScpImageList = pScpImageList;
HRESULT hr;
hr = _LoadIconFromResource(
(snapintype == SNAPINTYPE_SITE) ? IDI_SITEREPL : IDI_DSADMIN,
&m_iRootIconIndex);
ASSERT(SUCCEEDED(hr));
if (FAILED(hr))
return hr;
hr = _LoadIconFromResource(
(snapintype == SNAPINTYPE_SITE) ? IDI_SITEREPL_ERR : IDI_DSADMIN_ERR,
&m_iRootIconErrIndex);
ASSERT(SUCCEEDED(hr));
if (FAILED(hr))
return hr;
hr = _LoadIconFromResource(IDI_ICON_WAIT, &m_iWaitIconIndex);
ASSERT(SUCCEEDED(hr));
if (FAILED(hr))
return hr;
hr = _LoadIconFromResource(IDI_ICON_WARN, &m_iWarnIconIndex);
ASSERT(SUCCEEDED(hr));
if (FAILED(hr))
return hr;
hr = _LoadIconFromResource(IDI_FAVORITES, &m_iFavoritesIconIndex);
ASSERT(SUCCEEDED(hr));
if (FAILED(hr))
return hr;
hr = _LoadIconFromResource(IDI_QUERY, &m_iQueryIconIndex);
ASSERT(SUCCEEDED(hr));
hr = _LoadIconFromResource(IDI_QUERY_INVALID, &m_iQueryInvalidIconIndex);
ASSERT(SUCCEEDED(hr));
return hr;
}
HRESULT _SetIconHelper(IImageList* pImageList, HICON hiClass16, HICON hiClass32,
int iIndex, BOOL bAdd32 = FALSE)
{
HRESULT hr = pImageList->ImageListSetIcon((LONG_PTR *)hiClass16, iIndex);
if (SUCCEEDED(hr) && (hiClass32 != NULL))
{
#ifdef ILSI_LARGE_ICON
if (bAdd32)
{
HRESULT hr1 = pImageList->ImageListSetIcon((LONG_PTR *)hiClass32, ILSI_LARGE_ICON(iIndex));
ASSERT(SUCCEEDED(hr1));
}
#endif
}
return hr;
}
HRESULT CIconManager::FillInIconStrip(IImageList* pImageList)
{
// cannot do this passing a scope pane image list interface
ASSERT(m_pScpImageList != pImageList);
HRESULT hr = S_OK;
INT iTempIndex = _GetBaseIndex();
for (POSITION pos = m_IconInfoList.GetHeadPosition(); pos != NULL; )
{
CIconInfo* pInfo = m_IconInfoList.GetNext(pos);
hr = _SetIconHelper(pImageList, pInfo->m_hiClass16, pInfo->m_hiClass32, iTempIndex, TRUE);
if (FAILED(hr))
break;
iTempIndex++;
}
return hr;
}
HRESULT CIconManager::AddClassIcon(IN LPCWSTR lpszClass,
IN MyBasePathsInfo* pPathInfo,
IN DWORD dwFlags,
INOUT int* pnIndex)
{
HICON hiClass16 = pPathInfo->GetIcon(lpszClass, dwFlags, 16,16);
HICON hiClass32 = pPathInfo->GetIcon(lpszClass, dwFlags, 32,32);
return AddIcon(hiClass16, hiClass32, pnIndex);
}
HRESULT CIconManager::AddIcon(IN HICON hiClass16, IN HICON hiClass32, INOUT int* pnIndex)
{
ASSERT(pnIndex != NULL);
ASSERT(hiClass16 != NULL);
ASSERT(m_pScpImageList != NULL);
*pnIndex = -1;
int iNextIcon = _GetNextFreeIndex();
HRESULT hr = _SetIconHelper(m_pScpImageList, hiClass16, hiClass32, iNextIcon);
if (FAILED(hr))
return hr;
CIconInfo* pInfo = new CIconInfo;
if (pInfo)
{
pInfo->m_hiClass16 = hiClass16;
pInfo->m_hiClass32 = hiClass32;
m_IconInfoList.AddTail(pInfo);
*pnIndex = iNextIcon;
}
return hr;
}
HRESULT CIconManager::_LoadIconFromResource(IN UINT nIconResID, INOUT int* pnIndex)
{
ASSERT(pnIndex != NULL);
ASSERT(m_pScpImageList != NULL);
HICON hIcon = ::LoadIcon(_Module.GetModuleInstance(),
MAKEINTRESOURCE(nIconResID));
ASSERT(hIcon != NULL);
if (hIcon == NULL)
return E_INVALIDARG;
return AddIcon(hIcon, NULL, pnIndex);
}
/////////////////////////////////////////////////////////////////////////////
// CInternalFormatCracker
HRESULT CInternalFormatCracker::Extract(LPDATAOBJECT lpDataObject)
{
_Free();
if (lpDataObject == NULL)
return E_INVALIDARG;
SMMCDataObjects * pDO = NULL;
STGMEDIUM stgmedium = { TYMED_HGLOBAL, NULL };
FORMATETC formatetc = { CDSDataObject::m_cfInternal, NULL,
DVASPECT_CONTENT, -1, TYMED_HGLOBAL
};
FORMATETC formatetc2 = { CDSDataObject::m_cfMultiSelDataObjs, NULL,
DVASPECT_CONTENT, -1, TYMED_HGLOBAL
};
HRESULT hr = lpDataObject->GetData(&formatetc2, &stgmedium);
if (FAILED(hr)) {
// Attempt to get data from the object
do
{
hr = lpDataObject->GetData(&formatetc, &stgmedium);
if (FAILED(hr))
break;
m_pInternalFormat = reinterpret_cast<INTERNAL*>(stgmedium.hGlobal);
if (m_pInternalFormat == NULL)
{
if (SUCCEEDED(hr))
hr = E_FAIL;
break;
}
} while (FALSE);
return hr;
} else {
pDO = reinterpret_cast<SMMCDataObjects*>(stgmedium.hGlobal);
for (UINT i = 0; i < pDO->count; i++) {
hr = pDO->lpDataObject[i]->GetData(&formatetc, &stgmedium);
if (FAILED(hr))
break;
m_pInternalFormat = reinterpret_cast<INTERNAL*>(stgmedium.hGlobal);
if (m_pInternalFormat != NULL)
break;
}
}
return hr;
}
LPDATAOBJECT
CInternalFormatCracker::ExtractMultiSelect(LPDATAOBJECT lpDataObject)
{
_Free();
if (lpDataObject == NULL)
return NULL;
SMMCDataObjects * pDO = NULL;
STGMEDIUM stgmedium = { TYMED_HGLOBAL, NULL };
FORMATETC formatetc = { CDSDataObject::m_cfMultiSelDataObjs, NULL,
DVASPECT_CONTENT, -1, TYMED_HGLOBAL
};
if (FAILED(lpDataObject->GetData(&formatetc, &stgmedium))) {
return NULL;
} else {
pDO = reinterpret_cast<SMMCDataObjects*>(stgmedium.hGlobal);
return pDO->lpDataObject[0]; //assume that ours is the 1st
}
}
/////////////////////////////////////////////////////////////////////
// CObjectNamesFormatCracker
CLIPFORMAT CObjectNamesFormatCracker::m_cfDsObjectNames =
(CLIPFORMAT)RegisterClipboardFormat(CFSTR_DSOBJECTNAMES);
HRESULT CObjectNamesFormatCracker::Extract(LPDATAOBJECT lpDataObject)
{
_Free();
if (lpDataObject == NULL)
return E_INVALIDARG;
STGMEDIUM stgmedium = { TYMED_HGLOBAL, NULL };
FORMATETC formatetc = { m_cfDsObjectNames, NULL,
DVASPECT_CONTENT, -1, TYMED_HGLOBAL
};
HRESULT hr = lpDataObject->GetData(&formatetc, &stgmedium);
if (FAILED(hr))
{
return hr;
}
m_pDsObjectNames = reinterpret_cast<LPDSOBJECTNAMES>(stgmedium.hGlobal);
if (m_pDsObjectNames == NULL)
{
if (SUCCEEDED(hr))
hr = E_FAIL;
}
return hr;
}
/////////////////////////////////////////////////////////////////////
// CDSNotifyHandlerManager
typedef struct
{
DWORD cNotifyExtensions; // how many extension CLSIDs?
CLSID aNotifyExtensions[1];
} DSCLASSNOTIFYINFO, * LPDSCLASSNOTIFYINFO;
HRESULT DsGetClassNotifyInfo(IN MyBasePathsInfo* pBasePathInfo,
OUT LPDSCLASSNOTIFYINFO* ppInfo)
{
static LPCWSTR lpszSettingsObjectClass = L"dsUISettings";
static LPCWSTR lpszSettingsObject = L"cn=DS-UI-Default-Settings";
static LPCWSTR lpszNotifyProperty = L"dsUIAdminNotification";
if ( (ppInfo == NULL) || (pBasePathInfo == NULL) )
return E_INVALIDARG;
*ppInfo = NULL;
// get the display specifiers locale container (e.g. 409)
CComPtr<IADsContainer> spLocaleContainer;
HRESULT hr = pBasePathInfo->GetDisplaySpecifier(NULL, IID_IADsContainer, (void**)&spLocaleContainer);
if (FAILED(hr))
return hr;
// bind to the settings object
CComPtr<IDispatch> spIDispatchObject;
hr = spLocaleContainer->GetObject((LPWSTR)lpszSettingsObjectClass,
(LPWSTR)lpszSettingsObject,
&spIDispatchObject);
if (FAILED(hr))
return hr;
CComPtr<IADs> spSettingsObject;
hr = spIDispatchObject->QueryInterface(IID_IADs, (void**)&spSettingsObject);
if (FAILED(hr))
return hr;
// get multivaled property in string list form
CComVariant var;
CStringList stringList;
hr = spSettingsObject->Get((LPWSTR)lpszNotifyProperty, &var);
if (FAILED(hr))
return hr;
hr = HrVariantToStringList(var, stringList);
if (FAILED(hr))
return hr;
size_t nCount = stringList.GetCount();
// allocate memory
DWORD cbCount = sizeof(DSCLASSNOTIFYINFO);
if (nCount>1)
cbCount += static_cast<ULONG>((nCount-1)*sizeof(CLSID));
*ppInfo = (LPDSCLASSNOTIFYINFO)::LocalAlloc(LPTR, cbCount);
if ((*ppInfo) == NULL)
return E_OUTOFMEMORY;
ZeroMemory(*ppInfo, cbCount);
(*ppInfo)->cNotifyExtensions = 0;
int* pArr = new int[nCount];
if (!pArr)
{
return E_OUTOFMEMORY;
}
CString szEntry, szIndex, szGUID;
for (POSITION pos = stringList.GetHeadPosition(); pos != NULL; )
{
szEntry = stringList.GetNext(pos);
int nComma = szEntry.Find(L",");
if (nComma == -1)
continue;
szIndex = szEntry.Left(nComma);
int nIndex = _wtoi((LPCWSTR)szIndex);
if (nIndex <= 0)
continue; // allow from 1 up
// strip leading and traling blanks
szGUID = szEntry.Mid(nComma+1);
szGUID.TrimLeft();
szGUID.TrimRight();
GUID* pGuid= &((*ppInfo)->aNotifyExtensions[(*ppInfo)->cNotifyExtensions]);
hr = ::CLSIDFromString((LPWSTR)(LPCWSTR)szGUID, pGuid);
if (SUCCEEDED(hr))
{
pArr[(*ppInfo)->cNotifyExtensions] = nIndex;
((*ppInfo)->cNotifyExtensions)++;
}
}
if (((*ppInfo)->cNotifyExtensions) > 1)
{
// need to sort by index in pArr
while (TRUE)
{
BOOL bSwapped = FALSE;
for (UINT k=1; k < ((*ppInfo)->cNotifyExtensions); k++)
{
if (pArr[k] < pArr[k-1])
{
// swap
int nTemp = pArr[k];
pArr[k] = pArr[k-1];
pArr[k-1] = nTemp;
GUID temp = (*ppInfo)->aNotifyExtensions[k];
(*ppInfo)->aNotifyExtensions[k] = (*ppInfo)->aNotifyExtensions[k-1];
(*ppInfo)->aNotifyExtensions[k-1] = temp;
bSwapped = TRUE;
}
}
if (!bSwapped)
break;
}
}
delete[] pArr;
pArr = 0;
return S_OK;
}
HRESULT CDSNotifyHandlerManager::Init()
{
_Free(); // prepare for delayed initialization
return S_OK;
}
HRESULT CDSNotifyHandlerManager::Load(MyBasePathsInfo* pBasePathInfo)
{
if (m_state != uninitialized)
return S_OK; // already done, bail out
// start the initialization process
ASSERT(m_pInfoArr == NULL);
m_state = noHandlers;
LPDSCLASSNOTIFYINFO pInfo = NULL;
HRESULT hr = DsGetClassNotifyInfo(pBasePathInfo, &pInfo);
if (SUCCEEDED(hr) && (pInfo != NULL) && (pInfo->cNotifyExtensions > 0))
{
m_nArrSize = pInfo->cNotifyExtensions;
m_pInfoArr = new CDSNotifyHandlerInfo[m_nArrSize];
for (DWORD i=0; i<pInfo->cNotifyExtensions; i++)
{
hr = ::CoCreateInstance(pInfo->aNotifyExtensions[i],
NULL, CLSCTX_INPROC_SERVER,
IID_IDsAdminNotifyHandler,
(void**)(&m_pInfoArr[i].m_spIDsAdminNotifyHandler));
if (SUCCEEDED(hr) && m_pInfoArr[i].m_spIDsAdminNotifyHandler != NULL)
{
hr = m_pInfoArr[i].m_spIDsAdminNotifyHandler->Initialize(NULL,
&(m_pInfoArr[i].m_nRegisteredEvents));
if (FAILED(hr) || m_pInfoArr[i].m_nRegisteredEvents == 0)
{
// release if init failed or not registered for any event
m_pInfoArr[i].m_spIDsAdminNotifyHandler = NULL;
}
else
{
m_state = hasHandlers;
} //if
} //if
} // for
} // if
if (pInfo != NULL)
::LocalFree(pInfo);
return S_OK;
}
void CDSNotifyHandlerManager::Begin(ULONG uEvent, IDataObject* pArg1, IDataObject* pArg2)
{
ASSERT(m_state == hasHandlers);
HRESULT hr;
for (UINT i=0; i<m_nArrSize; i++)
{
ASSERT(!m_pInfoArr[i].m_bTransactionPending);
ASSERT(!m_pInfoArr[i].m_bNeedsNotify);
ASSERT(m_pInfoArr[i].m_nFlags == 0);
ASSERT(m_pInfoArr[i].m_szDisplayString.IsEmpty());
if ( (m_pInfoArr[i].m_spIDsAdminNotifyHandler != NULL) &&
(m_pInfoArr[i].m_nRegisteredEvents & uEvent) )
{
//
// this call is to set the context information for the event,
// we ignore the returned result
//
CComBSTR bstr;
hr = m_pInfoArr[i].m_spIDsAdminNotifyHandler->Begin(
uEvent, pArg1, pArg2,
&(m_pInfoArr[i].m_nFlags), &bstr);
if (SUCCEEDED(hr) && (bstr != NULL) && (bstr[0] != NULL))
{
//
// extension accepted the notification
//
m_pInfoArr[i].m_bNeedsNotify = TRUE;
m_pInfoArr[i].m_szDisplayString = bstr;
}
//
// mark the extension with a pending transaction
// on it. we will have to call End()
//
m_pInfoArr[i].m_bTransactionPending = TRUE;
} //if
} // for
}
void CDSNotifyHandlerManager::Notify(ULONG nItem, ULONG uEvent)
{
ASSERT(m_state == hasHandlers);
HRESULT hr;
for (UINT i=0; i<m_nArrSize; i++)
{
if ( (m_pInfoArr[i].m_spIDsAdminNotifyHandler != NULL) &&
(m_pInfoArr[i].m_nRegisteredEvents & uEvent) && m_pInfoArr[i].m_bNeedsNotify)
{
// should only call if the transaction was started by a Begin() call
ASSERT(m_pInfoArr[i].m_bTransactionPending);
hr = m_pInfoArr[i].m_spIDsAdminNotifyHandler->Notify(nItem,
m_pInfoArr[i].m_nFlags);
} //if
} // for
}
void CDSNotifyHandlerManager::End(ULONG uEvent)
{
ASSERT(m_state == hasHandlers);
HRESULT hr;
for (UINT i=0; i<m_nArrSize; i++)
{
if ( (m_pInfoArr[i].m_spIDsAdminNotifyHandler != NULL) &&
(m_pInfoArr[i].m_nRegisteredEvents & uEvent) )
{
ASSERT(m_pInfoArr[i].m_bTransactionPending);
hr = m_pInfoArr[i].m_spIDsAdminNotifyHandler->End();
// reset the state flags
m_pInfoArr[i].m_bNeedsNotify = FALSE;
m_pInfoArr[i].m_bTransactionPending = FALSE;
m_pInfoArr[i].m_nFlags= 0;
m_pInfoArr[i].m_szDisplayString.Empty();
} //if
} // for
}
UINT CDSNotifyHandlerManager::NeedNotifyCount(ULONG uEvent)
{
ASSERT(m_state == hasHandlers);
UINT iCount = 0;
for (UINT i=0; i<m_nArrSize; i++)
{
if ( (m_pInfoArr[i].m_spIDsAdminNotifyHandler != NULL) &&
(m_pInfoArr[i].m_nRegisteredEvents & uEvent) &&
m_pInfoArr[i].m_bNeedsNotify)
{
ASSERT(m_pInfoArr[i].m_bTransactionPending);
iCount++;
} //if
} // for
return iCount;
}
void CDSNotifyHandlerManager::SetCheckListBox(CCheckListBox* pCheckListBox, ULONG uEvent)
{
ASSERT(m_state == hasHandlers);
UINT iListBoxIndex = 0;
for (UINT i=0; i<m_nArrSize; i++)
{
if ( (m_pInfoArr[i].m_spIDsAdminNotifyHandler != NULL) &&
(m_pInfoArr[i].m_nRegisteredEvents & uEvent) &&
m_pInfoArr[i].m_bNeedsNotify)
{
ASSERT(m_pInfoArr[i].m_bTransactionPending);
pCheckListBox->InsertString(iListBoxIndex, m_pInfoArr[i].m_szDisplayString);
int nCheck = 0;
if (m_pInfoArr[i].m_nFlags & DSA_NOTIFY_FLAG_ADDITIONAL_DATA)
nCheck = 1;
pCheckListBox->SetCheck(iListBoxIndex, nCheck);
if (m_pInfoArr[i].m_nFlags & DSA_NOTIFY_FLAG_FORCE_ADDITIONAL_DATA)
pCheckListBox->Enable(iListBoxIndex, FALSE);
pCheckListBox->SetItemData(iListBoxIndex, (DWORD_PTR)(&m_pInfoArr[i]));
iListBoxIndex++;
} //if
} // for
}
void CDSNotifyHandlerManager::ReadFromCheckListBox(CCheckListBox* pCheckListBox, ULONG)
{
ASSERT(m_state == hasHandlers);
int nCount = pCheckListBox->GetCount();
ASSERT(nCount != LB_ERR);
for (int i=0; i< nCount; i++)
{
int nCheck = pCheckListBox->GetCheck(i);
CDSNotifyHandlerInfo* pInfo = (CDSNotifyHandlerInfo*)
pCheckListBox->GetItemData(i);
ASSERT(pInfo != NULL);
if ((pInfo->m_nFlags & DSA_NOTIFY_FLAG_FORCE_ADDITIONAL_DATA) == 0)
{
if (nCheck == 0)
pInfo->m_nFlags &= ~DSA_NOTIFY_FLAG_ADDITIONAL_DATA;
else
pInfo->m_nFlags |= DSA_NOTIFY_FLAG_ADDITIONAL_DATA;
}
} // for
}
//////////////////////////////////////////////////////////////////////
// IComponentData implementation
// WARNING this ctor passes an incomplete "this" pointer to other ctors
CDSComponentData::CDSComponentData() :
m_pShlInit(NULL),
m_pScope(NULL),
m_pFrame(NULL)
#ifdef _MMC_ISNAPIN_PROPERTY
,
m_pProperties(NULL)
#endif //_MMC_ISNAPIN_PROPERTY
{
ExceptionPropagatingInitializeCriticalSection(&m_cs);
m_ActiveDS = NULL;
m_pClassCache = NULL;
m_pQueryFilter = NULL;
m_pFavoritesNodesHolder = NULL;
m_pHiddenWnd = NULL;
m_pBackgroundThreadInfo = new CBackgroundThreadInfo;
m_pScpImageList = NULL;
m_bRunAsPrimarySnapin = TRUE;
m_bAddRootWhenExtended = FALSE;
m_bDirty = FALSE;
m_SerialNumber = 1000; // arbitrary starting point
m_ColumnWidths[0] = DEFAULT_NAME_COL_WIDTH;
m_ColumnWidths[1] = DEFAULT_TYPE_COL_WIDTH;
m_ColumnWidths[2] = DEFAULT_DESC_COL_WIDTH;
m_InitSuccess = FALSE;
m_InitAttempted = FALSE;
m_lpszSnapinHelpFile = NULL;
}
HRESULT CDSComponentData::FinalConstruct()
{
// This must be delayed until this ctor so that the virtual
// callouts work propery
// create and initialize hidden window
m_pHiddenWnd = new CHiddenWnd(this);
if (m_pHiddenWnd == NULL)
return E_OUTOFMEMORY;
if (!m_pHiddenWnd->Create())
{
TRACE(_T("Failed to create hidden window\n"));
ASSERT(FALSE);
return E_FAIL;
}
// create directory object
m_ActiveDS = new CDSDirect (this);
if (m_ActiveDS == NULL)
return E_OUTOFMEMORY;
// create class cache
m_pClassCache = new CDSCache;
if (m_pClassCache == NULL)
return E_OUTOFMEMORY;
m_pClassCache->Initialize(QuerySnapinType(), GetBasePathsInfo(), TRUE);
// create saved queries holder
if (QuerySnapinType() == SNAPINTYPE_DS)
{
m_pFavoritesNodesHolder = new CFavoritesNodesHolder();
if (m_pFavoritesNodesHolder == NULL)
return E_OUTOFMEMORY;
// REVIEW_MARCOC_PORT this is just to test/demo
// m_pFavoritesNodesHolder->BuildTestTree(_commandLineOptions.GetSavedQueriesXMLFile(),
// QuerySnapinType());
// graft the subtree under the snapin root
m_RootNode.GetFolderInfo()->AddNode(m_pFavoritesNodesHolder->GetFavoritesRoot());
}
// create filter
m_pQueryFilter = new CDSQueryFilter();
if (m_pQueryFilter == NULL)
return E_OUTOFMEMORY;
/* BUGBUG BUGBUG: 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");
}
}
return S_OK;
}
void CDSComponentData::FinalRelease()
{
_DeleteHiddenWnd();
// Dump the profiling data
DUMP_PROFILING_RESULTS;
}
CDSComponentData::~CDSComponentData()
{
TRACE(_T("~CDSComponentData entered...\n"));
::DeleteCriticalSection(&m_cs);
ASSERT(m_pScope == NULL);
if (m_pBackgroundThreadInfo != NULL)
{
delete m_pBackgroundThreadInfo;
}
// clean up the Class Cache
if (m_pClassCache != NULL)
{
delete m_pClassCache;
m_pClassCache = NULL;
}
// cleanup saved queries holder
if (m_pFavoritesNodesHolder != NULL)
{
m_RootNode.GetFolderInfo()->RemoveNode(m_pFavoritesNodesHolder->GetFavoritesRoot());
delete m_pFavoritesNodesHolder;
m_pFavoritesNodesHolder = NULL;
}
// clean up the ADSI interface
if (m_ActiveDS != NULL)
{
delete m_ActiveDS;
m_ActiveDS = NULL;
}
if (m_pShlInit)
{
m_pShlInit->Release();
m_pShlInit = NULL;
}
if (m_pScpImageList) {
m_pScpImageList->Release();
m_pScpImageList = NULL;
}
if (m_pQueryFilter) {
delete m_pQueryFilter;
m_pQueryFilter = NULL;
}
if (g_lpszLoggedInUser != NULL)
{
delete[] g_lpszLoggedInUser;
g_lpszLoggedInUser = NULL;
}
TRACE(_T("~CDSComponentData leaving...\n"));
}
HWND CDSComponentData::GetHiddenWindow()
{
ASSERT(m_pHiddenWnd != NULL);
ASSERT(::IsWindow(m_pHiddenWnd->m_hWnd));
return m_pHiddenWnd->m_hWnd;
}
void CDSComponentData::_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;
}
BOOL CDSComponentData::ExpandComputers()
{
Lock();
BOOL b = m_pQueryFilter->ExpandComputers();
Unlock();
return b;
}
BOOL CDSComponentData::IsAdvancedView()
{
return m_pQueryFilter->IsAdvancedView();
}
BOOL CDSComponentData::ViewServicesNode()
{
return m_pQueryFilter->ViewServicesNode();
}
class CLockHandler
{
public:
CLockHandler(CDSComponentData* pCD)
{
m_pCD = pCD;
m_pCD->Lock();
}
~CLockHandler()
{
m_pCD->Unlock();
}
private:
CDSComponentData* m_pCD;
};
STDMETHODIMP CDSComponentData::Initialize(LPUNKNOWN pUnknown)
{
ASSERT(pUnknown != NULL);
HRESULT hr;
AFX_MANAGE_STATE(AfxGetStaticModuleState());
// MMC should only call ::Initialize once!
ASSERT(m_pScope == NULL);
pUnknown->QueryInterface(IID_IConsoleNameSpace2,
reinterpret_cast<void**>(&m_pScope));
// Get console's pre-registered clipboard formats
hr = pUnknown->QueryInterface(IID_IConsole3, reinterpret_cast<void**>(&m_pFrame));
if (FAILED(hr))
{
TRACE(TEXT("QueryInterface for IID_IConsole3 failed, hr: 0x%x\n"), hr);
return hr;
}
//
// 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.
//
hr = CoCreateInstance(CLSID_DsPropertyPages, NULL, CLSCTX_INPROC_SERVER,
IID_IShellExtInit, (void **)&m_pShlInit);
if (FAILED(hr))
{
TRACE(TEXT("CoCreateInstance on CLSID_DsPropertyPages failed, hr: 0x%x\n"), hr);
return hr;
}
hr = m_pFrame->QueryScopeImageList (&m_pScpImageList);
if (FAILED(hr))
{
TRACE(TEXT("Query for ScopeImageList failed, hr: 0x%x\n"), hr);
return hr;
}
hr = m_iconManager.Init(m_pScpImageList, QuerySnapinType());
if (FAILED(hr))
{
TRACE(TEXT("m_iconManager.Init() failed, hr: 0x%x\n"), hr);
return hr;
}
if (!_StartBackgroundThread())
return E_FAIL;
m_pFrame->GetMainWindow(&m_hwnd);
// NOTICE: we should initialize the filter only if the MyBasePathsInfo
// initialization call has succeeded (need schema path for filtering).
// In reality, we need the filter initialized for loading from a stream:
// with a failure, this initialization is "wrong" because it has
// bad naming context info, but we will re initalize when we get good
// info through retargeting
hr = m_pQueryFilter->Init(this);
if (FAILED(hr))
return hr;
return S_OK;
}
STDMETHODIMP CDSComponentData::CreateComponent(LPCOMPONENT* ppComponent)
{
ASSERT(ppComponent != NULL);
CComObject<CDSEvent>* pObject;
CComObject<CDSEvent>::CreateInstance(&pObject);
ASSERT(pObject != NULL);
// Store IComponentData
pObject->SetIComponentData(this);
return pObject->QueryInterface(IID_IComponent,
reinterpret_cast<void**>(ppComponent));
}
STDMETHODIMP CDSComponentData::Notify(LPDATAOBJECT lpDataObject, MMC_NOTIFY_TYPE event, LPARAM arg, LPARAM param)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
ASSERT(m_pScope != NULL);
HRESULT hr = S_FALSE;
CUINode* pUINode = NULL;
// 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 (lpDataObject != NULL)
{
CInternalFormatCracker dobjCracker;
if (FAILED(dobjCracker.Extract(lpDataObject)))
{
if ((event == MMCN_EXPAND) && (arg == TRUE) && !m_bRunAsPrimarySnapin)
{
// this is a namespace extension, need to add
// the root of the snapin
hr = _OnNamespaceExtensionExpand(lpDataObject, param);
if (FAILED(hr))
{
hr = S_FALSE;
}
return hr;
}
return S_OK;
}
// got a valid data object
pUINode = dobjCracker.GetCookie();
}
if (event == MMCN_PROPERTY_CHANGE)
{
TRACE(_T("CDSComponentData::Notify() - property change, pDataObj = 0x%08x, param = 0x%08x, arg = %d.\n"),
lpDataObject, param, arg);
if (param != 0)
{
hr = _OnPropertyChange((LPDATAOBJECT)param, TRUE);
if (FAILED(hr))
{
hr = S_FALSE;
}
return hr;
}
return S_FALSE;
}
if (pUINode == NULL)
return S_FALSE;
switch (event)
{
case MMCN_PRELOAD:
{
_OnPreload((HSCOPEITEM)arg);
hr = S_OK;
}
break;
case MMCN_EXPANDSYNC:
{
MMC_EXPANDSYNC_STRUCT* pExpandStruct =
reinterpret_cast<MMC_EXPANDSYNC_STRUCT*>(param);
if (pExpandStruct->bExpanding)
{
_OnExpand(pUINode, pExpandStruct->hItem,event);
pExpandStruct->bHandled = TRUE;
hr = S_OK;
}
}
break;
case MMCN_EXPAND:
if (arg == TRUE)
{ // Show
_OnExpand(pUINode,(HSCOPEITEM)param,event);
hr = S_OK;
}
break;
case MMCN_DELETE:
{
CDSUINode* pDSUINode = dynamic_cast<CDSUINode*>(pUINode);
if (pDSUINode == NULL)
{
hr = pUINode->Delete(this);
}
else
{
hr = _DeleteFromBackendAndUI(lpDataObject, pDSUINode);
}
if (FAILED(hr))
{
hr = S_FALSE;
}
}
break;
case MMCN_RENAME:
hr = _Rename (pUINode, (LPWSTR)param);
if (FAILED(hr))
{
hr = S_FALSE;
}
break;
case MMCN_REFRESH:
hr = Refresh (pUINode);
if (FAILED(hr))
{
hr = S_FALSE;
}
break;
default:
hr = S_FALSE;
}
return hr;
}
STDMETHODIMP CDSComponentData::Destroy()
{
// sever all ties with cookies having pending requests
m_queryNodeTable.Reset();
// wait for all the threads to shut down.
_ShutDownBackgroundThread();
// destroy the hidden window
_DeleteHiddenWnd();
if (m_pScope)
{
m_pScope->Release();
m_pScope = NULL;
}
if (m_pFrame)
{
m_pFrame->Release();
m_pFrame = NULL;
}
#ifdef _MMC_ISNAPIN_PROPERTY
if (m_pProperties)
{
m_pProperties->Release();
m_pProperties = NULL;
}
#endif //_MMC_ISNAPIN_PROPERTY
return S_OK;
}
STDMETHODIMP CDSComponentData::QueryDataObject(MMC_COOKIE cookie, DATA_OBJECT_TYPES type,
LPDATAOBJECT* ppDataObject)
{
ASSERT(ppDataObject != NULL);
HRESULT hr;
CUINode* pNode;
CComObject<CDSDataObject>* pObject;
CComObject<CDSDataObject>::CreateInstance(&pObject);
ASSERT(pObject != NULL);
if (pObject != NULL)
{
// Check to see if we have a valid cookie or we should use the snapin
// cookie
//
pNode = reinterpret_cast<CUINode*>(cookie);
if (pNode == NULL)
{
pNode = &m_RootNode;
}
// Save cookie and type for delayed rendering
pObject->SetType(type, QuerySnapinType());
pObject->SetComponentData(this);
pObject->SetCookie(pNode);
hr = pObject->QueryInterface(IID_IDataObject,
reinterpret_cast<void**>(ppDataObject));
//TRACE(_T("xx.%03x> CDSComponentData::QueryDataObject (CDsDataObject 0x%x)\n"),
// GetCurrentThreadId(), *ppDataObject);
}
else
{
hr = E_OUTOFMEMORY;
}
return hr;
}
STDMETHODIMP CDSComponentData::GetDisplayInfo(LPSCOPEDATAITEM scopeInfo)
{
CUINode* pNode = reinterpret_cast<CUINode*>(scopeInfo->lParam);
ASSERT(pNode != NULL);
ASSERT(pNode->IsContainer());
if (scopeInfo->mask & SDI_STR)
{
#ifdef DBG
BOOL bNoName = (pNode->GetParent() == &m_RootNode) && _commandLineOptions.IsNoNameCommandLine();
scopeInfo->displayname = bNoName ? L"" : const_cast<LPTSTR>(pNode->GetName());
#else
scopeInfo->displayname = const_cast<LPTSTR>(pNode->GetName());
#endif
}
if (scopeInfo->mask & SDI_IMAGE)
{
scopeInfo->nImage = GetImage(pNode, FALSE);
}
if (scopeInfo->mask & SDI_OPENIMAGE)
{
scopeInfo->nOpenImage = GetImage(pNode, TRUE);
}
return S_OK;
}
///////////////////////////////////////////////////////////////////////////////
//// IPersistStream interface members
STDMETHODIMP CDSComponentData::GetClassID(CLSID *pClassID)
{
ASSERT(pClassID != NULL);
ASSERT(m_bRunAsPrimarySnapin);
// Copy the CLSID for this snapin
switch (QuerySnapinType())
{
case SNAPINTYPE_DS:
*pClassID = CLSID_DSSnapin;
break;
case SNAPINTYPE_DSEX:
*pClassID = CLSID_DSSnapinEx;
break;
case SNAPINTYPE_SITE:
*pClassID = CLSID_SiteSnapin;
break;
default:
ASSERT(FALSE);
return E_FAIL;
}
return S_OK;
}
STDMETHODIMP CDSComponentData::IsDirty()
{
ASSERT(m_bRunAsPrimarySnapin);
m_pFrame->UpdateAllViews(NULL, NULL, DS_CHECK_COLUMN_WIDTHS);
return m_bDirty ? S_OK : S_FALSE;
}
// IMPORTANT NOTICE: this value has to be bumped up EVERY time
// a change is made to the stream format
#define DS_STREAM_VERSION ((DWORD)0x08)
#define DS_STREAM_BEFORE_SAVED_QUERIES ((DWORD)0x07)
#define DS_STREAM_W2K_VERSION ((DWORD)0x07)
STDMETHODIMP CDSComponentData::Load(IStream *pStm)
{
// serialization on extensions not supported
if (!m_bRunAsPrimarySnapin)
return E_FAIL;
ASSERT(pStm);
// read the version ##
DWORD dwVersion;
HRESULT hr = LoadDWordHelper(pStm, &dwVersion);
// if ( FAILED(hr) ||(dwVersion != DS_STREAM_VERSION) )
if (FAILED(hr) || dwVersion < DS_STREAM_W2K_VERSION)
return E_FAIL;
// read targeting info
hr = m_targetingInfo.Load(pStm);
if (FAILED(hr))
return hr;
//
// Initialize the root from the target info so that columns
// can be loaded from the DS
//
hr = _InitRootFromCurrentTargetInfo();
if (FAILED(hr))
return hr;
// read filtering options
hr = m_pQueryFilter->Load(pStm);
if (FAILED(hr))
return hr;
// read the class cache information
hr = m_pClassCache->Load(pStm);
if (FAILED(hr))
return hr;
if (dwVersion > DS_STREAM_BEFORE_SAVED_QUERIES)
{
hr = m_pFavoritesNodesHolder->Load(pStm, this);
if (FAILED(hr))
{
return hr;
}
}
m_bDirty = FALSE; // start clean
return hr;
}
STDMETHODIMP CDSComponentData::Save(IStream *pStm, BOOL fClearDirty)
{
// serialization on extensions not supported
if (!m_bRunAsPrimarySnapin)
return E_FAIL;
ASSERT(pStm);
// write the version ##
HRESULT hr = SaveDWordHelper(pStm, DS_STREAM_VERSION);
if (FAILED(hr))
return hr;
// save targeting info
hr = m_targetingInfo.Save(pStm, GetBasePathsInfo()->GetDomainName());
if (FAILED(hr))
return hr;
// save filtering options
hr = m_pQueryFilter->Save(pStm);
if (FAILED(hr))
return hr;
// save the class cache information
hr = m_pClassCache->Save(pStm);
if (FAILED(hr))
return hr;
if (QuerySnapinType() == SNAPINTYPE_DS)
{
//
// Save the saved queries folder for dsadmin only
//
hr = m_pFavoritesNodesHolder->Save(pStm);
if (FAILED(hr))
return hr;
}
if (fClearDirty)
m_bDirty = FALSE;
return hr;
}
STDMETHODIMP CDSComponentData::GetSizeMax(ULARGE_INTEGER *pcbSize)
{
ASSERT(pcbSize);
ASSERT(FALSE);
//
// Arbitrary values but I don't think we ever get called
//
pcbSize->LowPart = 0xffff;
pcbSize->HighPart= 0x0;
return S_OK;
}
/////////////////////////////////////////////////////////////////////////////
// IExtendPropertySheet Implementation
//+----------------------------------------------------------------------------
//
// Member: CDSComponentData::IExtendPropertySheet::CreatePropertyPages
//
// Synopsis: Called in response to a user click on the Properties context
// menu item.
//
//-----------------------------------------------------------------------------
STDMETHODIMP
CDSComponentData::CreatePropertyPages(LPPROPERTYSHEETCALLBACK pCall,
LONG_PTR lNotifyHandle,
LPDATAOBJECT pDataObject)
{
CDSCookie* pCookie = NULL;
TRACE(_T("xx.%03x> CDSComponentData::CreatePropertyPages()\n"),
GetCurrentThreadId());
//
// Validate Inputs
//
if (pCall == NULL)
{
return E_INVALIDARG;
}
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = S_OK;
CInternalFormatCracker dobjCracker;
if (FAILED(dobjCracker.Extract(pDataObject)))
{
return E_NOTIMPL;
}
//
// Pass the Notify Handle to the data object.
//
PROPSHEETCFG SheetCfg = {lNotifyHandle};
FORMATETC fe = {CDSDataObject::m_cfPropSheetCfg, NULL, DVASPECT_CONTENT,
-1, TYMED_HGLOBAL};
STGMEDIUM sm = {TYMED_HGLOBAL, NULL, NULL};
sm.hGlobal = (HGLOBAL)&SheetCfg;
pDataObject->SetData(&fe, &sm, FALSE);
if (dobjCracker.GetCookieCount() > 1) // multiple selection
{
//
// Pass a unique identifier to the data object
//
GUID guid;
hr = ::CoCreateGuid(&guid);
if (FAILED(hr))
{
ASSERT(FALSE);
return hr;
}
WCHAR pszGuid[40];
if (!::StringFromGUID2(guid, pszGuid, 40))
{
ASSERT(FALSE);
return E_FAIL;
}
FORMATETC multiSelectfe = {CDSDataObject::m_cfMultiSelectProppage, NULL, DVASPECT_CONTENT,
-1, TYMED_HGLOBAL};
STGMEDIUM multiSelectsm = {TYMED_HGLOBAL, NULL, NULL};
multiSelectsm.hGlobal = (HGLOBAL)pszGuid;
pDataObject->SetData(&multiSelectfe, &multiSelectsm, FALSE);
hr = GetClassCache()->TabCollect_AddMultiSelectPropertyPages(pCall, lNotifyHandle, pDataObject, GetBasePathsInfo());
}
else // single selection
{
CUINode* pUINode = dobjCracker.GetCookie();
if (pUINode == NULL)
{
return E_NOTIMPL;
}
CDSUINode* pDSUINode = dynamic_cast<CDSUINode*>(pUINode);
if (pDSUINode == NULL)
{
//
// Delegate page creation to the node
//
return pUINode->CreatePropertyPages(pCall, lNotifyHandle, pDataObject, this);
}
pCookie = GetDSCookieFromUINode(pDSUINode);
ASSERT(pCookie != NULL);
CString szPath;
GetBasePathsInfo()->ComposeADsIPath(szPath, pCookie->GetPath());
FORMATETC mfe = {CDSDataObject::m_cfMultiSelectProppage, NULL, DVASPECT_CONTENT,
-1, TYMED_HGLOBAL};
STGMEDIUM msm = {TYMED_HGLOBAL, NULL, NULL};
msm.hGlobal = (HGLOBAL)(LPCWSTR)szPath;
pDataObject->SetData(&mfe, &msm, FALSE);
//
// See if a sheet is already up for this object.
//
if (IsSheetAlreadyUp(pDataObject))
{
return S_OK;
}
//
// Initialize and create the pages. Create an instance of the
// CDsPropertyPages object for each sheet because each sheet runs on its
// own thread.
//
IShellExtInit * pShlInit;
hr = CoCreateInstance(CLSID_DsPropertyPages, NULL, CLSCTX_INPROC_SERVER,
IID_IShellExtInit, (void **)&pShlInit);
if (FAILED(hr))
{
TRACE(TEXT("CoCreateInstance on CLSID_DsPropertyPages failed, hr: 0x%x\n"), hr);
return hr;
}
//
// Initialize the sheet with the data object
//
hr = pShlInit->Initialize(NULL, pDataObject, 0);
if (FAILED(hr))
{
TRACE(TEXT("pShlInit->Initialize failed, hr: 0x%x\n"), hr);
pShlInit->Release();
return hr;
}
IShellPropSheetExt * pSPSE;
hr = pShlInit->QueryInterface(IID_IShellPropSheetExt, (void **)&pSPSE);
pShlInit->Release();
if (FAILED(hr))
{
TRACE(TEXT("pShlInit->QI for IID_IShellPropSheetExt failed, hr: 0x%x\n"), hr);
return hr;
}
//
// Add pages to the sheet
//
hr = pSPSE->AddPages(AddPageProc, (LPARAM)pCall);
if (FAILED(hr))
{
TRACE(TEXT("pSPSE->AddPages failed, hr: 0x%x\n"), hr);
pSPSE->Release();
return hr;
}
pSPSE->Release();
}
// REVIEW_MARCOC_PORT: need to clean up and leave the locking/unlocking
// working for non DS property pages
//_SheetLockCookie(pUINode);
return hr;
}
//+----------------------------------------------------------------------------
//
// Member: CDSComponentData::IExtendPropertySheet::QueryPagesFor
//
// Synopsis: Called before a context menu is posted. If we support a
// property sheet for this object, then return S_OK.
//
//-----------------------------------------------------------------------------
STDMETHODIMP CDSComponentData::QueryPagesFor(LPDATAOBJECT pDataObject)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
TRACE(TEXT("CDSComponentData::QueryPagesFor().\n"));
BOOL bHasPages = FALSE;
//
// Look at the data object and see if it an item in the scope pane.
//
CInternalFormatCracker dobjCracker;
HRESULT hr = dobjCracker.Extract(pDataObject);
if (FAILED(hr) || !dobjCracker.HasData())
{
//
// not internal format, not ours
//
return S_FALSE;
}
//
// this is the MMC snapin wizard, we do not have one
//
if (dobjCracker.GetType() == CCT_SNAPIN_MANAGER)
{
return S_FALSE;
}
if (dobjCracker.GetCookieCount() > 1) // multiple selection
{
bHasPages = TRUE;
}
else // single selection
{
CUINode* pUINode = dobjCracker.GetCookie();
if (pUINode == NULL)
{
return S_FALSE;
}
bHasPages = pUINode->HasPropertyPages(pDataObject);
}
return (bHasPages) ? S_OK : S_FALSE;
}
//+----------------------------------------------------------------------------
//
// Member: CDSComponentData::IComponentData::CompareObjects
//
// Synopsis: If the data objects belong to the same DS object, then return
// S_OK.
//
//-----------------------------------------------------------------------------
class CCompareCookieByDN
{
public:
CCompareCookieByDN(LPCWSTR lpszDN) { m_lpszDN = lpszDN;}
bool operator()(CDSUINode* pUINode)
{
CDSCookie* pCookie = GetDSCookieFromUINode(pUINode);
if (pCookie == NULL)
{
return FALSE;
}
return (_wcsicmp(m_lpszDN, pCookie->GetPath()) == 0);
}
private:
LPCWSTR m_lpszDN;
};
STDMETHODIMP CDSComponentData::CompareObjects(LPDATAOBJECT pDataObject1,
LPDATAOBJECT pDataObject2)
{
TRACE(TEXT("CDSComponentData::CompareObjects().\n"));
CInternalFormatCracker dobjCracker1;
CInternalFormatCracker dobjCracker2;
if (FAILED(dobjCracker1.Extract(pDataObject1)) ||
FAILED(dobjCracker2.Extract(pDataObject2)))
{
return S_FALSE; // could not get internal format
}
CUINode* pUINode1 = dobjCracker1.GetCookie();
CUINode* pUINode2 = dobjCracker2.GetCookie();
//
// must have valid nodes
//
if ( (pUINode1 == NULL) || (pUINode2 == NULL) )
{
return S_FALSE;
}
if (dobjCracker1.GetCookieCount() == 1 &&
dobjCracker2.GetCookieCount() == 1 &&
pUINode1 == pUINode2)
{
//
// same pointer, they are the same (either both from real nodes
// or both from secondary pages)
//
return S_OK;
}
//
// if they are not the same, we compare them by DN, because we
// support only property pages on DS objects
//
CObjectNamesFormatCracker objectNamesFormatCracker1;
CObjectNamesFormatCracker objectNamesFormatCracker2;
if ( (FAILED(objectNamesFormatCracker1.Extract(pDataObject1))) ||
(FAILED(objectNamesFormatCracker2.Extract(pDataObject2))) )
{
// one or both not a DS object: we assume they are different
return S_FALSE;
}
if ( (objectNamesFormatCracker1.GetCount() != 1) ||
(objectNamesFormatCracker2.GetCount() != 1) )
{
//
// We are allowing as many multiple selection pages up as the user wants
//
return S_FALSE;
}
TRACE(L"CDSComponentData::CompareObjects(%s, %s)\n", objectNamesFormatCracker1.GetName(0),
objectNamesFormatCracker2.GetName(0));
return (_wcsicmp(objectNamesFormatCracker1.GetName(0),
objectNamesFormatCracker2.GetName(0)) == 0) ? S_OK : S_FALSE;
}
///////////////////////////////////////////////////////////////////////////////
// IExtendContextMenu implementation
//
STDMETHODIMP CDSComponentData::AddMenuItems(LPDATAOBJECT pDataObject,
LPCONTEXTMENUCALLBACK pContextMenuCallback,
long *pInsertionAllowed)
{
HRESULT hr = S_OK;
TRACE(_T("CDSComponentData::AddMenuItems()\n"));
AFX_MANAGE_STATE(AfxGetStaticModuleState());
DATA_OBJECT_TYPES dotType;
CUINode* pUINode = NULL;
CUIFolderInfo* pFolderInfo = NULL;
CInternalFormatCracker dobjCracker;
hr = dobjCracker.Extract(pDataObject);
if (FAILED(hr))
{
ASSERT (FALSE); // Invalid Data Object
return E_UNEXPECTED;
}
dotType = dobjCracker.GetType();
pUINode = dobjCracker.GetCookie();
if (pUINode==NULL || dotType==0)
{
ASSERT(FALSE); // Invalid args
return E_UNEXPECTED;
}
//
// Retrieve context menu verb handler form node
//
CContextMenuVerbs* pMenuVerbs = pUINode->GetContextMenuVerbsObject(this);
if (pMenuVerbs == NULL)
{
ASSERT(FALSE);
return E_UNEXPECTED;
}
if (pUINode->IsContainer())
{
pFolderInfo = pUINode->GetFolderInfo();
ASSERT(pFolderInfo != NULL);
pFolderInfo->UpdateSerialNumber(this);
}
//
// Use the IContextMenuCallback2 interface so that we can use
// language independent IDs on the menu items.
//
CComPtr<IContextMenuCallback2> spMenuCallback2;
hr = pContextMenuCallback->QueryInterface(IID_IContextMenuCallback2, (PVOID*)&spMenuCallback2);
if (FAILED(hr))
{
ASSERT(FALSE && L"Failed to QI for the IContextMenuCallback2 interface.");
return E_UNEXPECTED;
}
if (*pInsertionAllowed & CCM_INSERTIONALLOWED_NEW)
{
//
// Load New Menu
//
hr = pMenuVerbs->LoadNewMenu(spMenuCallback2,
m_pShlInit,
pDataObject,
pUINode,
pInsertionAllowed);
ASSERT(SUCCEEDED(hr));
}
if ( *pInsertionAllowed & CCM_INSERTIONALLOWED_TOP )
{
//
// Load Top Menu
//
hr = pMenuVerbs->LoadTopMenu(spMenuCallback2, pUINode);
ASSERT(SUCCEEDED(hr));
}
if (*pInsertionAllowed & CCM_INSERTIONALLOWED_TASK)
{
//
// Load Task Menu
//
hr = pMenuVerbs->LoadTaskMenu(spMenuCallback2, pUINode);
ASSERT(SUCCEEDED(hr));
}
if (*pInsertionAllowed & CCM_INSERTIONALLOWED_VIEW)
{
//
// Load View Menu
//
hr = pMenuVerbs->LoadViewMenu(spMenuCallback2, pUINode);
ASSERT(SUCCEEDED(hr));
}
return hr;
}
STDMETHODIMP CDSComponentData::Command(long nCommandID, LPDATAOBJECT pDataObject)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
if (nCommandID >= IDM_NEW_OBJECT_BASE)
{
// creation of a new DS object
return _CommandNewDSObject(nCommandID, pDataObject);
}
if ((nCommandID >= MENU_MERGE_BASE) && (nCommandID <= MENU_MERGE_LIMIT))
{
// range of menu ID's coming from shell extensions
return _CommandShellExtension(nCommandID, pDataObject);
}
HRESULT hr = S_OK;
CInternalFormatCracker dobjCracker;
hr = dobjCracker.Extract(pDataObject);
if (FAILED(hr))
{
ASSERT (FALSE); // Invalid Data Object
return hr;
}
DATA_OBJECT_TYPES dotType = dobjCracker.GetType();
CUINode* pUINode = dobjCracker.GetCookie();
if (pUINode == NULL || dotType == 0)
{
ASSERT(FALSE); // Invalid args
return E_FAIL;
}
if (IS_CLASS(*pUINode, CDSUINode))
{
CDSCookie* pCookie = GetDSCookieFromUINode(pUINode);
// menu ID's from standard DSA hard coded values
switch (nCommandID)
{
case IDM_DS_OBJECT_FIND:
{
LPCWSTR lpszPath = NULL;
if (pCookie == NULL)
{
lpszPath = m_RootNode.GetPath();
}
else
{
lpszPath = pCookie->GetPath();
}
m_ActiveDS->DSFind(m_hwnd, lpszPath);
}
break;
case IDM_GEN_TASK_MOVE:
{
CDSUINode* pDSUINode = dynamic_cast<CDSUINode*>(pUINode);
ASSERT(pDSUINode != NULL);
_MoveObject(pDSUINode);
m_pFrame->UpdateAllViews (NULL, NULL, DS_UPDATE_OBJECT_COUNT);
}
break;
case IDM_VIEW_COMPUTER_HACK:
if (CanRefreshAll())
{
Lock();
m_pQueryFilter->ToggleExpandComputers();
Unlock();
BOOL fDoRefresh = m_pClassCache->ToggleExpandSpecialClasses(m_pQueryFilter->ExpandComputers());
m_bDirty = TRUE;
if (fDoRefresh)
{
RefreshAll();
}
}
break;
case IDM_GEN_TASK_SELECT_DOMAIN:
case IDM_GEN_TASK_SELECT_FOREST:
if (CanRefreshAll())
{
GetDomain();
}
break;
case IDM_GEN_TASK_SELECT_DC:
if (CanRefreshAll())
{
GetDC();
}
break;
#ifdef FIXUPDC
case IDM_GEN_TASK_FIXUP_DC:
#endif // FIXUPDC
case IDM_GEN_TASK_RUN_KCC:
{
ASSERT(pCookie != NULL);
//
// Pass the LDAP path of the parent cookie to _FixupDC or _RunKCC.
// The current cookie is a nTDSDSA object,
// and the parent cookie must be a server object
//
CUINode* pParentUINode = pUINode->GetParent();
ASSERT(pParentUINode != NULL);
CDSCookie *pParentCookie = GetDSCookieFromUINode(pParentUINode);
ASSERT(pParentCookie != NULL);
CString strServerPath = pParentCookie->GetPath();
CString strPath = GetBasePathsInfo()->GetProviderAndServerName();
strPath += strServerPath;
#ifdef FIXUPDC
switch (nCommandID)
{
case IDM_GEN_TASK_FIXUP_DC:
_FixupDC(strPath);
break;
case IDM_GEN_TASK_RUN_KCC:
#endif // FIXUPDC
_RunKCC(strPath);
#ifdef FIXUPDC
break;
default:
ASSERT(FALSE);
break;
}
#endif // FIXUPDC
}
break;
case IDM_GEN_TASK_EDIT_FSMO:
{
EditFSMO();
}
break;
case IDM_GEN_TASK_RAISE_VERSION:
RaiseVersion();
break;
case IDM_VIEW_ADVANCED:
{
if (CanRefreshAll())
{
ASSERT( SNAPINTYPE_SITE != QuerySnapinType() );
m_pQueryFilter->ToggleAdvancedView();
m_bDirty = TRUE;
RefreshAll();
}
}
break;
case IDM_VIEW_SERVICES_NODE:
{
if (CanRefreshAll())
{
ASSERT( SNAPINTYPE_SITE == QuerySnapinType() );
m_pQueryFilter->ToggleViewServicesNode();
m_bDirty = TRUE;
if (m_RootNode.GetFolderInfo()->IsExpanded())
{
Refresh(&m_RootNode, FALSE /*bFlushCache*/ );
}
}
}
break;
case IDM_VIEW_FILTER_OPTIONS:
{
if (CanRefreshAll())
{
ASSERT(m_bRunAsPrimarySnapin);
if (m_pQueryFilter->EditFilteringOptions())
{
m_bDirty = TRUE;
RefreshAll();
}
}
}
break;
} // switch
}
else // Other node types
{
pUINode->OnCommand(nCommandID, this);
}
return S_OK;
}
HRESULT CDSComponentData::_CommandNewDSObject(long nCommandID,
LPDATAOBJECT pDataObject)
{
ASSERT(nCommandID >= IDM_NEW_OBJECT_BASE);
UINT objIndex = nCommandID - IDM_NEW_OBJECT_BASE;
if (pDataObject == NULL)
return E_INVALIDARG;
CInternalFormatCracker internalFormat;
HRESULT hr = internalFormat.Extract(pDataObject);
if (FAILED(hr))
{
return hr;
}
if (!internalFormat.HasData() || (internalFormat.GetCookieCount() != 1))
{
return E_INVALIDARG;
}
CUINode* pContainerUINode = internalFormat.GetCookie();
ASSERT(pContainerUINode != NULL);
// can do this for DS objects only
CDSUINode* pContainerDSUINode = dynamic_cast<CDSUINode*>(pContainerUINode);
if (pContainerDSUINode == NULL)
{
ASSERT(FALSE); // should never happen
return E_INVALIDARG;
}
CDSUINode* pNewDSUINode = NULL;
// pNewCookie is filled in if it is a leaf, then we call UpdateAllViews
hr = _CreateDSObject(pContainerDSUINode, pContainerDSUINode->GetCookie()->GetChildListEntry(objIndex), NULL, &pNewDSUINode);
if (SUCCEEDED(hr) && (hr != S_FALSE) && (pNewDSUINode != NULL))
{
m_pFrame->UpdateAllViews(pDataObject, (LPARAM)pNewDSUINode, DS_CREATE_OCCURRED);
m_pFrame->UpdateAllViews(pDataObject, (LPARAM)pContainerDSUINode, DS_UNSELECT_OBJECT);
}
m_pFrame->UpdateAllViews (NULL, NULL, DS_UPDATE_OBJECT_COUNT);
return S_OK;
}
HRESULT CDSComponentData::_CommandShellExtension(long nCommandID,
LPDATAOBJECT pDataObject)
{
CComPtr<IContextMenu> spICM;
HRESULT hr = m_pShlInit->QueryInterface(IID_IContextMenu, (void **)&spICM);
if (FAILED(hr))
{
ASSERT(FALSE);
return hr;
}
// just call the shell extension
HWND hwnd;
CMINVOKECOMMANDINFO cmiCommand;
hr = m_pFrame->GetMainWindow (&hwnd);
ASSERT (hr == S_OK);
cmiCommand.hwnd = hwnd;
cmiCommand.cbSize = sizeof (CMINVOKECOMMANDINFO);
cmiCommand.fMask = SEE_MASK_ASYNCOK;
cmiCommand.lpVerb = MAKEINTRESOURCEA(nCommandID - MENU_MERGE_BASE);
spICM->InvokeCommand(&cmiCommand);
// get the internal clibard format to see if it was one of our objects
// from the DS context emnu extension
CInternalFormatCracker internalFormat;
hr = internalFormat.Extract(pDataObject);
if (FAILED(hr))
{
return hr;
}
if (!internalFormat.HasData() || (internalFormat.GetCookieCount() != 1))
{
return E_INVALIDARG;
}
CUINode* pUINode = internalFormat.GetCookie();
ASSERT(pUINode != NULL);
if (pUINode->GetExtOp() & OPCODE_MOVE)
{
// REVIEW_MARCOC_PORT: need to generalize this for all folder types
CDSUINode* pDSUINode = dynamic_cast<CDSUINode*>(pUINode);
ASSERT(pDSUINode != NULL);
if (pDSUINode != NULL)
{
CUINode* pNewParentNode = MoveObjectInUI(pDSUINode);
if (pNewParentNode && pNewParentNode->GetFolderInfo()->IsExpanded())
{
Refresh(pNewParentNode);
}
}
}
return hr;
}
/////////////////////////////////////////////////////////////////////////////
// CDSComponentData::ISnapinHelp2 members
STDMETHODIMP
CDSComponentData::GetHelpTopic(LPOLESTR* lpCompiledHelpFile)
{
if (lpCompiledHelpFile == NULL)
return E_INVALIDARG;
if (m_lpszSnapinHelpFile == NULL)
{
*lpCompiledHelpFile = NULL;
return E_NOTIMPL;
}
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 += m_lpszSnapinHelpFile;
UINT nBytes = (szHelpFilePath.GetLength()+1) * sizeof(WCHAR);
*lpCompiledHelpFile = (LPOLESTR)::CoTaskMemAlloc(nBytes);
if (*lpCompiledHelpFile != NULL)
{
memcpy(*lpCompiledHelpFile, (LPCWSTR)szHelpFilePath, nBytes);
}
return S_OK;
}
STDMETHODIMP
CDSComponentData::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 += DSADMIN_LINKED_HELP_FILE;
UINT nBytes = (szHelpFilePath.GetLength()+1) * sizeof(WCHAR);
*lpCompiledHelpFile = (LPOLESTR)::CoTaskMemAlloc(nBytes);
if (*lpCompiledHelpFile != NULL)
{
memcpy(*lpCompiledHelpFile, (LPCWSTR)szHelpFilePath, nBytes);
}
return S_OK;
}
#ifdef _MMC_ISNAPIN_PROPERTY
/////////////////////////////////////////////////////////////////////////////
// CDSComponentData::ISnapinProperties members
// struct defining each entry
struct CSnapinPropertyEntry
{
LPCWSTR lpszName;
DWORD dwFlags;
};
// actual table
static const CSnapinPropertyEntry g_snapinPropertyArray[] =
{
{ g_szServer, MMC_PROP_CHANGEAFFECTSUI|MMC_PROP_MODIFIABLE|MMC_PROP_PERSIST},
{ g_szDomain, MMC_PROP_CHANGEAFFECTSUI|MMC_PROP_MODIFIABLE|MMC_PROP_PERSIST},
{ g_szRDN, MMC_PROP_CHANGEAFFECTSUI|MMC_PROP_MODIFIABLE|MMC_PROP_PERSIST},
{ NULL, 0x0} // end of table marker
};
STDMETHODIMP CDSComponentData::Initialize(
Properties* pProperties) /* I:my snap-in's properties */
{
TRACE(L"CDSComponentData::ISnapinProperties::Initialize()\n");
if (pProperties == NULL)
{
return E_INVALIDARG;
}
ASSERT(m_pProperties == NULL); // assume called only once
// save the interface pointer,
// it will be released during IComponentData::Destroy()
m_pProperties = pProperties;
m_pProperties->AddRef();
return S_OK;
}
STDMETHODIMP CDSComponentData::QueryPropertyNames(
ISnapinPropertiesCallback* pCallback) /* I:interface to add prop names*/
{
TRACE(L"CDSComponentData::QueryPropertyNames()\n");
HRESULT hr = S_OK;
// just loop through the table and add the entries
for (int k= 0; g_snapinPropertyArray[k].lpszName != NULL; k++)
{
hr = pCallback->AddPropertyName(g_snapinPropertyArray[k].lpszName,
NULL,
g_snapinPropertyArray[k].dwFlags);
if (FAILED(hr))
{
break;
}
}
return hr;
}
/*+-------------------------------------------------------------------------*
* CDSComponentData::PropertiesChanged
*
* This method is called when the snap-in's property set has changed.
*
* Returns:
* S_OK change was successful
* S_FALSE change was ignored
* E_INVALIDARG a changed property was invalid (e.g. a malformed
* computer name)
* E_FAIL a changed property was valid, but couldn't be used
* (e.g. a valid name for a computer that couldn't be
* located)
*--------------------------------------------------------------------------*/
STDMETHODIMP CDSComponentData::PropertiesChanged(
long cChangedProps, /* I:changed property count */
MMC_SNAPIN_PROPERTY* pChangedProps) /* I:changed properties */
{
TRACE(L"CDSComponentData::PropertiesChanged()\n");
// for the time being we do not allow any property change,
// we accept only initialization, so make a quick change and bail out
// if things are not such
for (long k=0; k< cChangedProps; k++)
{
if (pChangedProps[k].eAction != MMC_PROPACT_INITIALIZING)
{
return S_FALSE; // change ignored
}
if (pChangedProps[k].varValue.vt != VT_BSTR)
{
// something is wrong, refuse
return E_INVALIDARG;
}
}
// delegate to the targeting info object
HRESULT hr = m_targetingInfo.InitFromSnapinProperties(cChangedProps, pChangedProps);
// need to add here the properties for advanced view and alike
return hr;
}
#endif //_MMC_ISNAPIN_PROPERTY
/////////////////////////////////////////////////////////////////////////////
// internal helpers
HRESULT CDSComponentData::_InitRootFromBasePathsInfo(MyBasePathsInfo* pBasePathsInfo)
{
// we assume the MyBasePathsInfo we get is valid,
// we just swap info around and rebuild the related
// data structures
GetBasePathsInfo()->InitFromInfo(pBasePathsInfo);
m_InitSuccess = TRUE;
TRACE(_T("in _InitRootFromBasePathsInfo, set m_InitSuccess to true\n"));
return _InitRootFromValidBasePathsInfo();
}
HRESULT CDSComponentData::_InitRootFromCurrentTargetInfo()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
CWaitCursor wait;
HRESULT hr = S_OK;
//
// This function may be called twice if we are loading from a file,
// so don't try to initialize a second time
//
if (m_InitAttempted)
{
return S_OK;
}
BOOL bLocalLogin;
bLocalLogin = IsLocalLogin();
//if user logged in locally and noting given on
//command line
LPCWSTR lpszServerOrDomain = m_targetingInfo.GetTargetString();
BOOL bNoTarget = ( (lpszServerOrDomain == NULL) ||
(lpszServerOrDomain[0] == NULL) );
if( bNoTarget && bLocalLogin && (SNAPINTYPE_SITE != QuerySnapinType()))
{
TRACE(_T("LoggedIn as Local User and No Command Line arguments\n"));
CString szMsg;
szMsg.LoadString(IDS_LOCAL_LOGIN_ERROR);
CComPtr<IDisplayHelp> spIDisplayHelp;
hr = m_pFrame->QueryInterface (IID_IDisplayHelp,
(void **)&spIDisplayHelp);
CMoreInfoMessageBox dlg(m_hwnd, spIDisplayHelp , FALSE);
dlg.SetMessage(szMsg);
dlg.SetURL(DSADMIN_MOREINFO_LOCAL_LOGIN_ERROR);
dlg.DoModal();
m_InitSuccess = FALSE;
TRACE(_T("in _InitRootFromCurrentTargetInfo, set m_InitSuccess to false\n"));
}
else
{
// initialize base paths
hr = GetBasePathsInfo()->InitFromName(lpszServerOrDomain);
//
// JonN 5/4/00
// 55400: SITEREPL: Should default to local DC regardless of credentials
// If the local machine is in the target forest, we target the domain
// containing the local machine.
//
do // false loop
{
// We cannot follow this procedudure if we couldn't bind initially
if (FAILED(hr)) break;
// Skip this if the user specified a target
if (!bNoTarget) break;
// only do this for SITEREPL
if (SNAPINTYPE_SITE != QuerySnapinType()) break;
// Check whether the user is logged onto the local domain.
CString strComputer; // empty string
CString strLocalDomain;
HRESULT hr2 = GetDnsNameOfDomainOrForest(
strComputer, strLocalDomain, FALSE, TRUE );
if (FAILED(hr2) || strLocalDomain.IsEmpty()) break;
CString strTargetDomain = GetBasePathsInfo()->GetDomainName();
if (strTargetDomain.IsEmpty()) break;
if (!strLocalDomain.CompareNoCase(strTargetDomain)) break;
// The user is not logged onto the local domain.
// We need to determine whether the user is logged onto
// the same forest as the local forest.
CString strLocalForest;
hr2 = GetDnsNameOfDomainOrForest(
strComputer, strLocalForest, FALSE, FALSE );
if (FAILED(hr2) || strLocalForest.IsEmpty()) break;
CString strTargetForest;
strComputer = GetBasePathsInfo()->GetServerName();
hr2 = GetDnsNameOfDomainOrForest(
strComputer, strTargetForest, FALSE, FALSE );
if (FAILED(hr2) || strTargetForest.IsEmpty()) break;
if (strLocalForest.CompareNoCase(strTargetForest)) break;
// The user is logged on to a different domain than the local
// domain, but one in the same forest. There are probably closer DCs
// than the one just located, so use them instead.
// start using hr again here rather than hr2
TRACE(_T("_InitRootFromCurrentTargetInfo() rebinding\n"));
hr = GetBasePathsInfo()->InitFromName(strLocalDomain);
if (FAILED(hr))
{
// try to fall back to initial focus
TRACE(_T("_InitRootFromCurrentTargetInfo() reverting\n"));
hr = GetBasePathsInfo()->InitFromName(lpszServerOrDomain);
}
} while (false); // false loop
// NOTICE: if we fail, we out out the error message, and
// we keep a flag to avoid query expansions, but
// we continue, because we have to keep consistency in all
// the data structures (class cache, filter, etc.)
if (FAILED(hr))
{
TRACE(_T("_InitRootFromCurrentTargetInfo() failed\n"));
ReportErrorEx (m_hwnd, IDS_CANT_GET_ROOTDSE,hr,
MB_OK | MB_ICONERROR, NULL, 0);
m_InitSuccess = FALSE;
TRACE(_T("in _InitRootFromCurrentTargetInfo(), set m_InitSuccess to false\n"));
}
else
{
m_InitSuccess = TRUE;
TRACE(_T("in _InitRootFromCurrentTargetInfo(), set m_InitSuccess to true\n"));
}
}
_InitRootFromValidBasePathsInfo();
m_InitAttempted = TRUE;
return hr;
}
HRESULT CDSComponentData::_InitRootFromValidBasePathsInfo()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = S_OK;
// now set the root node strings. This will be reset below
// with the DNS name of the domain if everything succeeds
CString str;
str.LoadString( ResourceIDForSnapinType[ QuerySnapinType() ] );
m_RootNode.SetName(str);
// rebuild the display spec options struct for Data Objects
hr = BuildDsDisplaySpecOptionsStruct();
if (FAILED(hr))
return hr;
// reset the notification handler
GetNotifyHandlerManager()->Init();
// reset the query filter (already initialized in IComponentData::Initialize())
hr = m_pQueryFilter->Bind();
if (FAILED(hr))
return hr;
CString szServerName = GetBasePathsInfo()->GetServerName();
if (!szServerName.IsEmpty())
{
str += L" [";
str += szServerName;
str += L"]";
}
m_RootNode.SetName(str);
if (QuerySnapinType() == SNAPINTYPE_SITE)
{
//fix the default root path
str = GetBasePathsInfo()->GetConfigNamingContext();
}
else
{
LPCWSTR lpszRootRDN = m_targetingInfo.GetRootRDN();
if ( (lpszRootRDN != NULL) && (lpszRootRDN[0] != NULL) )
{
// add RDN below default naming context
// REVIEW_MARCOC_PORT: need to make sure the RDN is valid
str = m_targetingInfo.GetRootRDN();
str += L",";
str += GetBasePathsInfo()->GetDefaultRootNamingContext();
}
else
{
// just use the default naming context
str = GetBasePathsInfo()->GetDefaultRootNamingContext();
}
}
m_RootNode.SetPath(str);
// update UI if we already have inserted the root (retargeting case)
HSCOPEITEM hScopeItemID = m_RootNode.GetFolderInfo()->GetScopeItem();
if (hScopeItemID != NULL)
{
SCOPEDATAITEM Item;
CString csRoot;
Item.ID = m_RootNode.GetFolderInfo()->GetScopeItem();
Item.mask = SDI_STR;
csRoot = m_RootNode.GetName();
Item.displayname = (LPWSTR)(LPCWSTR)csRoot;
m_pScope->SetItem(&Item);
m_RootNode.SetExtOp(m_InitSuccess ? 0 : OPCODE_ENUM_FAILED);
ChangeScopeItemIcon(&m_RootNode);
}
return hr;
}
void CDSComponentData::GetDomain()
{
CChooseDomainDlg DomainDlg;
// load current bind info
DomainDlg.m_csTargetDomain = GetBasePathsInfo()->GetDomainName();
DomainDlg.m_bSiteRepl = (SNAPINTYPE_SITE == QuerySnapinType());
DomainDlg.m_bSaveCurrent = m_targetingInfo.GetSaveCurrent();
//
// invoke the dialog
//
if (DomainDlg.DoModal() == IDOK)
{
CWaitCursor cwait;
// attempt to bind
MyBasePathsInfo tempBasePathsInfo;
HRESULT hr = tempBasePathsInfo.InitFromName(DomainDlg.m_csTargetDomain);
if (SUCCEEDED(hr))
{
hr = _InitRootFromBasePathsInfo(&tempBasePathsInfo);
if (SUCCEEDED(hr))
{
m_targetingInfo.SetSaveCurrent(DomainDlg.m_bSaveCurrent);
m_bDirty = TRUE;
ClearClassCacheAndRefreshRoot();
}
}
if (FAILED(hr))
{
ReportErrorEx(
m_hwnd,
(DomainDlg.m_bSiteRepl ? IDS_RETARGET_FOREST_FAILED : IDS_RETARGET_DOMAIN_FAILED),
hr, MB_OK | MB_ICONERROR, NULL, 0);
}
}
return;
}
void CDSComponentData::GetDC()
{
CChooseDCDlg DCdlg(CWnd::FromHandle(m_hwnd));
// load current bind info
DCdlg.m_bSiteRepl = (SNAPINTYPE_SITE == QuerySnapinType());
DCdlg.m_csTargetDomain = GetBasePathsInfo()->GetDomainName();
DCdlg.m_csTargetDomainController = GetBasePathsInfo()->GetServerName();
//
// invoke the dialog
//
if (DCdlg.DoModal() == IDOK)
{
CWaitCursor cwait;
CString csNewTarget;
csNewTarget = DCdlg.m_csTargetDomainController;
if (csNewTarget.IsEmpty())
csNewTarget = DCdlg.m_csTargetDomain;
// attempt to bind
MyBasePathsInfo tempBasePathsInfo;
HRESULT hr = tempBasePathsInfo.InitFromName(csNewTarget);
if (SUCCEEDED(hr))
{
hr = _InitRootFromBasePathsInfo(&tempBasePathsInfo);
if (SUCCEEDED(hr))
ClearClassCacheAndRefreshRoot();
}
if (FAILED(hr))
{
ReportErrorEx(
m_hwnd,
IDS_RETARGET_DC_FAILED,
hr, MB_OK | MB_ICONERROR, NULL, 0);
}
}
return;
}
void CDSComponentData::EditFSMO()
{
CComPtr<IDisplayHelp> spIDisplayHelp;
HRESULT hr = m_pFrame->QueryInterface (IID_IDisplayHelp,
(void **)&spIDisplayHelp);
ASSERT(spIDisplayHelp != NULL);
if (SUCCEEDED(hr))
{
HWND hWnd;
m_pFrame->GetMainWindow(&hWnd);
LPCWSTR lpszTODO = L"";
CFsmoPropertySheet sheet(GetBasePathsInfo(), hWnd, spIDisplayHelp, lpszTODO);
sheet.DoModal();
}
}
void CDSComponentData::RaiseVersion(void)
{
HWND hWnd;
m_pFrame->GetMainWindow(&hWnd);
CString strPath;
GetBasePathsInfo()->GetDefaultRootPath(strPath);
PCWSTR pwzDnsName = GetBasePathsInfo()->GetDomainName();
ASSERT(pwzDnsName);
DSPROP_DomainVersionDlg(strPath, pwzDnsName, hWnd);
}
HRESULT CDSComponentData::_OnPreload(HSCOPEITEM hRoot)
{
HRESULT hr = S_OK;
AFX_MANAGE_STATE(AfxGetStaticModuleState());
CString str;
str.LoadString( ResourceIDForSnapinType[ QuerySnapinType() ] );
m_RootNode.SetName(str);
if (GetBasePathsInfo()->IsInitialized())
{
CString szServerName = GetBasePathsInfo()->GetServerName();
if (!szServerName.IsEmpty())
{
str += L" [";
str += szServerName;
str += L"]";
}
m_RootNode.SetName(str);
}
SCOPEDATAITEM Item;
Item.ID = hRoot;
Item.mask = SDI_STR;
Item.displayname = (LPWSTR)(LPCWSTR)str;
hr = m_pScope->SetItem(&Item);
return hr;
}
HRESULT CDSComponentData::_OnExpand(CUINode* pNode, HSCOPEITEM hParent, MMC_NOTIFY_TYPE event)
{
HRESULT hr = S_OK;
if ((pNode == NULL) || (!pNode->IsContainer()) )
{
ASSERT(FALSE); // Invalid Arguments
return E_INVALIDARG;
}
BEGIN_PROFILING_BLOCK("CDSComponentData::_OnExpand");
CWaitCursor cwait;
if (pNode->GetFolderInfo()->IsExpanded())
{
END_PROFILING_BLOCK;
//
// Short circuit the expansion because the node is already expanded
//
return S_OK;
}
pNode->GetFolderInfo()->SetExpanded();
if (pNode == &m_RootNode)
{
// initialize the paths and targeting
_InitRootFromCurrentTargetInfo();
// add the root cookie to MMC
pNode->GetFolderInfo()->SetScopeItem(hParent);
SCOPEDATAITEM Item;
Item.ID = hParent;
Item.mask = SDI_STR;
Item.displayname = (LPWSTR)(LPCWSTR)(m_RootNode.GetName());
m_pScope->SetItem (&Item);
// also add the root for the saved queries, if present
if (m_pFavoritesNodesHolder != NULL)
{
// add the favorite queries subtree
_AddScopeItem(m_pFavoritesNodesHolder->GetFavoritesRoot(),
m_RootNode.GetFolderInfo()->GetScopeItem());
}
}
if (IS_CLASS(*pNode, CFavoritesNode))
{
// just add the favorites subfolders and query folders
CUINodeList* pNodeList = pNode->GetFolderInfo()->GetContainerList();
for (POSITION pos = pNodeList->GetHeadPosition(); pos != NULL; )
{
CUINode* pCurrChildNode = pNodeList->GetNext(pos);
_AddScopeItem(pCurrChildNode,
pNode->GetFolderInfo()->GetScopeItem());
}
END_PROFILING_BLOCK;
// return because we do not need to spawn any background
// thread query
return S_OK;
}
if (!_PostQueryToBackgroundThread(pNode))
{
END_PROFILING_BLOCK;
// no background thread query generated, we are done
return S_OK;
}
// need to spawn a query request
pNode->SetExtOp(OPCODE_EXPAND_IN_PROGRESS);
TIMER(_T("posting request to bg threads\n"));
if (MMCN_EXPANDSYNC == event)
{
// if sync expand, have to wait for the query to complete
MSG tempMSG;
TRACE(L"MMCN_EXPANDSYNC, before while()\n");
while(m_queryNodeTable.IsPresent(pNode))
{
if (::PeekMessage(&tempMSG,m_pHiddenWnd->m_hWnd,CHiddenWnd::s_ThreadStartNotificationMessage,
CHiddenWnd::s_ThreadDoneNotificationMessage,
PM_REMOVE))
{
DispatchMessage(&tempMSG);
}
} // while
TRACE(L"MMCN_EXPANDSYNC, after while()\n");
}
END_PROFILING_BLOCK;
return hr;
}
HRESULT CDSComponentData::_AddScopeItem(CUINode* pUINode, HSCOPEITEM hParent, BOOL bSetSelected)
{
if (pUINode==NULL)
{
ASSERT(FALSE); // Invalid Arguments
return E_INVALIDARG;
}
ASSERT(pUINode->IsContainer());
HRESULT hr=S_OK;
SCOPEDATAITEM tSDItem;
ZeroMemory(&tSDItem, sizeof(SCOPEDATAITEM));
tSDItem.mask = SDI_STR | SDI_IMAGE | SDI_OPENIMAGE | SDI_STATE | SDI_PARAM |SDI_CHILDREN | SDI_PARENT;
tSDItem.relativeID = hParent;
if (IS_CLASS(*pUINode, CSavedQueryNode))
{
tSDItem.cChildren = 0;
}
else
{
tSDItem.cChildren=1;
}
tSDItem.nState = 0;
// insert item into tree control
tSDItem.lParam = reinterpret_cast<LPARAM>(pUINode);
tSDItem.displayname=(LPWSTR)-1;
tSDItem.nOpenImage = GetImage(pUINode, TRUE);
tSDItem.nImage = GetImage(pUINode, FALSE);
hr = m_pScope->InsertItem(&tSDItem);
if (SUCCEEDED(hr) && tSDItem.ID != NULL)
{
pUINode->GetFolderInfo()->SetScopeItem(tSDItem.ID);
if (bSetSelected)
{
m_pFrame->SelectScopeItem(tSDItem.ID);
}
}
return hr;
}
HRESULT CDSComponentData::ChangeScopeItemIcon(CUINode* pUINode)
{
ASSERT(pUINode->IsContainer());
SCOPEDATAITEM tSDItem;
ZeroMemory(&tSDItem, sizeof(SCOPEDATAITEM));
tSDItem.mask = SDI_IMAGE | SDI_OPENIMAGE;
tSDItem.nOpenImage = GetImage(pUINode, TRUE);
tSDItem.nImage = GetImage(pUINode, FALSE);
tSDItem.ID = pUINode->GetFolderInfo()->GetScopeItem();
return m_pScope->SetItem(&tSDItem);
}
HRESULT CDSComponentData::_ChangeResultItemIcon(CUINode* pUINode)
{
ASSERT(!pUINode->IsContainer());
return m_pFrame->UpdateAllViews(NULL,(LPARAM)pUINode, DS_UPDATE_OCCURRED);
}
HRESULT CDSComponentData::ToggleDisabled(CDSUINode* pDSUINode, BOOL bDisable)
{
HRESULT hr = S_OK;
CDSCookie* pCookie = pDSUINode->GetCookie();
ASSERT(pCookie != NULL);
if (pCookie == NULL)
{
return E_INVALIDARG;
}
if (pCookie->IsDisabled() != bDisable)
{
// changed state
if (bDisable)
pCookie->SetDisabled();
else
pCookie->ReSetDisabled();
// now need to change icon
if (pDSUINode->IsContainer())
return ChangeScopeItemIcon(pDSUINode);
else
return _ChangeResultItemIcon(pDSUINode);
}
return hr;
}
HRESULT CDSComponentData::UpdateItem(CUINode* pNode)
{
if (pNode->IsContainer())
{
//
// this is a scope pane item
//
return _UpdateScopeItem(pNode);
}
else
{
//
// this is a result pane item
// tell the views to update
//
return m_pFrame->UpdateAllViews(NULL,(LPARAM)pNode, DS_UPDATE_OCCURRED);
}
}
HRESULT CDSComponentData::_UpdateScopeItem(CUINode* pNode)
{
ASSERT(pNode->IsContainer());
SCOPEDATAITEM tSDItem;
ZeroMemory(&tSDItem, sizeof(SCOPEDATAITEM));
tSDItem.mask = SDI_STR;
tSDItem.displayname = MMC_CALLBACK;
tSDItem.ID = pNode->GetFolderInfo()->GetScopeItem();
return m_pScope->SetItem(&tSDItem);
}
HRESULT CDSComponentData::AddClassIcon(IN LPCWSTR lpszClass, IN DWORD dwFlags, INOUT int* pnIndex)
{
Lock();
HRESULT hr = m_iconManager.AddClassIcon(lpszClass, GetBasePathsInfo(), dwFlags, pnIndex);
Unlock();
return hr;
}
HRESULT CDSComponentData::FillInIconStrip(IImageList* pImageList)
{
Lock();
HRESULT hr = m_iconManager.FillInIconStrip(pImageList);
Unlock();
return hr;
}
BOOL
CDSComponentData::IsNotHiddenClass (LPWSTR pwszClass, CDSCookie* pParentCookie)
{
BOOL bApproved = FALSE;
if (m_CreateInfo.IsEmpty())
{
return FALSE;
}
POSITION pos;
pos = m_CreateInfo.GetHeadPosition();
while (pos)
{
if (!m_CreateInfo.GetNext(pos).CompareNoCase(pwszClass))
{
bApproved = TRUE;
goto done;
}
else
{
if ( (!wcscmp (pwszClass, L"sitesContainer"))
|| (!wcscmp (pwszClass, L"site"))
|| (!wcscmp (pwszClass, L"siteLink"))
|| (!wcscmp (pwszClass, L"siteLinkBridge"))
|| (!wcscmp (pwszClass, L"licensingSiteSettings"))
|| (!wcscmp (pwszClass, L"nTDSSiteSettings"))
|| (!wcscmp (pwszClass, L"serversContainer"))
|| (!wcscmp (pwszClass, L"server"))
|| (!wcscmp (pwszClass, L"nTDSDSA"))
|| (!wcscmp (pwszClass, L"subnet"))
#ifdef FRS_CREATE
|| (!wcscmp (pwszClass, L"nTDSConnection"))
|| (!wcscmp (pwszClass, L"nTFRSSettings"))
|| (!wcscmp (pwszClass, L"nTFRSReplicaSet"))
|| (!wcscmp (pwszClass, L"nTFRSMember"))
|| (!wcscmp (pwszClass, L"nTFRSSubscriptions"))
|| (!wcscmp (pwszClass, L"nTFRSSubscriber"))
#endif // FRS_CREATE
)
{
bApproved = TRUE;
goto done;
}
#ifndef FRS_CREATE
else if ( !wcscmp(pwszClass, L"nTDSConnection"))
{
LPCWSTR pwszParentClass = (pParentCookie) ? pParentCookie->GetClass() : L"";
if ( NULL != pwszParentClass
&& wcscmp(pwszParentClass, L"nTFRSSettings")
&& wcscmp(pwszParentClass, L"nTFRSReplicaSet")
&& wcscmp(pwszParentClass, L"nTFRSMember")
)
{
bApproved = TRUE;
goto done;
}
}
#endif // !FRS_CREATE
}
}
done:
return bApproved;
}
HRESULT
CDSComponentData::FillInChildList(CDSCookie * pCookie)
{
HRESULT hr = S_OK;
LPWSTR pszClasses = L"allowedChildClassesEffective";
LONG uBound, lBound;
UINT index, index2 = 0;
UINT cChildCount = 0;
CString Path;
WCHAR **ppChildren = NULL;
VARIANT *pNames = NULL;
WCHAR *pNextFree;
CComVariant Var;
CComVariant VarProp;
CComVariant varHints;
CComPtr<IADsPropertyList> spDSObject;
GetBasePathsInfo()->ComposeADsIPath(Path, pCookie->GetPath());
hr = DSAdminOpenObject(Path,
IID_IADsPropertyList,
(void **)&spDSObject,
TRUE /*bServer*/);
if (FAILED(hr))
{
TRACE(_T("Bind to Container for IPropertyList failed: %lx.\n"), hr);
goto error;
}
else
{
CComPtr<IADs> spDSObject2;
hr = spDSObject->QueryInterface (IID_IADs, (void **)&spDSObject2);
if (FAILED(hr))
{
TRACE(_T("QI to Container for IADs failed: %lx.\n"), hr);
goto error;
}
ADsBuildVarArrayStr (&pszClasses, 1, &varHints);
spDSObject2->GetInfoEx(varHints, 0);
}
hr = spDSObject->GetPropertyItem (pszClasses,
ADSTYPE_CASE_IGNORE_STRING,
&VarProp);
if (!SUCCEEDED(hr))
{
TRACE(_T("GetPropertyTtem failed: %lx.\n"), hr);
goto error;
}
if (V_VT(&VarProp) == VT_EMPTY)
{
TRACE(_T("GetPropertyTtem return empty VARIANT: vtype is %lx.\n"), V_VT(&VarProp));
goto error;
}
{ // scope to allow goto's to compile
IDispatch * pDisp = NULL;
pDisp = V_DISPATCH(&VarProp);
CComPtr<IADsPropertyEntry> spPropEntry;
hr = pDisp->QueryInterface(IID_IADsPropertyEntry, (void **)&spPropEntry);
hr = spPropEntry->get_Values(&Var);
}
hr = SafeArrayGetUBound (V_ARRAY(&Var), 1, &uBound);
hr = SafeArrayGetLBound (V_ARRAY(&Var), 1, &lBound);
hr = SafeArrayAccessData(V_ARRAY(&Var),
(void **)&pNames);
if (FAILED(hr))
{
TRACE(_T("Accessing safearray data failed: %lx.\n"), hr);
goto error;
}
else
{
if (uBound >= 0)
{
cChildCount = (UINT) (uBound - lBound);
ppChildren = (WCHAR **) LocalAlloc (LPTR,
(cChildCount + 1) * STRING_LEN);
if (ppChildren != NULL)
{
pNextFree = (WCHAR*)(ppChildren + cChildCount + 1);
index2 = 0;
for (index = lBound; index <= (UINT)uBound; index++)
{
CComPtr<IADsPropertyValue> spEntry;
hr = (pNames[index].pdispVal)->QueryInterface (IID_IADsPropertyValue,
(void **)&spEntry);
if (SUCCEEDED(hr))
{
CComBSTR bsObject;
hr = spEntry->get_CaseIgnoreString (&bsObject);
TRACE(_T("----->allowed object number %d: %s\n"),
index, bsObject);
if (IsNotHiddenClass(bsObject, pCookie))
{
TRACE(_T("-----------approved.\n"));
ppChildren[index2] = pNextFree;
pNextFree += wcslen(bsObject)+ sizeof (WCHAR);
wcscpy (ppChildren[index2], bsObject);
index2 ++;
} // if
} // if
} // for
} // if
} // if uBound
#ifdef DBG
else
{
TRACE(_T("--- no classes returned, no creation allowed here.\n"));
}
#endif
VERIFY(SUCCEEDED(SafeArrayUnaccessData(V_ARRAY(&Var))));
}
error:
if (index2 != 0)
{
SortChildList (ppChildren, index2);
pCookie->SetChildList (ppChildren);
}
pCookie->SetChildCount (index2);
return hr;
}
// routine to sort the entries for the "Create New" menu
// simple-minded bubble sort; its a small list
BOOL CDSComponentData::SortChildList (LPWSTR *ppszChildList, UINT cChildCount)
{
LPWSTR Temp;
BOOL IsSorted = FALSE;
while (!IsSorted)
{
IsSorted = TRUE;
// TRACE(_T("At top of while. ready to go again.\n"));
for (UINT index = 0; index < cChildCount - 1; index++)
{
if (wcscmp (ppszChildList[index], ppszChildList[index + 1]) > 0)
{
Temp = ppszChildList[index];
ppszChildList[index] = ppszChildList[index + 1];
ppszChildList[index + 1] = Temp;
//TRACE(_T("Swapped %s and %ws. still not done.\n"),
// ppszChildList[index], ppszChildList[index + 1]);
IsSorted = FALSE;
}
}
}
return IsSorted;
}
/////////////////////////////////////////////////////////////////////
// CDSComponentData::_CreateDSObject()
//
// Create a new ADs object.
//
HRESULT CDSComponentData::_CreateDSObject(CDSUINode* pContainerDSUINode, // IN: container where to create object
LPCWSTR lpszObjectClass, // IN: class of the object to be created
IN CDSUINode* pCopyFromDSUINode, // IN: (optional) object to be copied
OUT CDSUINode** ppSUINodeNew) // OUT: OPTIONAL: Pointer to new node
{
CDSCookie* pNewCookie = NULL;
HRESULT hr = GetActiveDS()->CreateDSObject(pContainerDSUINode,
lpszObjectClass,
pCopyFromDSUINode,
&pNewCookie);
if (SUCCEEDED(hr) && (hr != S_FALSE) && (pNewCookie != NULL))
{
// make sure we update the icon cache
m_pFrame->UpdateAllViews(/*unused*/NULL /*pDataObj*/, /*unused*/(LPARAM)0, DS_ICON_STRIP_UPDATE);
// create a UI node to hold the cookie
*ppSUINodeNew = new CDSUINode(NULL);
(*ppSUINodeNew)->SetCookie(pNewCookie);
if (pNewCookie->IsContainerClass())
{
(*ppSUINodeNew)->MakeContainer();
}
// Add the new node to the link list
pContainerDSUINode->GetFolderInfo()->AddNode(*ppSUINodeNew);
if ((*ppSUINodeNew)->IsContainer())
{
//
// Add the scope item and select it
//
_AddScopeItem(*ppSUINodeNew, pContainerDSUINode->GetFolderInfo()->GetScopeItem(), TRUE);
*ppSUINodeNew = NULL;
}
}
return hr;
}
//
// return S_OK if can copy, S_FALSE if not, some hr error if failed
//
HRESULT CDSComponentData::_CanCopyDSObject(IDataObject* pCopyFromDsObject)
{
if (pCopyFromDsObject == NULL)
{
return E_INVALIDARG;
}
CInternalFormatCracker internalFormat;
HRESULT hr = internalFormat.Extract(pCopyFromDsObject);
if (FAILED(hr))
{
return hr;
}
if (!internalFormat.HasData() || (internalFormat.GetCookieCount() != 1))
{
return E_INVALIDARG;
}
//
// Get the node data
//
CUINode* pUINode = internalFormat.GetCookie();
CDSCookie* pCopyFromDsCookie = NULL;
if (IS_CLASS(*pUINode, CDSUINode))
{
pCopyFromDsCookie = GetDSCookieFromUINode(pUINode);
}
if (pCopyFromDsCookie == NULL)
{
return E_INVALIDARG;
}
//
// get the parent node data
//
CUINode* pParentUINode = pUINode->GetParent();
CDSCookie* pContainerDsCookie = NULL;
if (IS_CLASS(*pParentUINode, CDSUINode))
{
pContainerDsCookie = GetDSCookieFromUINode(pParentUINode);
}
if (pContainerDsCookie == NULL)
{
return E_INVALIDARG;
}
//
// get the class to be created
//
LPCWSTR lpszObjectClass = pCopyFromDsCookie->GetClass();
//
// try to find the class in the possible child classes of the container
//
WCHAR ** ppChildren = pContainerDsCookie->GetChildList();
if (ppChildren == NULL)
{
FillInChildList(pContainerDsCookie);
ppChildren = pContainerDsCookie->GetChildList();
}
//
// loop trough the class list to find a match
//
int cChildCount = pContainerDsCookie->GetChildCount();
for (int index = 0; index < cChildCount; index++)
{
if (wcscmp(pContainerDsCookie->GetChildListEntry(index), lpszObjectClass) == 0)
{
return S_OK; // got one, can create
}
}
return S_FALSE; // not found, cannot create
}
HRESULT CDSComponentData::_CopyDSObject(IDataObject* pCopyFromDsObject) // IN object to be copied
{
if (pCopyFromDsObject == NULL)
return E_INVALIDARG;
CInternalFormatCracker internalFormat;
HRESULT hr = internalFormat.Extract(pCopyFromDsObject);
if (FAILED(hr))
{
return hr;
}
if (!internalFormat.HasData() || (internalFormat.GetCookieCount() != 1))
{
return E_INVALIDARG;
}
CUINode* pCopyFromUINode = internalFormat.GetCookie();
ASSERT(pCopyFromUINode != NULL);
// can do this for DS objects only
CDSUINode* pCopyFromDSUINode = dynamic_cast<CDSUINode*>(pCopyFromUINode);
if (pCopyFromDSUINode == NULL)
{
ASSERT(FALSE); // should never happen
return E_INVALIDARG;
}
// get the parent cookie
CDSUINode* pContainerDSUINode = dynamic_cast<CDSUINode*>(pCopyFromDSUINode->GetParent());
if(pContainerDSUINode == NULL)
{
ASSERT(FALSE); // should never happen
return E_INVALIDARG;
}
// get the class to be created
LPCWSTR lpszObjectClass = pCopyFromDSUINode->GetCookie()->GetClass();
// call the object creation code
CDSUINode* pNewDSUINode = NULL;
hr = _CreateDSObject(pContainerDSUINode, lpszObjectClass, pCopyFromDSUINode, &pNewDSUINode);
// update if result pane item
// (if it were a scope item, _CreateDSObject() would update it
if (SUCCEEDED(hr) && (hr != S_FALSE) && (pNewDSUINode != NULL))
{
m_pFrame->UpdateAllViews(pCopyFromDsObject, (LPARAM)pNewDSUINode, DS_CREATE_OCCURRED_RESULT_PANE);
m_pFrame->UpdateAllViews(NULL, (LPARAM)pCopyFromDSUINode, DS_UNSELECT_OBJECT);
}
return S_OK;
}
HRESULT
CDSComponentData::_DeleteFromBackendAndUI(IDataObject* pDataObject, CDSUINode* pDSUINode)
{
HRESULT hr = S_OK;
ASSERT(pDSUINode != NULL);
ASSERT(pDSUINode->IsContainer());
// guard against property sheet open on this cookie
if (_WarningOnSheetsUp(pDSUINode))
return S_OK;
CWaitCursor cwait;
// this call will handle the notifications to extensions
CDSCookie* pCookie = GetDSCookieFromUINode(pDSUINode);
hr = _DeleteFromBackEnd(pDataObject, pCookie);
// if deletion happened, delete the scope item from the UI
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
hr = RemoveContainerFromUI(pDSUINode);
delete pDSUINode;
}
return S_OK;
}
HRESULT CDSComponentData::RemoveContainerFromUI(CUINode* pUINode)
{
HRESULT hr = S_OK;
ASSERT(pUINode->IsContainer());
HSCOPEITEM ItemID, ParentItemID;
ItemID = pUINode->GetFolderInfo()->GetScopeItem();
CUINode* pParentNode = NULL;
hr = m_pScope->GetParentItem(ItemID, &ParentItemID,
(MMC_COOKIE *)&pParentNode);
m_pScope->DeleteItem(ItemID, TRUE);
if (SUCCEEDED(hr))
{
ASSERT(pParentNode->IsContainer());
// delete memory
pParentNode->GetFolderInfo()->RemoveNode(pUINode);
}
m_pFrame->UpdateAllViews(NULL, NULL, DS_UPDATE_OBJECT_COUNT);
//
// Remove the '+' sign in the UI if this was the last container child in this container
//
if (pParentNode != NULL &&
ParentItemID != 0 &&
pParentNode->GetFolderInfo()->GetContainerList()->GetCount() == 0)
{
SCOPEDATAITEM sdi;
memset(&sdi, 0, sizeof(SCOPEDATAITEM));
sdi.ID = ParentItemID;
sdi.mask |= SDI_CHILDREN;
sdi.cChildren = 0;
hr = m_pScope->SetItem(&sdi);
}
return hr;
}
///////////////////////////////////////////////////////////////////////////
// CSnapinSingleDeleteHandler
class CSnapinSingleDeleteHandler : public CSingleDeleteHandlerBase
{
public:
CSnapinSingleDeleteHandler(CDSComponentData* pComponentData, HWND hwnd,
CDSCookie* pCookie)
: CSingleDeleteHandlerBase(pComponentData, hwnd)
{
m_pCookie = pCookie;
GetComponentData()->GetBasePathsInfo()->ComposeADsIPath(
m_strItemPath, m_pCookie->GetPath());
}
protected:
CDSCookie* m_pCookie;
CString m_strItemPath;
virtual HRESULT BeginTransaction()
{
return GetTransaction()->Begin(m_pCookie, NULL, NULL, FALSE);
}
virtual HRESULT DeleteObject()
{
return GetComponentData()->GetActiveDS()->DeleteObject(m_pCookie ,FALSE);
}
virtual HRESULT DeleteSubtree()
{
return GetComponentData()->_DeleteSubtreeFromBackEnd(m_pCookie);
}
virtual void GetItemName(OUT CString& szName){ szName = m_pCookie->GetName(); }
virtual LPCWSTR GetItemClass(){ return m_pCookie->GetClass(); }
virtual LPCWSTR GetItemPath(){ return m_strItemPath; }
};
/*
NOTICE: the function will return S_OK on success, S_FALSE if aborted
by user, some FAILED(hr) otherwise
*/
HRESULT CDSComponentData::_DeleteFromBackEnd(IDataObject*, CDSCookie* pCookie)
{
ASSERT(pCookie != NULL);
CSnapinSingleDeleteHandler deleteHandler(this, m_hwnd, pCookie);
return deleteHandler.Delete();
}
HRESULT
CDSComponentData::_DeleteSubtreeFromBackEnd(CDSCookie* pCookie)
{
HRESULT hr = S_OK;
CComPtr<IADsDeleteOps> spObj;
CString szPath;
GetBasePathsInfo()->ComposeADsIPath(szPath, pCookie->GetPath());
hr = DSAdminOpenObject(szPath,
IID_IADsDeleteOps,
(void **)&spObj,
TRUE /*bServer*/);
if (SUCCEEDED(hr))
{
hr = spObj->DeleteObject(NULL); //flag is reserved by ADSI
}
return hr;
}
HRESULT CDSComponentData::_Rename(CUINode* pUINode, LPWSTR NewName)
{
//
// Verify parameters
//
if (pUINode == NULL || NewName == NULL)
{
ASSERT(FALSE);
return E_INVALIDARG;
}
CWaitCursor cwait;
HRESULT hr = S_OK;
CDSCookie* pCookie = NULL;
CString szPath;
//
// guard against property sheet open on this cookie
//
if (_WarningOnSheetsUp(pUINode))
{
return E_FAIL;
}
if (pUINode->IsSheetLocked())
{
ReportErrorEx (m_hwnd,IDS_SHEETS_UP_RENAME,hr,
MB_OK | MB_ICONINFORMATION, NULL, 0);
return hr;
}
if (IS_CLASS(*pUINode, CDSUINode))
{
pCookie = GetDSCookieFromUINode(pUINode);
if (pCookie == NULL)
{
return E_FAIL;
}
CDSRenameObject* pRenameObject = NULL;
CString strClass = pCookie->GetClass();
CString szDN = pCookie->GetPath();
GetBasePathsInfo()->ComposeADsIPath(szPath, szDN);
//
// Rename user object
//
if (strClass == L"user"
#ifdef INETORGPERSON
|| strClass == L"inetOrgPerson"
#endif
)
{
//
// Rename user
//
pRenameObject = new CDSRenameUser(pUINode, pCookie, NewName, m_hwnd, this);
}
else if (strClass == L"group")
{
//
// Rename group
//
pRenameObject = new CDSRenameGroup(pUINode, pCookie, NewName, m_hwnd, this);
}
else if (strClass == L"contact")
{
//
// rename contact
//
pRenameObject = new CDSRenameContact(pUINode, pCookie, NewName, m_hwnd, this);
}
else if (strClass == L"site")
{
//
// Rename site
//
pRenameObject = new CDSRenameSite(pUINode, pCookie, NewName, m_hwnd, this);
}
else if (strClass == L"subnet")
{
//
// Rename subnet
//
pRenameObject = new CDSRenameSubnet(pUINode, pCookie, NewName, m_hwnd, this);
}
else if (strClass == L"nTDSConnection")
{
//
// Rename nTDSConnection
//
pRenameObject = new CDSRenameNTDSConnection(pUINode, pCookie, NewName, m_hwnd, this);
}
else
{
//
// Rename other object
//
pRenameObject = new CDSRenameObject(pUINode, pCookie, NewName, m_hwnd, this);
}
if (pRenameObject != NULL)
{
hr = pRenameObject->DoRename();
}
else
{
hr = E_FAIL;
}
}
else // !CDSUINode
{
hr = pUINode->Rename(NewName, this);
}
if (SUCCEEDED(hr) && !szPath.IsEmpty())
{
CStringList pathList;
pathList.AddTail(szPath);
InvalidateSavedQueriesContainingObjects(pathList);
}
return hr;
}
void CDSComponentData::ClearSubtreeHelperForRename(CUINode* pUINode)
{
//
// Verify parameters
//
if (pUINode == NULL)
{
ASSERT(FALSE);
return;
}
HSCOPEITEM ItemID;
CUIFolderInfo* pFolderInfo = NULL;
pFolderInfo = pUINode->GetFolderInfo();
if (pFolderInfo != NULL)
{
//
// remove the folder subtree in the UI
//
ItemID = pFolderInfo->GetScopeItem();
m_pScope->DeleteItem(ItemID, /* this node*/FALSE);
//
// clear list of children
//
pFolderInfo->DeleteAllLeafNodes();
pFolderInfo->DeleteAllContainerNodes();
//
// remove the descendants from the pending query table
//
m_queryNodeTable.RemoveDescendants(pUINode);
pFolderInfo->ReSetExpanded();
// make sure MMC knows the + sign should show
SCOPEDATAITEM scopeItem;
ZeroMemory(&scopeItem, sizeof(SCOPEDATAITEM));
scopeItem.ID = ItemID;
scopeItem.mask = SDI_CHILDREN;
scopeItem.cChildren = 1;
m_pScope->SetItem(&scopeItem);
}
}
CUINode* CDSComponentData::MoveObjectInUI(CDSUINode* pDSUINode)
{
CUINode* pParentUINode = pDSUINode->GetParent();
HSCOPEITEM ParentItemID = NULL;
HRESULT hr = S_OK;
ASSERT(pParentUINode != NULL && pParentUINode->IsContainer());
//
// find the new parent node
//
CUINode* pNewParentNode = NULL;
hr = FindParentCookie(pDSUINode->GetCookie()->GetPath(), &pNewParentNode);
if (pDSUINode->IsContainer())
{
HSCOPEITEM ItemID = pDSUINode->GetFolderInfo()->GetScopeItem();
hr = m_pScope->GetParentItem(ItemID, &ParentItemID, (MMC_COOKIE *)&pParentUINode);
//
// remove node from MMC
//
m_pScope->DeleteItem(ItemID, TRUE);
if (SUCCEEDED(hr))
{
//
// remove it from the list of children
//
pParentUINode->GetFolderInfo()->RemoveNode(pDSUINode);
}
if ((hr == S_OK) && pNewParentNode && pNewParentNode->GetFolderInfo()->IsExpanded())
{
//
// add to new child list
//
pDSUINode->ClearParent();
if (pNewParentNode != NULL)
{
pNewParentNode->GetFolderInfo()->AddNode(pDSUINode);
//
// add to MMC scope pane
//
_AddScopeItem(pDSUINode, pNewParentNode->GetFolderInfo()->GetScopeItem());
}
}
else
{
// will get it later on when enumerating
delete pDSUINode;
}
}
else // leaf node
{
if ((pNewParentNode) &&
(pNewParentNode->GetFolderInfo()->IsExpanded()))
{
pDSUINode->ClearParent();
pNewParentNode->GetFolderInfo()->AddNode(pDSUINode);
}
m_pFrame->UpdateAllViews(NULL, (LPARAM)pDSUINode, DS_MOVE_OCCURRED);
}
return pNewParentNode;
}
HRESULT CDSComponentData::_MoveObject(CDSUINode* pDSUINode)
{
// guard against property sheet open on this cookie
if (_WarningOnSheetsUp(pDSUINode))
return S_OK;
CWaitCursor cwait;
// call the backend to do the delete
HRESULT hr = m_ActiveDS->MoveObject(pDSUINode->GetCookie());
if (SUCCEEDED(hr) && (hr != S_FALSE))
{
// we actually moved the object, move in the folders and MMC
CUINode* pNewParentNode = MoveObjectInUI(pDSUINode);
if (pNewParentNode && pNewParentNode->GetFolderInfo()->IsExpanded())
{
Refresh(pNewParentNode);
}
}
return hr;
}
HRESULT CDSComponentData::Refresh(CUINode* pNode, BOOL bFlushCache, BOOL bFlushColumns)
{
HRESULT hr = S_OK;
TRACE(_T("CDSComponentData::Refresh: cookie is %s\n"),
pNode->GetName());
if (m_queryNodeTable.IsLocked(pNode))
{
// this might happen if MMC's verb management bent out of shape (BUG?)
// like in the case of the "*" (num keypad) command (expand the whole tree)
// just ignore the command
return S_OK;
}
if (_WarningOnSheetsUp(pNode))
return hr;
if ((pNode == &m_RootNode) && !m_InitSuccess)
{
hr = _InitRootFromCurrentTargetInfo();
if (FAILED(hr))
{
m_InitSuccess = FALSE;
TRACE(_T("in Refresh, set m_InitSuccess to false\n"));
return hr;
}
else
{
m_InitSuccess = TRUE;
TRACE(_T("in Refresh, set m_InitSuccess to true\n"));
}
}
// remove the folder subtree in the UI
HSCOPEITEM ItemID = NULL;
if (pNode->IsContainer())
{
ItemID = pNode->GetFolderInfo()->GetScopeItem();
}
if (ItemID == NULL)
{
// let's try the parent
CUINode* pParent = pNode->GetParent();
ASSERT(pParent != NULL);
ASSERT(pParent->IsContainer());
ItemID = pParent->GetFolderInfo()->GetScopeItem();
if (ItemID == NULL)
{
return S_OK;
}
else
{
pNode = pParent;
}
}
m_pScope->DeleteItem(ItemID, /* this node*/FALSE);
// delete result pane items in the UI
TIMER(_T("calling update all views..."));
m_pFrame->UpdateAllViews(NULL, (LPARAM)pNode, DS_REFRESH_REQUESTED);
// clear list of children
TIMER(_T("back from UpdateAllViews.\ncleaning up data structs..."));
if (pNode == &m_RootNode)
{
if (m_pFavoritesNodesHolder != NULL)
{
// do not remove the favorites, just detach them from tree
m_RootNode.GetFolderInfo()->RemoveNode(m_pFavoritesNodesHolder->GetFavoritesRoot());
m_pFavoritesNodesHolder->GetFavoritesRoot()->ClearParent();
m_pFavoritesNodesHolder->GetFavoritesRoot()->GetFolderInfo()->ReSetExpanded();
// clean up all the query folders, but otherwise leave the
// subtree intact
m_pFavoritesNodesHolder->GetFavoritesRoot()->RemoveQueryResults();
}
// remove the remaining folders
m_RootNode.GetFolderInfo()->DeleteAllLeafNodes();
m_RootNode.GetFolderInfo()->DeleteAllContainerNodes();
if (m_pFavoritesNodesHolder != NULL)
{
// re-attach the favorites underneath the root
m_RootNode.GetFolderInfo()->AddNode(m_pFavoritesNodesHolder->GetFavoritesRoot());
// add the favorite queries subtree
_AddScopeItem(m_pFavoritesNodesHolder->GetFavoritesRoot(),
m_RootNode.GetFolderInfo()->GetScopeItem());
}
}
else if (IS_CLASS(*pNode, CFavoritesNode))
{
// recurse down to other query folders to do cleanup
dynamic_cast<CFavoritesNode*>(pNode)->RemoveQueryResults();
// just add the favorites subfolders and query folders
CUINodeList* pNodeList = pNode->GetFolderInfo()->GetContainerList();
for (POSITION pos = pNodeList->GetHeadPosition(); pos != NULL; )
{
CUINode* pCurrChildNode = pNodeList->GetNext(pos);
_AddScopeItem(pCurrChildNode,
pNode->GetFolderInfo()->GetScopeItem());
}
}
else if (IS_CLASS(*pNode, CSavedQueryNode))
{
pNode->GetFolderInfo()->DeleteAllLeafNodes();
pNode->GetFolderInfo()->DeleteAllContainerNodes();
dynamic_cast<CSavedQueryNode*>(pNode)->SetValid(TRUE);
}
else
{
ASSERT(IS_CLASS(*pNode, CDSUINode) );
// standard DS container, just remove all sub objects
pNode->GetFolderInfo()->DeleteAllLeafNodes();
pNode->GetFolderInfo()->DeleteAllContainerNodes();
}
TIMER(_T("datastructs cleaned up\n"));
// remove the descendants from the pending query table
m_queryNodeTable.RemoveDescendants(pNode);
if ((pNode == &m_RootNode) && bFlushCache)
{
TRACE(L"CDSComponentData::Refresh: flushing the cache\n");
m_pClassCache->Initialize(QuerySnapinType(), GetBasePathsInfo(), bFlushColumns);
}
// post a query
TRACE(L"CDSComponentData::Refresh: posting query\n");
_PostQueryToBackgroundThread(pNode);
TRACE(L"CDSComponentData::Refresh: returning\n");
return hr;
}
#if (FALSE)
HRESULT CDSComponentData::_OnPropertyChange(LPDATAOBJECT pDataObject, BOOL bScope)
{
if (pDataObject == NULL)
{
return E_INVALIDARG;
}
CInternalFormatCracker dobjCracker;
VERIFY(SUCCEEDED(dobjCracker.Extract(pDataObject)));
CDSCookie* pCookie = NULL;
CUINode* pUINode = dobjCracker.GetCookie();
if (pUINode == NULL)
{
return E_INVALIDARG;
}
//
// Right now we are not supporting properties on other node types
//
if (IS_CLASS(*pUINode, CDSUINode))
{
pCookie = GetDSCookieFromUINode(pUINode);
}
if (pCookie == NULL)
{
// not a DS object
return S_OK;
}
{
//
// notify the extension that an object has changed
//
CDSNotifyHandlerTransaction transaction(this);
transaction.SetEventType(DSA_NOTIFY_PROP);
transaction.Begin(pDataObject, NULL, NULL, FALSE);
//
// we do not call Confirm() because this is an asynchrnous call after the fact
//
transaction.Notify(0);
transaction.End();
}
//
// update the data to be displayed
//
//
// update all the possible instances in the query namespace
//
if (m_pFavoritesNodesHolder != NULL)
{
// find the list of items to update
CUINodeList queryNamespaceNodeList;
m_pFavoritesNodesHolder->GetFavoritesRoot()->FindCookiesInQueries(pCookie->GetPath(), &queryNamespaceNodeList);
// update all of them
for (POSITION pos = queryNamespaceNodeList.GetHeadPosition(); pos != NULL; )
{
CUINode* pCurrUINode = queryNamespaceNodeList.GetNext(pos);
HRESULT hrCurr = UpdateFromDS(pCurrUINode);
if (SUCCEEDED(hrCurr))
{
UpdateItem(pCurrUINode);
}
}
}
//
// figure out if the notification cookie is in the query namespace or
// in the DS one
//
BOOL bNodeFromQueryNamespace = IS_CLASS(*(pUINode->GetParent()), CSavedQueryNode);
CUINode* pUINodeToUpdate = NULL;
if (bNodeFromQueryNamespace)
{
// find the item
FindCookieInSubtree(&m_RootNode, pCookie->GetPath(), QuerySnapinType(), &pUINodeToUpdate);
}
else
{
pUINodeToUpdate = pUINode;
}
if (pUINodeToUpdate != NULL)
{
HRESULT hr = UpdateFromDS(pUINodeToUpdate);
if (SUCCEEDED(hr))
{
return UpdateItem(pUINodeToUpdate);
}
}
return S_OK;
}
#endif
HRESULT CDSComponentData::_OnPropertyChange(LPDATAOBJECT pDataObject, BOOL)
{
if (pDataObject == NULL)
{
return E_INVALIDARG;
}
CInternalFormatCracker ifc;
if (FAILED(ifc.Extract(pDataObject)))
{
ASSERT(FALSE);
return E_INVALIDARG;
}
CUINode* pUINode = ifc.GetCookie();
if (pUINode != NULL)
{
if (!IS_CLASS(*pUINode, CDSUINode))
{
UpdateItem(pUINode);
return S_OK;
}
}
CObjectNamesFormatCracker objectNamesFormatCracker;
if (FAILED(objectNamesFormatCracker.Extract(pDataObject)))
{
ASSERT(FALSE);
return E_INVALIDARG;
}
{
//
// notify the extension that an object has changed
//
CDSNotifyHandlerTransaction transaction(this);
transaction.SetEventType(DSA_NOTIFY_PROP);
transaction.Begin(pDataObject, NULL, NULL, FALSE);
//
// we do not call Confirm() because this is an asynchrnous call after the fact
//
transaction.Notify(0);
transaction.End();
}
for (UINT idx = 0; idx < objectNamesFormatCracker.GetCount(); idx ++)
{
//
// update the data to be displayed, need the DN out of the ADSI path
//
CComBSTR bstrDN;
CPathCracker pathCracker;
pathCracker.Set((LPWSTR)objectNamesFormatCracker.GetName(idx), ADS_SETTYPE_FULL);
pathCracker.Retrieve(ADS_FORMAT_X500_DN, &bstrDN);
//
// update all the possible instances in the query namespace
//
if (m_pFavoritesNodesHolder != NULL)
{
// find the list of items to update
CUINodeList queryNamespaceNodeList;
m_pFavoritesNodesHolder->GetFavoritesRoot()->FindCookiesInQueries(bstrDN, &queryNamespaceNodeList);
// update all of them
for (POSITION pos = queryNamespaceNodeList.GetHeadPosition(); pos != NULL; )
{
CUINode* pCurrUINode = queryNamespaceNodeList.GetNext(pos);
HRESULT hrCurr = UpdateFromDS(pCurrUINode);
if (SUCCEEDED(hrCurr))
{
UpdateItem(pCurrUINode);
}
}
}
//
// find node in the DS namespace and update it
//
CUINode* pUINodeToUpdate = NULL;
// find the item
FindCookieInSubtree(&m_RootNode, bstrDN, QuerySnapinType(), &pUINodeToUpdate);
if (pUINodeToUpdate != NULL)
{
HRESULT hr = UpdateFromDS(pUINodeToUpdate);
if (SUCCEEDED(hr))
{
UpdateItem(pUINodeToUpdate);
}
}
}
return S_OK;
}
/* ---------------------------------------------------------
Helper function to create an LDAP query string to retrieve
a single element inside a given container.
Input: the DN of the object to query for.
e.g.: "cn=foo,ou=bar,dc=mydom,dc=com"
Output: a query string containing the leaf node properly escaped,
(as per RFC 2254)
e.g.: "(cn=foo)"
NOTES:
* we do not deal with embedded NULLs (we have regular C/C++ strings)
* any \ character remaining after the path cracked full unescaping
has to be escaped along the other special characters by
using the \HexHex sequences.
------------------------------------------------------------*/
HRESULT _CreateLdapQueryFilterStringFromDN(IN LPCWSTR lpszDN,
OUT CString& szQueryString)
{
szQueryString.Empty();
CPathCracker pathCracker;
// remove any LDAP/ADSI escaping from the DN
pathCracker.Set((LPWSTR)lpszDN, ADS_SETTYPE_DN);
pathCracker.put_EscapedMode(ADS_ESCAPEDMODE_OFF_EX);
// retrieve the leaf element
CString szNewElement;
CComBSTR bstrLeafElement;
HRESULT hr = pathCracker.GetElement(0, &bstrLeafElement);
if (FAILED(hr))
{
return hr;
}
LPCWSTR lpszTemp = bstrLeafElement;
TRACE(L"bstrLeafElement = %s\n", lpszTemp);
// do LDAP escaping (as per RFC 2254)
szQueryString = L"(";
for (WCHAR* pChar = bstrLeafElement; (*pChar) != NULL; pChar++)
{
switch (*pChar)
{
case L'*':
szQueryString += L"\\2a";
break;
case L'(':
szQueryString += L"\\28";
break;
case L')':
szQueryString += L"\\29";
break;
case L'\\':
szQueryString += L"\\5c";
break;
default:
szQueryString += (*pChar);
} // switch
} // for
// finish wrapping with parentheses,
// to get something like "(cn=foo)"
szQueryString += L")";
return S_OK;
}
HRESULT CDSComponentData::UpdateFromDS(CUINode* pUINode)
{
ASSERT(pUINode != NULL);
//
// get the node data
//
CDSCookie* pCookie = NULL;
if (IS_CLASS(*pUINode, CDSUINode))
{
pCookie = GetDSCookieFromUINode(pUINode);
}
if (pCookie == NULL)
{
ASSERT(FALSE); // should never happen
return E_FAIL;
}
//
// get the container node
//
CUINode* pParentUINode = pUINode->GetParent();
ASSERT(pParentUINode != NULL);
//
// get the distinguished name of the parent by using the path in the cookie
// and removing the leaf element using the path cracker.
// e.g., given a DN "cn=x,ou=foo,...", the parent DN will be "ou=foo,..."
//
CComBSTR bstrParentDN;
CPathCracker pathCracker;
HRESULT hr = pathCracker.Set((LPWSTR)pCookie->GetPath(), ADS_SETTYPE_DN);
ASSERT(SUCCEEDED(hr));
if (pParentUINode != GetRootNode())
{
hr = pathCracker.RemoveLeafElement();
ASSERT(SUCCEEDED(hr));
}
hr = pathCracker.Retrieve(ADS_FORMAT_X500_DN, &bstrParentDN);
ASSERT(SUCCEEDED(hr));
//
// get the LDAP path of the parent
//
CString szParentLdapPath;
GetBasePathsInfo()->ComposeADsIPath(szParentLdapPath, bstrParentDN);
//
// find a matching column set
//
CDSColumnSet* pColumnSet = pParentUINode->GetColumnSet(this);
if (pColumnSet == NULL)
{
return hr;
}
//
// create a search object and init it
//
CDSSearch ContainerSrch(m_pClassCache, this);
TRACE(L"ContainerSrch.Init(%s)\n", (LPCWSTR)szParentLdapPath);
hr = ContainerSrch.Init(szParentLdapPath);
if (FAILED(hr))
{
return hr;
}
//
// create a query string to look for the naming attribute
// eg, given a DN "cn=x,ou=foo,..." the search string
// will look like "(cn=x)"
//
CString szQueryString;
hr = _CreateLdapQueryFilterStringFromDN(pCookie->GetPath(), szQueryString);
if (FAILED(hr))
{
return hr;
}
TRACE(L"szQueryString = %s\n", (LPCWSTR)szQueryString);
ContainerSrch.SetAttributeListForContainerClass(pColumnSet);
ContainerSrch.SetFilterString((LPWSTR)(LPCWSTR)szQueryString);
if (pParentUINode == GetRootNode())
{
ContainerSrch.SetSearchScope(ADS_SCOPE_BASE);
}
else
{
ContainerSrch.SetSearchScope(ADS_SCOPE_ONELEVEL);
}
hr = ContainerSrch.DoQuery();
if (FAILED(hr))
{
return hr;
}
//
// get the only row
//
hr = ContainerSrch.GetNextRow();
if (hr == S_ADS_NOMORE_ROWS)
{
hr = E_INVALIDARG;
}
if (FAILED(hr))
{
return hr;
}
//
// update the cookie itself
//
hr = ContainerSrch.SetCookieFromData(pCookie, pColumnSet);
//
// special case if it is a domain DNS object,
// we want fo get the canonical name for display
//
if (wcscmp(pCookie->GetClass(), L"domainDNS") == 0)
{
ADS_SEARCH_COLUMN Column;
CString csCanonicalName;
int slashLocation;
LPWSTR canonicalNameAttrib = L"canonicalName";
ContainerSrch.SetAttributeList (&canonicalNameAttrib, 1);
hr = ContainerSrch.DoQuery();
if (FAILED(hr))
{
return hr;
}
hr = ContainerSrch.GetNextRow();
if (FAILED(hr))
{
return hr;
}
hr = ContainerSrch.GetColumn(canonicalNameAttrib, &Column);
if (FAILED(hr))
{
return hr;
}
ColumnExtractString (csCanonicalName, pCookie, &Column);
slashLocation = csCanonicalName.Find('/');
if (slashLocation != 0)
{
csCanonicalName = csCanonicalName.Left(slashLocation);
}
pCookie->SetName(csCanonicalName);
TRACE(L"canonical name pCookie->GetName() = %s\n", pCookie->GetName());
//
// Free column data
//
ContainerSrch.FreeColumn(&Column);
}
return hr;
}
BOOL CDSComponentData::CanRefreshAll()
{
return !_WarningOnSheetsUp(&m_RootNode);
}
void CDSComponentData::RefreshAll()
{
ASSERT(!m_RootNode.IsSheetLocked());
// need to refresh the tree (all containers below the root)
CUINodeList* pContainerNodeList = m_RootNode.GetFolderInfo()->GetContainerList();
for (POSITION pos = pContainerNodeList->GetHeadPosition(); pos != NULL; )
{
CUINode* pNode = pContainerNodeList->GetNext(pos);
ASSERT(pNode->IsContainer());
if (pNode->GetFolderInfo()->IsExpanded())
{
Refresh(pNode);
}
}
}
void CDSComponentData::ClearClassCacheAndRefreshRoot()
{
ASSERT(!m_RootNode.IsSheetLocked());
if (m_RootNode.GetFolderInfo()->IsExpanded())
{
Refresh(&m_RootNode, TRUE /*bFlushCache*/, FALSE );
}
}
// REVIEW_MARCOC_PORT: this function is not going to work with
// items that are of different types. Need to generalize as see fit.
BOOL _SearchList(CUINodeList* pContainers,
LPCWSTR lpszParentDN,
CUINode** ppParentUINode)
{
for (POSITION pos = pContainers->GetHeadPosition(); pos != NULL; )
{
CUINode* pCurrentNode = pContainers->GetNext(pos);
ASSERT(pCurrentNode->IsContainer());
if (!IS_CLASS(*pCurrentNode, CDSUINode))
{
// not a node with a cookie, just skip
continue;
}
/* is this the right cookie? */
CDSCookie* pCurrentCookie = GetDSCookieFromUINode(pCurrentNode);
LPCWSTR lpszCurrentPath = pCurrentCookie->GetPath();
TRACE (_T("--SearchList: Looking at: %s\n"), lpszCurrentPath);
if (_wcsicmp(lpszCurrentPath, lpszParentDN) == 0)
{
TRACE (_T("--SearchList: Found it!\n"));
*ppParentUINode = pCurrentNode;
return TRUE; // got it!!!
}
else
{
TRACE (L"--SearchList: not found...\n");
TRACE (_T("-- going down the tree: %s\n"), lpszCurrentPath);
CUINodeList* pSubContainers = pCurrentNode->GetFolderInfo()->GetContainerList();
if (_SearchList(pSubContainers, lpszParentDN, ppParentUINode))
{
return TRUE; // got it!!!
}
}
} // for
return FALSE; // not found
}
/*
given a cookie, find the cookie corresponding to its
parent node, if it exists. this is an expensive operation
this is used for figuring out where to refresh after having
moved an object. we know the new path to the object, but have
no idea where or if that parent cookie exists in the tree.
HUNT IT DOWN!!
*/
HRESULT
CDSComponentData::FindParentCookie(LPCWSTR lpszCookieDN, CUINode** ppParentUINode)
{
// init outout variable
*ppParentUINode = NULL;
// bind to the ADSI aobject
CString szPath;
GetBasePathsInfo()->ComposeADsIPath(szPath, lpszCookieDN);
CComPtr<IADs> spDSObj;
HRESULT hr = DSAdminOpenObject(szPath,
IID_IADs,
(void **)&spDSObj,
TRUE /*bServer*/);
if (FAILED(hr))
{
return hr; // could not bind
}
// get the LDAP path of the parent
CComBSTR ParentPath;
hr = spDSObj->get_Parent(&ParentPath);
if (FAILED(hr))
{
return hr;
}
CString szParentDN;
StripADsIPath(ParentPath, szParentDN);
TRACE(_T("goin on a cookie hunt.. (for %s)\n"), ParentPath);
// start a search from the root
CUINodeList* pContainers = m_RootNode.GetFolderInfo()->GetContainerList();
BOOL bFound = _SearchList(pContainers,
szParentDN,
ppParentUINode);
return bFound ? S_OK : S_FALSE;
}
//
// This is a recursive search of the currently expanded domain tree starting at
// the root looking at all CDSUINodes for a matching DN.
//
// NOTE : this may be an extremely expensive operation if a lot
// of containers have been expanded or they have a lot of
// children.
//
BOOL CDSComponentData::FindUINodeByDN(CUINode* pContainerNode,
PCWSTR pszDN,
CUINode** ppFoundNode)
{
if (ppFoundNode == NULL)
{
return FALSE;
}
*ppFoundNode = NULL;
if (pContainerNode == NULL || !pContainerNode->IsContainer())
{
return FALSE;
}
//
// First look through the leaf nodes
//
CUINodeList* pLeafList = pContainerNode->GetFolderInfo()->GetLeafList();
POSITION leafPos = pLeafList->GetHeadPosition();
while (leafPos != NULL)
{
CUINode* pCurrentLeaf = pLeafList->GetNext(leafPos);
if (pCurrentLeaf == NULL || !IS_CLASS(*pCurrentLeaf, CDSUINode))
{
//
// We can only search for DNs if the node is a CDSUINode
//
continue;
}
CDSCookie* pCurrentCookie = GetDSCookieFromUINode(pCurrentLeaf);
LPCWSTR lpszCurrentPath = pCurrentCookie->GetPath();
if (_wcsicmp(lpszCurrentPath, pszDN) == 0)
{
*ppFoundNode = pCurrentLeaf;
return TRUE;
}
}
//
// If not found in the leaf list then do a recursive search on the containers
//
CUINodeList* pContainerList = pContainerNode->GetFolderInfo()->GetContainerList();
POSITION containerPos = pContainerList->GetHeadPosition();
while (containerPos != NULL)
{
CUINode* pCurrentContainer = pContainerList->GetNext(containerPos);
if (pCurrentContainer == NULL || !IS_CLASS(*pCurrentContainer, CDSUINode))
{
//
// We can only search for DNs if the node is a CDSUINode
//
continue;
}
CDSCookie* pCurrentCookie = GetDSCookieFromUINode(pCurrentContainer);
LPCWSTR lpszCurrentPath = pCurrentCookie->GetPath();
if (_wcsicmp(lpszCurrentPath, pszDN) == 0)
{
*ppFoundNode = pCurrentContainer;
return TRUE;
}
else
{
//
// Start the recursion
//
if (FindUINodeByDN(pCurrentContainer, pszDN, ppFoundNode))
{
return TRUE;
}
}
}
return FALSE;
}
//
// This looks for nodes in the saved query tree that has the same DN as
// the any of the objects in the list and then invalidates the containing
// saved query node
//
void CDSComponentData::InvalidateSavedQueriesContainingObjects(const CUINodeList& refUINodeList)
{
if (QuerySnapinType() != SNAPINTYPE_SITE)
{
//
// Make a list of DNs
//
CStringList szDNList;
POSITION pos = refUINodeList.GetHeadPosition();
while (pos)
{
CDSUINode* pDSUINode = dynamic_cast<CDSUINode*>(refUINodeList.GetNext(pos));
if (!pDSUINode)
{
//
// Ignore anything that is not a DS node
//
continue;
}
CDSCookie* pCookie = GetDSCookieFromUINode(pDSUINode);
if (!pCookie)
{
ASSERT(FALSE);
continue;
}
szDNList.AddTail(pCookie->GetPath());
}
if (szDNList.GetCount() > 0)
{
//
// Now search through saved query tree invalidating query nodes
// that contain items in the list
//
GetFavoritesNodeHolder()->InvalidateSavedQueriesContainingObjects(this, szDNList);
}
}
}
//
// This looks for nodes in the saved query tree that has the same DN as
// the any of the objects in the list and then invalidates the containing
// saved query node
//
void CDSComponentData::InvalidateSavedQueriesContainingObjects(const CStringList& refPathList)
{
if (QuerySnapinType() != SNAPINTYPE_SITE)
{
CStringList szDNList;
CPathCracker pathCracker;
//
// Convert all the paths to DNs
//
POSITION pos = refPathList.GetHeadPosition();
while (pos)
{
CString szPath = refPathList.GetNext(pos);
HRESULT hr = pathCracker.Set((PWSTR)(PCWSTR)szPath, ADS_SETTYPE_FULL);
if (SUCCEEDED(hr))
{
CComBSTR sbstrDN;
hr = pathCracker.Retrieve(ADS_FORMAT_X500_DN, &sbstrDN);
if (SUCCEEDED(hr))
{
szDNList.AddTail(sbstrDN);
}
}
}
if (szDNList.GetCount() > 0)
{
//
// Now search through saved query tree invalidating query nodes
// that contain items in the list
//
GetFavoritesNodeHolder()->InvalidateSavedQueriesContainingObjects(this, szDNList);
}
}
}
void CDSComponentData::ReclaimCookies()
{
AddToLRUList (&m_RootNode);
CUINode* pUINode = NULL;
POSITION pos, pos2;
CUINodeList* pContainers = NULL;
#ifdef DBG
TRACE (_T("dumping LRU list...\n"));
pos = m_LRUList.GetHeadPosition();
while (pos)
{
pUINode = m_LRUList.GetNext(pos);
CUIFolderInfo* pFolderInfo = pUINode->GetFolderInfo();
if (pFolderInfo != NULL)
{
TRACE (_T("\tcontainer: %s (%d)\n"), pUINode->GetName(),
pFolderInfo->GetSerialNumber());
}
}
#endif
//
// Get Root folder info
//
CUIFolderInfo* pRootFolderInfo = m_RootNode.GetFolderInfo();
ASSERT(pRootFolderInfo != NULL);
TRACE (_T("-->total count is %d: reclaiming cookies from LRU list...\n"),
pRootFolderInfo->GetObjectCount());
UINT maxitems = m_pQueryFilter->GetMaxItemCount();
pos = m_LRUList.GetHeadPosition();
while (pos)
{
CUIFolderInfo* pUIFolderInfo = NULL;
pUINode = m_LRUList.GetNext(pos);
pUIFolderInfo = pUINode->GetFolderInfo();
if (pUIFolderInfo != NULL)
{
TRACE (_T("!!--!!container %s (sn:%d) containing %d objects is being reclaimed\n"),
pUINode->GetName(),
pUIFolderInfo->GetSerialNumber(),
pUIFolderInfo->GetObjectCount());
//
// clean all of the leaves out
//
pUIFolderInfo->DeleteAllLeafNodes();
//
// clean all of the containers here out of the tree view
//
pContainers = pUIFolderInfo->GetContainerList();
if (pContainers)
{
HSCOPEITEM ItemID;
CUINode* pUIContNode= NULL;
pos2 = pContainers->GetHeadPosition();
while (pos2)
{
pUIContNode = pContainers->GetNext(pos2);
CUIFolderInfo* pFolderInfo = pUIContNode->GetFolderInfo();
if (pFolderInfo != NULL)
{
ItemID = pFolderInfo->GetScopeItem();
m_pScope->DeleteItem (ItemID, TRUE);
}
}
}
pUIFolderInfo->DeleteAllContainerNodes();
pUIFolderInfo->ReSetExpanded();
if (pRootFolderInfo->GetObjectCount() < (maxitems * 5))
{
break;
}
}
}
TRACE (_T("--> done reclaiming cookies from LRU list. total count is now %d: ..\n"),
pRootFolderInfo->GetObjectCount());
//
// Empty the LRU list
//
while (!m_LRUList.IsEmpty())
{
m_LRUList.RemoveTail();
}
}
BOOL CDSComponentData::IsSelectionAnywhere(CUINode* pUINode)
{
ASSERT(pUINode->IsContainer());
UINODESELECTION nodeSelection;
nodeSelection.pUINode = pUINode;
nodeSelection.IsSelection = FALSE;
// if any view has this cookie selected, the IsSelection member
// will be TRUE when we return.
m_pFrame->UpdateAllViews (NULL,
(LPARAM)&nodeSelection,
DS_IS_COOKIE_SELECTION);
return nodeSelection.IsSelection;
}
void CDSComponentData::AddToLRUList (CUINode* pUINode)
{
HRESULT hr = S_OK;
CUIFolderInfo* pUIFolderInfo = pUINode->GetFolderInfo();
if (pUIFolderInfo != NULL)
{
CUINodeList* pContainers = pUIFolderInfo->GetContainerList();
CUINode* pUIContNode = NULL;
size_t cContainers = pContainers->GetCount();
BOOL foundSpot = FALSE;
POSITION pos;
if (cContainers > 0)
{
pos = pContainers->GetHeadPosition();
while (pos)
{
pUIContNode = pContainers->GetNext(pos);
if (pUIContNode != NULL)
{
AddToLRUList (pUIContNode);
}
}
}
//
// now we've taken care of the children, let's add
// this one to the list
//
//
// first, let's see if it is expanded
// this doesn't work currently - asking MMC guys why
//
SCOPEDATAITEM ScopeData;
ZeroMemory (&ScopeData, sizeof(SCOPEDATAITEM));
ScopeData.ID = pUIFolderInfo->GetScopeItem();
ScopeData.mask = SDI_STATE | SDI_PARAM;
hr = m_pScope->GetItem (&ScopeData);
if (!pUINode->IsSheetLocked()
&& (!IsSelectionAnywhere (pUINode))
&& (pUIFolderInfo->GetSerialNumber() != SERIALNUM_NOT_TOUCHED)
&& (!((ScopeData.nState & TVIS_EXPANDED) == TVIS_EXPANDED)))
{
pos = m_LRUList.GetHeadPosition();
if (!pos)
{
m_LRUList.AddHead(pUINode);
TRACE(_T("adding head: %s[%d]\n"), pUINode->GetName(),
pUIFolderInfo->GetSerialNumber);
}
else
{
CUINode* pLRUNode = NULL;
CUIFolderInfo* pLRUFolderInfo = NULL;
while (pos)
{
pLRUNode = m_LRUList.GetAt(pos);
pLRUFolderInfo = pLRUNode->GetFolderInfo();
if (pLRUFolderInfo != NULL)
{
if (pUIFolderInfo->GetSerialNumber() <
pLRUFolderInfo->GetSerialNumber())
{
foundSpot = TRUE;
break;
}
else
{
pLRUNode = m_LRUList.GetNext(pos);
}
}
}
if (!foundSpot)
{
m_LRUList.AddTail(pUINode);
TRACE(_T("adding tail: %s [%d]\n"), pUINode->GetName(),
pUIFolderInfo->GetSerialNumber());
}
else
{
m_LRUList.InsertBefore (pos, pUINode);
TRACE(_T("inserting: %s [%d]\n"), pUINode->GetName(),
pUIFolderInfo->GetSerialNumber());
}
}
}
}
}
HRESULT
CDSComponentData::_OnNamespaceExtensionExpand(LPDATAOBJECT, HSCOPEITEM hParent)
{
HRESULT hr = E_FAIL;
ASSERT(!m_bRunAsPrimarySnapin);
// namespace extension only for DS snapin
if (QuerySnapinType() != SNAPINTYPE_DSEX)
return hr;
// need to crack the data object to set the context
// retrieve the query string
m_pQueryFilter->SetExtensionFilterString(L"(objectClass=*)");
if (m_bAddRootWhenExtended)
{
hr = _AddScopeItem(&m_RootNode, hParent);
}
else
{
// need to directly expand the root and add children underneath
hr = _OnExpand(&m_RootNode, hParent, MMCN_EXPAND);
}
return hr;
}
//
// Right now this only checks adding group to group and user to group. Any other object class returns FALSE
//
BOOL CDSComponentData::CanAddCookieToGroup(CDSCookie* pCookie, INT iGroupType, BOOL bMixedMode)
{
BOOL bCanAdd = FALSE;
if (pCookie != NULL)
{
if (_wcsicmp(pCookie->GetClass(), L"group") == 0)
{
CDSCookieInfoGroup* pExtraInfo = dynamic_cast<CDSCookieInfoGroup*>(pCookie->GetExtraInfo());
if (pExtraInfo != NULL)
{
INT iAddGroupType = pExtraInfo->m_GroupType;
if (bMixedMode)
{
//
// Determine if the group can't be added
//
if (iGroupType & GROUP_TYPE_SECURITY_ENABLED)
{
if (iGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
if (iAddGroupType & GROUP_TYPE_SECURITY_ENABLED)
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Mixed Mode
// Target - Builtin SE
// Member - Builtin SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Mixed Mode
// Target - Builtin SE
// Member - GG SE
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Mixed Mode
// Target - Builtin SE
// Member - LG SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Mixed Mode
// Target - Builtin SE
// Member - UG SE
//
bCanAdd = FALSE;
}
else
{
//
// Mixed Mode
// Target - Builtin SE
// Member - ? SE
//
bCanAdd = FALSE;
}
}
else // group to add is a distribution group
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Mixed Mode
// Target - Builtin SE
// Member - Builtin SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Mixed Mode
// Target - Builtin SE
// Member - GG SD
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Mixed Mode
// Target - Builtin SE
// Member - LG SD
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Mixed Mode
// Target - Builtin SE
// Member - UG SD
//
bCanAdd = TRUE;
}
else
{
//
// Mixed Mode
// Target - Builtin SE
// Member - ? SD
//
bCanAdd = TRUE;
}
}
}
else if (iGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
if (iAddGroupType & GROUP_TYPE_SECURITY_ENABLED)
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Mixed Mode
// Target - GG SE
// Member - Builtin SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Mixed Mode
// Target - GG SE
// Member - GG SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Mixed Mode
// Target - GG SE
// Member - LG SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Mixed Mode
// Target - GG SE
// Member - UG SE
//
bCanAdd = FALSE;
}
else
{
//
// Mixed Mode
// Target - GG SE
// Member - ? SE
//
bCanAdd = FALSE;
}
}
else // group to add is a distribution group
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Mixed Mode
// Target - GG SE
// Member - Builtin SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Mixed Mode
// Target - GG SE
// Member - GG SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Mixed Mode
// Target - GG SE
// Member - LG SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Mixed Mode
// Target - GG SE
// Member - UG SD
//
bCanAdd = FALSE;
}
else
{
//
// Mixed Mode
// Target - GG SE
// Member - ? SD
//
bCanAdd = FALSE;
}
}
}
else if (iGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
if (iAddGroupType & GROUP_TYPE_SECURITY_ENABLED)
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Mixed Mode
// Target - LG SE
// Member - Builtin SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Mixed Mode
// Target - LG SE
// Member - GG SE
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Mixed Mode
// Target - LG SE
// Member - LG SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Mixed Mode
// Target - LG SE
// Member - UG SE
//
bCanAdd = FALSE;
}
else
{
//
// Mixed Mode
// Target - LG SE
// Member - ? SE
//
bCanAdd = FALSE;
}
}
else // group to add is a distribution group
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Mixed Mode
// Target - LG SE
// Member - Builtin SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Mixed Mode
// Target - LG SE
// Member - GG SD
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Mixed Mode
// Target - LG SE
// Member - LG SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Mixed Mode
// Target - LG SE
// Member - UG SD
//
bCanAdd = TRUE;
}
else
{
//
// Mixed Mode
// Target - LG SE
// Member - ? SD
//
bCanAdd = FALSE;
}
}
}
else if (iGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
if (iAddGroupType & GROUP_TYPE_SECURITY_ENABLED)
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Mixed Mode
// Target - UG SE
// Member - Builtin SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Mixed Mode
// Target - UG SE
// Member - GG SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Mixed Mode
// Target - UG SE
// Member - LG SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Mixed Mode
// Target - UG SE
// Member - UG SE
//
bCanAdd = FALSE;
}
else
{
//
// Mixed Mode
// Target - UG SE
// Member - ? SE
//
bCanAdd = FALSE;
}
}
else // group to add is a distribution group
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Mixed Mode
// Target - UG SE
// Member - Builtin SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Mixed Mode
// Target - UG SE
// Member - GG SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Mixed Mode
// Target - UG SE
// Member - LG SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Mixed Mode
// Target - UG SE
// Member - UG SD
//
bCanAdd = FALSE;
}
else
{
//
// Mixed Mode
// Target - UG SE
// Member - ? SD
//
bCanAdd = FALSE;
}
}
}
else
{
//
// Mixed Mode
// Target - ? SE
// Member - ? ?
//
bCanAdd = FALSE;
}
}
else // Distribution group
{
if (iGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
if (iAddGroupType & GROUP_TYPE_SECURITY_ENABLED)
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Mixed Mode
// Target - Builtin SD
// Member - Builtin SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Mixed Mode
// Target - Builtin SD
// Member - GG SE
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Mixed Mode
// Target - Builtin SD
// Member - LG SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Mixed Mode
// Target - Builtin SD
// Member - UG SE
//
bCanAdd = TRUE;
}
else
{
//
// Mixed Mode
// Target - Builtin SD
// Member - ? SE
//
bCanAdd = FALSE;
}
}
else // group to add is a distribution group
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Mixed Mode
// Target - Builtin SD
// Member - Builtin SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Mixed Mode
// Target - Builtin SD
// Member - GG SD
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Mixed Mode
// Target - Builtin SD
// Member - LG SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Mixed Mode
// Target - Builtin SD
// Member - UG SD
//
bCanAdd = TRUE;
}
else
{
//
// Mixed Mode
// Target - Builtin SD
// Member - ? SD
//
bCanAdd = TRUE;
}
}
}
else if (iGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
if (iAddGroupType & GROUP_TYPE_SECURITY_ENABLED)
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Mixed Mode
// Target - GG SD
// Member - Builtin SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Mixed Mode
// Target - GG SD
// Member - GG SE
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Mixed Mode
// Target - GG SD
// Member - LG SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Mixed Mode
// Target - GG SD
// Member - UG SE
//
bCanAdd = FALSE;
}
else
{
//
// Mixed Mode
// Target - GG SD
// Member - ? SE
//
bCanAdd = FALSE;
}
}
else // group to add is a distribution group
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Mixed Mode
// Target - GG SD
// Member - Builtin SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Mixed Mode
// Target - GG SD
// Member - GG SD
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Mixed Mode
// Target - GG SD
// Member - LG SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Mixed Mode
// Target - GG SD
// Member - UG SD
//
bCanAdd = FALSE;
}
else
{
//
// Mixed Mode
// Target - GG SD
// Member - ? SD
//
bCanAdd = FALSE;
}
}
}
else if (iGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
if (iAddGroupType & GROUP_TYPE_SECURITY_ENABLED)
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Mixed Mode
// Target - LG SD
// Member - Builtin SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Mixed Mode
// Target - LG SD
// Member - GG SE
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Mixed Mode
// Target - LG SD
// Member - LG SE
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Mixed Mode
// Target - LG SD
// Member - UG SE
//
bCanAdd = FALSE;
}
else
{
//
// Mixed Mode
// Target - LG SD
// Member - ? SE
//
bCanAdd = FALSE;
}
}
else // group to add is a distribution group
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Mixed Mode
// Target - LG SD
// Member - Builtin SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Mixed Mode
// Target - LG SD
// Member - GG SD
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Mixed Mode
// Target - LG SD
// Member - LG SD
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Mixed Mode
// Target - LG SD
// Member - UG SD
//
bCanAdd = TRUE;
}
else
{
//
// Mixed Mode
// Target - LG SD
// Member - ? SD
//
bCanAdd = FALSE;
}
}
}
else if (iGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
if (iAddGroupType & GROUP_TYPE_SECURITY_ENABLED)
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Mixed Mode
// Target - UG SD
// Member - Builtin SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Mixed Mode
// Target - UG SD
// Member - GG SE
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Mixed Mode
// Target - UG SD
// Member - LG SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Mixed Mode
// Target - UG SD
// Member - UG SE
//
bCanAdd = FALSE;
}
else
{
//
// Mixed Mode
// Target - UG SD
// Member - ? SE
//
bCanAdd = FALSE;
}
}
else // group to add is a distribution group
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Mixed Mode
// Target - UG SD
// Member - Builtin SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Mixed Mode
// Target - UG SD
// Member - GG SD
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Mixed Mode
// Target - UG SD
// Member - LG SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Mixed Mode
// Target - UG SD
// Member - UG SD
//
bCanAdd = TRUE;
}
else
{
//
// Mixed Mode
// Target - UG SD
// Member - ? SD
//
bCanAdd = FALSE;
}
}
}
else
{
//
// Mixed Mode
// Target - ? SD
// Member - ? ?
//
bCanAdd = FALSE;
}
}
}
else // native mode
{
//
// Determine if the group can't be added
//
if (iGroupType & GROUP_TYPE_SECURITY_ENABLED)
{
if (iGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
if (iAddGroupType & GROUP_TYPE_SECURITY_ENABLED)
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Native Mode
// Target - Builtin SE
// Member - Builtin SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Native Mode
// Target - Builtin SE
// Member - GG SE
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Native Mode
// Target - Builtin SE
// Member - LG SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Native Mode
// Target - Builtin SE
// Member - UG SE
//
bCanAdd = FALSE;
}
else
{
//
// Native Mode
// Target - Builtin SE
// Member - ? SE
//
bCanAdd = FALSE;
}
}
else // group to add is a distribution group
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Native Mode
// Target - Builtin SE
// Member - Builtin SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Native Mode
// Target - Builtin SE
// Member - GG SD
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Native Mode
// Target - Builtin SE
// Member - LG SD
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Native Mode
// Target - Builtin SE
// Member - UG SD
//
bCanAdd = TRUE;
}
else
{
//
// Native Mode
// Target - Builtin SE
// Member - ? SD
//
bCanAdd = TRUE;
}
}
}
else if (iGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
if (iAddGroupType & GROUP_TYPE_SECURITY_ENABLED)
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Native Mode
// Target - GG SE
// Member - Builtin SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Native Mode
// Target - GG SE
// Member - GG SE
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Native Mode
// Target - GG SE
// Member - LG SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Native Mode
// Target - GG SE
// Member - UG SE
//
bCanAdd = FALSE;
}
else
{
//
// Native Mode
// Target - GG SE
// Member - ? SE
//
bCanAdd = FALSE;
}
}
else // group to add is a distribution group
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Native Mode
// Target - GG SE
// Member - Builtin SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Native Mode
// Target - GG SE
// Member - GG SD
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Native Mode
// Target - GG SE
// Member - LG SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Native Mode
// Target - GG SE
// Member - UG SD
//
bCanAdd = FALSE;
}
else
{
//
// Native Mode
// Target - GG SE
// Member - ? SD
//
bCanAdd = FALSE;
}
}
}
else if (iGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
if (iAddGroupType & GROUP_TYPE_SECURITY_ENABLED)
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Native Mode
// Target - LG SE
// Member - Builtin SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Native Mode
// Target - LG SE
// Member - GG SE
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Native Mode
// Target - LG SE
// Member - LG SE
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Native Mode
// Target - LG SE
// Member - UG SE
//
bCanAdd = TRUE;
}
else
{
//
// Native Mode
// Target - LG SE
// Member - ? SE
//
bCanAdd = FALSE;
}
}
else // group to add is a distribution group
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Native Mode
// Target - LG SE
// Member - Builtin SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Native Mode
// Target - LG SE
// Member - GG SD
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Native Mode
// Target - LG SE
// Member - LG SD
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Native Mode
// Target - LG SE
// Member - UG SD
//
bCanAdd = TRUE;
}
else
{
//
// Native Mode
// Target - LG SE
// Member - ? SD
//
bCanAdd = FALSE;
}
}
}
else if (iGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
if (iAddGroupType & GROUP_TYPE_SECURITY_ENABLED)
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Native Mode
// Target - UG SE
// Member - Builtin SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Native Mode
// Target - UG SE
// Member - GG SE
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Native Mode
// Target - UG SE
// Member - LG SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Native Mode
// Target - UG SE
// Member - UG SE
//
bCanAdd = TRUE;
}
else
{
//
// Native Mode
// Target - UG SE
// Member - ? SE
//
bCanAdd = FALSE;
}
}
else // group to add is a distribution group
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Native Mode
// Target - UG SE
// Member - Builtin SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Native Mode
// Target - UG SE
// Member - GG SD
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Native Mode
// Target - UG SE
// Member - LG SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Native Mode
// Target - UG SE
// Member - UG SD
//
bCanAdd = TRUE;
}
else
{
//
// Native Mode
// Target - UG SE
// Member - ? SD
//
bCanAdd = FALSE;
}
}
}
else
{
//
// Native Mode
// Target - ? SE
// Member - ? ?
//
bCanAdd = FALSE;
}
}
else // Distribution group
{
if (iGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
if (iAddGroupType & GROUP_TYPE_SECURITY_ENABLED)
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Native Mode
// Target - Builtin SD
// Member - Buitlin SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Native Mode
// Target - Builtin SD
// Member - GG SE
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Native Mode
// Target - Builtin SD
// Member - LG SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Native Mode
// Target - Builtin SD
// Member - UG SE
//
bCanAdd = TRUE;
}
else
{
//
// Native Mode
// Target - Builtin SD
// Member - ? SE
//
bCanAdd = FALSE;
}
}
else // group to add is a distribution group
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Native Mode
// Target - Builtin SD
// Member - Builtin SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Native Mode
// Target - Builtin SD
// Member - GG SD
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Native Mode
// Target - Builtin SD
// Member - LG SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Native Mode
// Target - Builtin SD
// Member - UG SD
//
bCanAdd = TRUE;
}
else
{
//
// Native Mode
// Target - Builtin SD
// Member - ? SD
//
bCanAdd = TRUE;
}
}
}
else if (iGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
if (iAddGroupType & GROUP_TYPE_SECURITY_ENABLED)
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Native Mode
// Target - GG SD
// Member - Builtin SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Native Mode
// Target - GG SD
// Member - GG SE
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Native Mode
// Target - GG SD
// Member - LG SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Native Mode
// Target - GG SD
// Member - UG SE
//
bCanAdd = FALSE;
}
else
{
//
// Native Mode
// Target - GG SD
// Member - ? SE
//
bCanAdd = FALSE;
}
}
else // group to add is a distribution group
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Native Mode
// Target - GG SD
// Member - Builtin SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Native Mode
// Target - GG SD
// Member - GG SD
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Native Mode
// Target - GG SD
// Member - LG SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Native Mode
// Target - GG SD
// Member - UG SD
//
bCanAdd = FALSE;
}
else
{
//
// Native Mode
// Target - GG SD
// Member - ? SD
//
bCanAdd = FALSE;
}
}
}
else if (iGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
if (iAddGroupType & GROUP_TYPE_SECURITY_ENABLED)
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Native Mode
// Target - LG SD
// Member - Builtin SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Native Mode
// Target - LG SD
// Member - GG SE
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Native Mode
// Target - LG SD
// Member - LG SE
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Native Mode
// Target - LG SD
// Member - UG SE
//
bCanAdd = TRUE;
}
else
{
//
// Native Mode
// Target - LG SD
// Member - ? SE
//
bCanAdd = FALSE;
}
}
else // group to add is a distribution group
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Native Mode
// Target - LG SD
// Member - Builtin SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Native Mode
// Target - LG SD
// Member - GG SD
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Native Mode
// Target - LG SD
// Member - LG SD
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Native Mode
// Target - LG SD
// Member - UG SD
//
bCanAdd = TRUE;
}
else
{
//
// Native Mode
// Target - LG SD
// Member - ? SD
//
bCanAdd = FALSE;
}
}
}
else if (iGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
if (iAddGroupType & GROUP_TYPE_SECURITY_ENABLED)
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Native Mode
// Target - UG SD
// Member - Builtin SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Native Mode
// Target - UG SD
// Member - GG SE
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Native Mode
// Target - UG SD
// Member - LG SE
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Native Mode
// Target - UG SD
// Member - UG SE
//
bCanAdd = TRUE;
}
else
{
//
// Native Mode
// Target - UG SD
// Member - ? SE
//
bCanAdd = FALSE;
}
}
else // group to add is a distribution group
{
if (iAddGroupType & GROUP_TYPE_BUILTIN_LOCAL_GROUP)
{
//
// Native Mode
// Target - UG SD
// Member - Builtin SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_ACCOUNT_GROUP)
{
//
// Native Mode
// Target - UG SD
// Member - GG SD
//
bCanAdd = TRUE;
}
else if (iAddGroupType & GROUP_TYPE_RESOURCE_GROUP)
{
//
// Native Mode
// Target - UG SD
// Member - LG SD
//
bCanAdd = FALSE;
}
else if (iAddGroupType & GROUP_TYPE_UNIVERSAL_GROUP)
{
//
// Native Mode
// Target - UG SD
// Member - UG SD
//
bCanAdd = TRUE;
}
else
{
//
// Native Mode
// Target - UG SD
// Member - ? SD
//
bCanAdd = FALSE;
}
}
}
else
{
//
// Native Mode
// Target - ? SD
// Member - ? ?
//
bCanAdd = FALSE;
}
}
}
}
}
else if (_wcsicmp(pCookie->GetClass(), L"user") == 0 ||
#ifdef INETORGPERSON
_wcsicmp(pCookie->GetClass(), L"inetOrgPerson") == 0 ||
#endif
_wcsicmp(pCookie->GetClass(), L"contact") == 0 ||
_wcsicmp(pCookie->GetClass(), L"computer") == 0)
{
bCanAdd = TRUE;
}
else
{
BOOL bSecurity = (iGroupType & GROUP_TYPE_SECURITY_ENABLED) ? TRUE : FALSE;
bCanAdd = m_pClassCache->CanAddToGroup(GetBasePathsInfo(), pCookie->GetClass(), bSecurity);
}
}
else
{
bCanAdd = TRUE;
}
return bCanAdd;
}
////////////////////////////////////////////////////////////////////
// CDSComponentData thread API's
BOOL CDSComponentData::_StartBackgroundThread()
{
ASSERT(m_pHiddenWnd != NULL);
ASSERT(::IsWindow(m_pHiddenWnd->m_hWnd));
if ((m_pHiddenWnd == NULL) || !::IsWindow(m_pHiddenWnd->m_hWnd) )
return FALSE;
CDispatcherThread* pThreadObj = new CDispatcherThread;
ASSERT(pThreadObj != NULL);
if (pThreadObj == NULL)
return FALSE;
// start the the thread
ASSERT(m_pBackgroundThreadInfo->m_nThreadID == 0);
ASSERT(m_pBackgroundThreadInfo->m_hThreadHandle == NULL);
ASSERT(m_pBackgroundThreadInfo->m_state == notStarted);
ASSERT(pThreadObj->m_bAutoDelete);
if (!pThreadObj->Start(m_pHiddenWnd->m_hWnd, this))
return FALSE;
ASSERT(pThreadObj->m_nThreadID != 0);
ASSERT(pThreadObj->m_hThread != NULL);
// copy the thread info we need from the thread object
m_pBackgroundThreadInfo->m_hThreadHandle = pThreadObj->m_hThread;
m_pBackgroundThreadInfo->m_nThreadID = pThreadObj->m_nThreadID;
// wait for the thread to start and be ready to receive messages
_WaitForBackGroundThreadStartAck();
ASSERT(m_pBackgroundThreadInfo->m_state == running);
TRACE(L"dispatcher thread (HANDLE = 0x%x) running\n", m_pBackgroundThreadInfo->m_hThreadHandle);
return TRUE;
}
void CDSComponentData::_WaitForBackGroundThreadStartAck()
{
ASSERT(m_pHiddenWnd != NULL);
ASSERT(::IsWindow(m_pHiddenWnd->m_hWnd));
ASSERT(m_pBackgroundThreadInfo->m_state == notStarted);
MSG tempMSG;
while(m_pBackgroundThreadInfo->m_state == notStarted)
{
if (::PeekMessage(&tempMSG,m_pHiddenWnd->m_hWnd,CHiddenWnd::s_ThreadStartNotificationMessage,
CHiddenWnd::s_ThreadStartNotificationMessage,
PM_REMOVE))
{
DispatchMessage(&tempMSG);
}
}
ASSERT(m_pBackgroundThreadInfo->m_state == running);
}
void CDSComponentData::_ShutDownBackgroundThread()
{
TRACE(L"CDSComponentData::_ShutDownBackgroundThread()\n");
// set thread state to shutdown mode
// to avoid any spurious processing
ASSERT(m_pBackgroundThreadInfo->m_nThreadID != 0);
ASSERT(m_pBackgroundThreadInfo->m_hThreadHandle != NULL);
ASSERT(m_pBackgroundThreadInfo->m_state == running);
m_pBackgroundThreadInfo->m_state = shuttingDown;
// post a message to the dispatcher thread to signal shutdown
_PostMessageToBackgroundThread(THREAD_SHUTDOWN_MSG, 0,0);
// wait for the dispatcher thread to acknowledge
// (i.e. all worker threads have shut down)
TRACE(L"Waiting for CHiddenWnd::s_ThreadShutDownNotificationMessage\n");
MSG tempMSG;
while(m_pBackgroundThreadInfo->m_state == shuttingDown)
{
if (::PeekMessage(&tempMSG,m_pHiddenWnd->m_hWnd,CHiddenWnd::s_ThreadShutDownNotificationMessage,
CHiddenWnd::s_ThreadShutDownNotificationMessage,
PM_REMOVE))
{
DispatchMessage(&tempMSG);
}
}
ASSERT(m_pBackgroundThreadInfo->m_state == terminated);
// wait for the dispatcher thread handle to become signalled
TRACE(L"before WaitForThreadShutdown(0x%x) on dispatcher thread\n", m_pBackgroundThreadInfo->m_hThreadHandle);
WaitForThreadShutdown(&(m_pBackgroundThreadInfo->m_hThreadHandle), 1);
TRACE(L"after WaitForThreadShutdown() on dispatcher thread\n");
}
BOOL CDSComponentData::_PostQueryToBackgroundThread(CUINode* pUINode)
{
CThreadQueryInfo* pQueryInfo = NULL;
if (pUINode == &m_RootNode)
{
// enumerating the root of the namespace
CDSThreadQueryInfo* pDSQueryInfo = new CDSThreadQueryInfo;
pDSQueryInfo->SetQueryDSQueryParameters(rootFolder,
m_RootNode.GetPath(),
NULL, // class
m_pQueryFilter->GetQueryString(),
m_pQueryFilter->GetMaxItemCount(),
TRUE, // bOneLevel
m_RootNode.GetColumnSet(this)->GetColumnID());
pQueryInfo = pDSQueryInfo;
}
else if (IS_CLASS(*pUINode, CDSUINode))
{
// enumerating regular DS folder
CDSThreadQueryInfo* pDSQueryInfo = new CDSThreadQueryInfo;
CDSCookie* pCookie = GetDSCookieFromUINode(pUINode);
ASSERT(pCookie != NULL);
pDSQueryInfo->SetQueryDSQueryParameters(dsFolder,
pCookie->GetPath(),
pCookie->GetClass(),
m_pQueryFilter->GetQueryString(),
m_pQueryFilter->GetMaxItemCount(),
TRUE, // bOneLevel
pUINode->GetColumnSet(this)->GetColumnID());
pQueryInfo = pDSQueryInfo;
}
else if (IS_CLASS(*pUINode, CSavedQueryNode))
{
// enumerating a saved query folder
CDSThreadQueryInfo* pDSQueryInfo = new CDSThreadQueryInfo;
if (pDSQueryInfo != NULL)
{
CSavedQueryNode* pSavedQueryNode = dynamic_cast<CSavedQueryNode*>(pUINode);
ASSERT(pSavedQueryNode != NULL);
if (pSavedQueryNode != NULL)
{
if (pSavedQueryNode->IsFilterLastLogon())
{
if (GetBasePathsInfo()->GetDomainBehaviorVersion() == DS_BEHAVIOR_WIN2000)
{
CString szText, szCaption;
VERIFY(szText.LoadString(IDS_FILTER_LAST_LOGON_VERSION));
VERIFY(szCaption.LoadString(IDS_DSSNAPINNAME));
MessageBox(GetHWnd(), szText, szCaption, MB_OK | MB_ICONSTOP);
return FALSE;
}
}
pDSQueryInfo->SetQueryDSQueryParameters(queryFolder,
pSavedQueryNode->GetRootPath(),
NULL, // class
pSavedQueryNode->GetQueryString(),
UINT_MAX, // don't limit the number of items the query returns
pSavedQueryNode->IsOneLevel(),
pUINode->GetColumnSet(this)->GetColumnID());
pQueryInfo = pDSQueryInfo;
}
else
{
TRACE(_T("Failed to dynamically cast to CSavedQueryNode in CDSComponentData::_PostQueryToBackgroundThread()"));
ASSERT(FALSE);
}
}
else
{
TRACE(_T("Failed to allocate memory for CDSThreadQueryInfo in CDSComponentData::_PostQueryToBackgroundThread()"));
ASSERT(FALSE);
}
}
if (pQueryInfo == NULL)
{
return FALSE;
}
TRACE(_T("CDSComponentData::_PostQueryToBackgroundThread: cookie is %s\n"),
pUINode->GetName());
ASSERT(pUINode->IsContainer());
ASSERT(m_pBackgroundThreadInfo->m_nThreadID != 0);
ASSERT(m_pBackgroundThreadInfo->m_hThreadHandle != NULL);
ASSERT(m_pBackgroundThreadInfo->m_state == running);
m_queryNodeTable.Add(pUINode);
m_pFrame->UpdateAllViews(NULL, (LPARAM)pUINode, DS_VERB_UPDATE);
VERIFY(SUCCEEDED(ChangeScopeItemIcon(pUINode)));
TRACE(L"CDSComponentData::_PostQueryToBackgroundThread: posting DISPATCH_THREAD_RUN_MSG\n");
return _PostMessageToBackgroundThread(DISPATCH_THREAD_RUN_MSG,
(WPARAM)pUINode, (LPARAM)pQueryInfo);
}
BOOL CDSComponentData::_PostMessageToBackgroundThread(UINT Msg, WPARAM wParam, LPARAM lParam)
{
ASSERT(m_pBackgroundThreadInfo->m_nThreadID != 0);
ASSERT(m_pBackgroundThreadInfo->m_hThreadHandle != NULL);
return ::PostThreadMessage(m_pBackgroundThreadInfo->m_nThreadID, Msg, wParam, lParam);
}
void CDSComponentData::_OnTooMuchData(CUINode* pUINode)
{
if (!m_queryNodeTable.IsPresent(pUINode))
return; // cookie not found, node not there anymore
AFX_MANAGE_STATE(AfxGetStaticModuleState());
BOOL bHandledWithApproximation = FALSE;
CDSCookie* pDSCookie = GetDSCookieFromUINode(pUINode);
if (pDSCookie != NULL)
{
CString szPath;
GetBasePathsInfo()->ComposeADsIPath(szPath, pDSCookie->GetPath());
//
// Bind to the object and determine approximately how many
// objects are in the container
//
CComPtr<IDirectoryObject> spDirObject;
HRESULT hr = DSAdminOpenObject(szPath,
IID_IDirectoryObject,
(PVOID*)&spDirObject,
TRUE /*bServer*/);
if (SUCCEEDED(hr))
{
//
// Retrieve the approximation through the constructed attribute
//
const int iAttrCount = 1;
PWSTR pszAttribs[] = { L"msDS-Approx-Immed-Subordinates" };
PADS_ATTR_INFO pAttrInfo = NULL;
DWORD dwNumRet = 0;
CComVariant var;
hr = spDirObject->GetObjectAttributes(pszAttribs,
iAttrCount,
&pAttrInfo,
&dwNumRet);
if (SUCCEEDED(hr))
{
ASSERT(dwNumRet == 1);
ASSERT(pAttrInfo != NULL && pAttrInfo->pADsValues != NULL);
if (dwNumRet == 1 &&
pAttrInfo != NULL &&
pAttrInfo->pADsValues != NULL)
{
UINT nCount = static_cast<UINT>(pAttrInfo->pADsValues->Integer);
UINT nRetrieved = m_pQueryFilter->GetMaxItemCount();
UINT nApprox = __max(nCount, nRetrieved);
//
// Format the message
//
CString szMsg;
szMsg.Format(IDS_MSG_QUERY_TOO_MANY_ITEMS_WITH_APPROX, nRetrieved, nApprox, pUINode->GetName());
PVOID apv[1] = {(LPWSTR)(LPCWSTR)szMsg};
ReportErrorEx (m_hwnd,IDS_STRING,S_OK, MB_OK | MB_ICONINFORMATION, apv, 1);
//
// We were able to retrieve the approximation of the contained objects and post an error
// so we don't have to resort to the old message
//
bHandledWithApproximation = TRUE;
pUINode->GetFolderInfo()->SetTooMuchData(TRUE, nCount);
m_pFrame->UpdateAllViews (NULL, NULL, DS_UPDATE_OBJECT_COUNT);
}
if (pAttrInfo != NULL)
{
FreeADsMem(pAttrInfo);
pAttrInfo = NULL;
}
}
}
}
//
// Resort to using the old message if we are unable to retrieve the approximation
//
if (!bHandledWithApproximation)
{
CString szFmt;
szFmt.LoadString(IDS_MSG_QUERY_TOO_MANY_ITEMS);
CString szMsg;
szMsg.Format(szFmt, pUINode->GetName());
PVOID apv[1] = {(LPWSTR)(LPCWSTR)szMsg};
ReportErrorEx (m_hwnd,IDS_STRING,S_OK, MB_OK | MB_ICONINFORMATION, apv, 1);
}
}
void CDSComponentData::AddScopeItemToUI(CUINode* pUINode, BOOL bSetSelected)
{
if (pUINode->IsContainer())
{
CUIFolderInfo* pParentInfo = pUINode->GetFolderInfo()->GetParentNode()->GetFolderInfo();
if (pParentInfo != NULL)
{
_AddScopeItem(pUINode, pParentInfo->GetScopeItem(), bSetSelected);
}
}
}
void CDSComponentData::AddListOfNodesToUI(CUINode* pUINode, CUINodeList* pNodeList)
{
CComPtr<IDataObject> spDataObj;
HRESULT hr = QueryDataObject ((MMC_COOKIE)pUINode, CCT_SCOPE, &spDataObj);
ASSERT(SUCCEEDED(hr));
// add the icon just in case
m_pFrame->UpdateAllViews(spDataObj, /*unused*/(LPARAM)0, DS_ICON_STRIP_UPDATE);
TIMER(_T("adding containers to scope pane\n"));
// the cookie is good, add all the cookies
for (POSITION pos = pNodeList->GetHeadPosition(); pos != NULL; )
{
CUINode* pNewUINode = pNodeList->GetNext(pos);
pUINode->GetFolderInfo()->AddNode(pNewUINode); // add to the linked lists
if (pNewUINode->IsContainer())
{
// add to the scope pane
_AddScopeItem(pNewUINode, pUINode->GetFolderInfo()->GetScopeItem());
}
} // for
// for the leaf nodes, do a bulk update on the result pane
TIMER(_T("sending have-data notification to views\n"));
m_pFrame->UpdateAllViews(spDataObj, (LPARAM)pNodeList, DS_HAVE_DATA);
}
HRESULT CDSComponentData::ReadUINodeFromLdapPath(IN CDSUINode* pContainerDSUINode,
IN LPCWSTR lpszLdapPath,
OUT CDSUINode** ppSUINodeNew)
{
CDSCookie* pNewCookie = NULL;
HRESULT hr = GetActiveDS()->ReadDSObjectCookie(pContainerDSUINode,
lpszLdapPath,
&pNewCookie);
if (SUCCEEDED(hr) && (hr != S_FALSE) && (pNewCookie != NULL))
{
// make sure we update the icon cache
m_pFrame->UpdateAllViews(/*unused*/NULL /*pDataObj*/, /*unused*/(LPARAM)0, DS_ICON_STRIP_UPDATE);
// create a UI node to hold the cookie
*ppSUINodeNew = new CDSUINode(NULL);
(*ppSUINodeNew)->SetCookie(pNewCookie);
if (pNewCookie->IsContainerClass())
{
(*ppSUINodeNew)->MakeContainer();
}
}
return hr;
}
void CDSComponentData::_OnHaveData(CUINode* pUINode, CThreadQueryResult* pResult)
{
ASSERT(pUINode != NULL);
ASSERT(pUINode->IsContainer());
TRACE(_T("CDSComponentData::_OnHaveData()\n"));
if ( m_queryNodeTable.IsPresent(pUINode) && (pResult != NULL) )
{
AddListOfNodesToUI(pUINode, &(pResult->m_nodeList));
pResult->m_bOwnMemory = FALSE; // relinquish ownership of pointers
}
if (m_RootNode.GetFolderInfo()->GetObjectCount() > (m_pQueryFilter->GetMaxItemCount() * 5)) {
ReclaimCookies();
}
if (pResult != NULL)
{
delete pResult;
}
}
void CDSComponentData::_OnDone(CUINode* pUINode, HRESULT hr)
{
ASSERT(pUINode != NULL);
ASSERT(pUINode->IsContainer());
if (!m_queryNodeTable.Remove(pUINode))
return; // cookie not found, node not there anymore
// change the icon state
pUINode->SetExtOp(SUCCEEDED(hr) ? 0 : OPCODE_ENUM_FAILED);
VERIFY(SUCCEEDED(ChangeScopeItemIcon(pUINode)));
m_pFrame->UpdateAllViews(NULL, (LPARAM)pUINode, DS_VERB_UPDATE);
// update serial number
pUINode->GetFolderInfo()->UpdateSerialNumber(this);
TIMER(_T("got on-done notification\n"));
if (SUCCEEDED(hr))
{
if (pUINode->GetExtOp() & OPCODE_EXPAND_IN_PROGRESS) {
m_pFrame->UpdateAllViews(NULL, (LPARAM)pUINode, DS_DELAYED_EXPAND);
}
}
else if (m_InitSuccess)
{
if (IS_CLASS(*pUINode, CSavedQueryNode))
{
CSavedQueryNode* pQueryNode = dynamic_cast<CSavedQueryNode*>(pUINode);
if (pQueryNode != NULL)
{
if (HRESULT_CODE(hr) == ERROR_DS_FILTER_UNKNOWN)
{
//
// Error message for an invalid query filter
//
PVOID apv[2] = {(PVOID)pQueryNode->GetQueryString()};
ReportErrorEx (m_hwnd,IDS_ERRMSG_QUERY_FILTER_NOT_VALID, hr,
MB_OK | MB_ICONERROR, apv, 1);
}
else if (HRESULT_CODE(hr) == ERROR_DS_NO_SUCH_OBJECT)
{
//
// Error message for an invalid query root
//
PVOID apv[2] = {(PVOID)pQueryNode->GetRootPath(),
(PVOID)GetBasePathsInfo()->GetServerName()};
ReportErrorEx (m_hwnd,IDS_ERRMSG_QUERY_ROOT_NOT_VALID, hr,
MB_OK | MB_ICONERROR, apv, 2);
}
else
{
//
// Error message for any other error
//
ReportErrorEx (m_hwnd,IDS_ERRMSG_QUERY_FAILED, hr,
MB_OK | MB_ICONERROR, NULL, 0);
}
}
}
else
{
PVOID apv[2] = {(PVOID)GetBasePathsInfo()->GetServerName(),
(PVOID)pUINode->GetName()};
ReportErrorEx (m_hwnd,IDS_12_CANT_GET_DATA, hr,
MB_OK | MB_ICONERROR, apv, 2);
}
}
SortResultPane(pUINode);
}
void CDSComponentData::_OnSheetClose(CUINode* /*pUINode*/)
{
/*
ASSERT(pUINode != NULL);
// REVIEW_MARCOC_PORT: sheet locking is skipped for
// DS nodes, because we let them float
CDSUINode* pDSUINode = dynamic_cast<CDSUINode*>(pUINode);
if (pDSUINode != NULL)
{
return;
}
// not a DS object, need too do the usual thing
_SheetUnlockCookie(pUINode);
*/
}
HRESULT CreateSecondarySheet(HWND hWndParent,
LPCONSOLE pIConsole,
IUnknown* pUnkComponentData,
CDSUINode* pCookie,
IDataObject* pDataObject,
LPCWSTR lpszTitle)
{
ASSERT(pIConsole != NULL);
ASSERT(pDataObject != NULL);
ASSERT(pUnkComponentData != NULL);
// get an interface to a sheet provider
CComPtr<IPropertySheetProvider> spSheetProvider;
HRESULT hr = pIConsole->QueryInterface(IID_IPropertySheetProvider,(void**)&spSheetProvider);
ASSERT(SUCCEEDED(hr));
ASSERT(spSheetProvider != NULL);
// get an interface to a sheet callback
CComPtr<IPropertySheetCallback> spSheetCallback;
hr = pIConsole->QueryInterface(IID_IPropertySheetCallback,(void**)&spSheetCallback);
ASSERT(SUCCEEDED(hr));
ASSERT(spSheetCallback != NULL);
ASSERT(pDataObject != NULL);
// get a sheet
MMC_COOKIE cookie = reinterpret_cast<MMC_COOKIE>(pCookie);
hr = spSheetProvider->CreatePropertySheet(lpszTitle, TRUE, cookie,
pDataObject, 0x0 /*dwOptions*/);
ASSERT(SUCCEEDED(hr));
hr = spSheetProvider->AddPrimaryPages(pUnkComponentData,
FALSE /*bCreateHandle*/,
hWndParent,
FALSE /* bScopePane*/);
hr = spSheetProvider->AddExtensionPages();
ASSERT(SUCCEEDED(hr));
hr = spSheetProvider->Show(reinterpret_cast<LONG_PTR>(hWndParent), 0);
ASSERT(SUCCEEDED(hr));
return hr;
}
void CDSComponentData::_OnSheetCreate(PDSA_SEC_PAGE_INFO pDsaSecondaryPageInfo)
{
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);
CDSUINode* pDSUINode = 0;
CDSCookie* pNewCookie = 0;
try
{
//
// Create a node and cookie
//
pDSUINode = new CDSUINode(NULL);
if (!pDSUINode)
{
return;
}
pNewCookie = new CDSCookie();
if (!pNewCookie)
{
delete pDSUINode;
pDSUINode = 0;
return;
}
}
catch(CMemoryException *)
{
if (pDSUINode)
{
delete pDSUINode;
pDSUINode = 0;
}
if (pNewCookie)
{
delete pNewCookie;
pNewCookie = 0;
}
return;
}
//
// get the DN out of the LDAP path
//
CString szLdapPath = lpszName;
CString szDN;
StripADsIPath(szLdapPath, szDN);
pNewCookie->SetPath(szDN);
CDSClassCacheItemBase* pItem = m_pClassCache->FindClassCacheItem(this, lpszClass, szLdapPath);
ASSERT(pItem != NULL);
if (pItem == NULL)
{
delete pDSUINode;
pDSUINode = 0;
delete pNewCookie;
pNewCookie = 0;
return;
}
pNewCookie->SetCacheItem(pItem);
//
// Set the cookie in the node (from now on the node owns the cookie and its memory
//
pDSUINode->SetCookie(pNewCookie);
if (pNewCookie->IsContainerClass())
{
pDSUINode->MakeContainer();
}
//
// with the cookie, can call into ourselves to get a data object
//
CComPtr<IDataObject> spDataObject;
MMC_COOKIE cookie = reinterpret_cast<MMC_COOKIE>(pDSUINode);
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 pDSUINode;
pDSUINode = 0;
return;
}
//
// Pass the parent sheet handle to the data object.
//
PROPSHEETCFG SheetCfg = {0};
SheetCfg.hwndParentSheet = hwndParent;
FORMATETC fe = {CDSDataObject::m_cfPropSheetCfg, 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 = CreateSecondarySheet(GetHWnd(),
m_pFrame,
GetUnknown(),
pDSUINode,
spDataObject,
lpszTitle);
delete pDSUINode;
}
HRESULT CDSComponentData::SelectScopeNode(CUINode* pUINode)
{
if (!pUINode->IsContainer())
{
ASSERT(pUINode->IsContainer());
return E_INVALIDARG;
}
return m_pFrame->SelectScopeItem(pUINode->GetFolderInfo()->GetScopeItem());
}
void CDSComponentData::SortResultPane(CUINode* pUINode)
{
if(pUINode != NULL)
m_pFrame->UpdateAllViews(NULL, (LPARAM)pUINode, DS_SORT_RESULT_PANE);
}
HRESULT
CDSComponentData::QueryFromWorkerThread(CThreadQueryInfo* pQueryInfo,
CWorkerThread* pWorkerThread)
{
HRESULT hr = S_OK;
if (!m_InitSuccess)
return E_FAIL;
//if (IDYES == ::MessageBox (NULL, L"Fail Query ?", L"DS Admin", MB_YESNO))
//{
// return E_FAIL;
//}
// function called in the context of a worker thread
if (IS_CLASS(*pQueryInfo, CDSThreadQueryInfo))
{
CDSThreadQueryInfo* pDSQueryInfo = dynamic_cast<CDSThreadQueryInfo*>(pQueryInfo);
if (pDSQueryInfo != NULL)
{
ASSERT(pDSQueryInfo->GetType() != unk);
if (pDSQueryInfo->GetType() == rootFolder)
{
hr = m_ActiveDS->EnumerateRootContainer(pDSQueryInfo, pWorkerThread);
}
else if ((pDSQueryInfo->GetType() == dsFolder) || (pDSQueryInfo->GetType() == queryFolder))
{
hr = m_ActiveDS->EnumerateContainer(pDSQueryInfo, pWorkerThread);
}
}
else
{
TRACE(_T("Failed to dynamically cast to CDSThreadQueryInfo in CDSComponentData::QueryFromWorkerThread()"));
ASSERT(FALSE);
hr = E_OUTOFMEMORY;
}
}
return hr;
}
BOOL CDSComponentData::CanEnableVerb(CUINode* pUINode)
{
return !m_queryNodeTable.IsLocked(pUINode);
}
int CDSComponentData::GetImage(CUINode* pNode, BOOL bOpen)
{
ASSERT(pNode != NULL);
int imageIndex = -1;
if (m_queryNodeTable.IsPresent(pNode))
{
// executing a query, same icon across the board
imageIndex = m_iconManager.GetWaitIndex();
}
else if (pNode->GetExtOp() & OPCODE_ENUM_FAILED)
{
// error condition
if (pNode == GetRootNode())
imageIndex = m_iconManager.GetRootErrIndex();
else
imageIndex = m_iconManager.GetWarnIndex();
}
else
{
// normal state icon for the cookie
if (pNode == GetRootNode())
{
// this is the root
imageIndex = m_iconManager.GetRootIndex();
}
else if (IS_CLASS(*pNode, CFavoritesNode))
{
imageIndex = m_iconManager.GetFavoritesIndex();
}
else if (IS_CLASS(*pNode, CSavedQueryNode))
{
CSavedQueryNode* pSavedQueryNode = dynamic_cast<CSavedQueryNode*>(pNode);
if (pSavedQueryNode->IsValid())
{
imageIndex = m_iconManager.GetQueryIndex();
}
else
{
imageIndex = m_iconManager.GetQueryInvalidIndex();
}
}
else
{
imageIndex = pNode->GetImage(bOpen);
}
}
TRACE(_T("CDSComponentData::GetImage() returning: %d\n"), imageIndex);
return imageIndex;
}
void CDSComponentData::_SheetLockCookie(CUINode* pNode)
{
pNode->IncrementSheetLockCount();
m_sheetNodeTable.Add(pNode);
}
void CDSComponentData::_SheetUnlockCookie(CUINode* pNode)
{
pNode->DecrementSheetLockCount();
m_sheetNodeTable.Remove(pNode);
}
BOOL CDSComponentData::_WarningOnSheetsUp(CUINode* pNode, BOOL bShowMessage, BOOL bActivate)
{
if (!pNode->IsSheetLocked())
return FALSE; // no warning, all is cool
if (bShowMessage)
{
// warning to user that oeration cannot be performed
ReportErrorEx (m_hwnd,IDS_SHEETS_UP_DELETE,S_OK,
MB_OK | MB_ICONINFORMATION, NULL, 0);
}
// need to bring sheets on the foreground and activate it
m_sheetNodeTable.BringToForeground(pNode, this, bActivate);
return TRUE;
}
BOOL CDSComponentData::_WarningOnSheetsUp(CInternalFormatCracker* pInternalFormatCracker)
{
ASSERT(pInternalFormatCracker != NULL);
if (!pInternalFormatCracker->HasData())
{
return FALSE;
}
UINT cCookieTotalCount = pInternalFormatCracker->GetCookieCount();
//
// protect against operations with sheets up
//
BOOL bStop = FALSE;
BOOL bFirstOne = TRUE;
for (UINT cCount=0; cCount < cCookieTotalCount; cCount++)
{
CUINode* pUINode = pInternalFormatCracker->GetCookie(cCount);
if (_WarningOnSheetsUp(pUINode, bFirstOne, bFirstOne))
{
bStop = TRUE;
bFirstOne = FALSE;
}
} // for
return bStop;
}
HRESULT CDSComponentData::ColumnsChanged(CDSEvent* pDSEvent, CUINode* pUINode,
MMC_VISIBLE_COLUMNS* pVisibleColumns, BOOL bRefresh)
{
ASSERT(pUINode != NULL);
ASSERT(pUINode->IsContainer());
if (bRefresh && m_RootNode.IsSheetLocked())
{
// warning to user that oeration cannot be performed
ReportErrorEx (m_hwnd,IDS_SHEETS_UP_COLUMNS_CHANGED,S_OK,
MB_OK | MB_ICONINFORMATION, NULL, 0);
// need to bring sheets on the foreground and activate it
m_sheetNodeTable.BringToForeground(&m_RootNode, this, TRUE);
// tell MMC to discard the column changes
return E_UNEXPECTED;
}
CDSColumnSet* pColumnSet = pUINode->GetColumnSet(this);
pColumnSet->ClearVisibleColumns();
if (pVisibleColumns != NULL)
{
ASSERT(pDSEvent != NULL);
pDSEvent->SetUpdateAllViewsOrigin(TRUE);
pColumnSet->AddVisibleColumns(pVisibleColumns);
// set the dirty flag, need to save to stream to be in sync
m_bDirty = TRUE;
}
m_pFrame->UpdateAllViews(NULL, (LPARAM)pUINode, DS_UPDATE_VISIBLE_COLUMNS);
if (pDSEvent != NULL)
pDSEvent->SetUpdateAllViewsOrigin(FALSE);
if (IS_CLASS(*pUINode, CSavedQueryNode))
{
Refresh(pUINode);
}
else
{
if (bRefresh)
{
ASSERT(!m_RootNode.IsSheetLocked());
::PostMessage(m_pHiddenWnd->m_hWnd, CHiddenWnd::s_RefreshAllNotificationMessage, 0, 0);
}
}
return S_OK;
}
void CDSComponentData::ForceRefreshAll()
{
m_bDirty = TRUE;
RefreshAll();
}
HRESULT CDSComponentData::SetRenameMode(CUINode* pUINode)
{
HRESULT hr = S_OK;
if (pUINode->IsContainer())
{
CUIFolderInfo* pFolderInfo = pUINode->GetFolderInfo();
hr = m_pFrame->RenameScopeItem(pFolderInfo->GetScopeItem());
}
else
{
//
// REVIEW_JEFFJON : Codework to implement for result pane items
// Need to do an UpdateAllViews with new message and handler
//
}
return hr;
}
/////////////////////////////////////////////////////////////////////
// functionality for snapin CoClasses
SnapinType CDSSnapin::QuerySnapinType() {return SNAPINTYPE_DS;}
SnapinType CDSSnapinEx::QuerySnapinType() {return SNAPINTYPE_DSEX;}
SnapinType CSiteSnapin::QuerySnapinType() {return SNAPINTYPE_SITE;}
int ResourceIDForSnapinType[SNAPINTYPE_NUMTYPES] =
{
IDS_DSSNAPINNAME,
IDS_DS_MANAGER_EX,
IDS_SITESNAPINNAME
};
/////////////////////////////////////////////////////////////////////
// CDSSnapin (DS standalone)
CDSSnapin::CDSSnapin()
{
m_lpszSnapinHelpFile = L"dsadmin.chm";
}
/////////////////////////////////////////////////////////////////////
// CDSSnapinEx (DS namespace extension)
CDSSnapinEx::CDSSnapinEx()
{
m_bRunAsPrimarySnapin = FALSE;
m_bAddRootWhenExtended = TRUE;
m_lpszSnapinHelpFile = L"dsadmin.chm";
}
/////////////////////////////////////////////////////////////////////
// CSiteSnapin (Site manager standalone)
CSiteSnapin::CSiteSnapin()
{
m_lpszSnapinHelpFile = L"dssite.chm";
}
//////////////////////////////////////////////////////////////////////////
// CDSSnapinAbout
CDSSnapinAbout::CDSSnapinAbout()
{
m_uIdStrProvider = IDS_SNAPIN_PROVIDER;
m_uIdStrVersion = IDS_SNAPIN_VERSION;
m_uIdStrDestription = IDS_SNAPINABOUT_DESCRIPTION;
m_uIdIconImage = IDI_DSADMIN;
m_uIdBitmapSmallImage = IDB_DSADMIN;
m_uIdBitmapSmallImageOpen = IDB_DSADMIN;
m_uIdBitmapLargeImage = IDB_DSADMIN_LG;
m_crImageMask = RGB(255,0,255);
}
//////////////////////////////////////////////////////////////////////////
// CDSSnapinAbout
CSitesSnapinAbout::CSitesSnapinAbout()
{
m_uIdStrProvider = IDS_SNAPIN_PROVIDER;
m_uIdStrVersion = IDS_SNAPIN_VERSION;
m_uIdStrDestription = IDS_SITES_SNAPINABOUT_DESCRIPTION;
m_uIdIconImage = IDI_SITEREPL;
m_uIdBitmapSmallImage = IDB_SITEREPL;
m_uIdBitmapSmallImageOpen = IDB_SITEREPL;
m_uIdBitmapLargeImage = IDB_SITEREPL_LG;
m_crImageMask = RGB(255,0,255);
}
Reference in a new issue View git blame Copy permalink