able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/security/gina/snapins/ade/scope.cpp

2650 lines
84 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+--------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1994 - 1998.
//
// File: scope.cpp
//
// Contents: implementation of the scope pane
//
// Classes: CScopePane
//
// History: 03-14-1998 stevebl Created
// 05-20-1998 RahulTh added GetUNCPath and modified Command to
// use this function
//
//---------------------------------------------------------------------------
#include "precomp.hxx"
#include <wbemcli.h>
#include "rsoputil.h"
#include <list>
// Comment this line to stop trying to set the main snapin icon in the
// scope pane.
#define SET_SCOPE_ICONS 1
// Un-comment the next line to persist snap-in related data. (This really
// shouldn't be necessary since I get all my info from my parent anyway.)
// #define PERSIST_DATA 1
///////////////////////////////////////////////////////////////////////////////
// IComponentData implementation
DEBUG_DECLARE_INSTANCE_COUNTER(CScopePane);
CScopePane::CScopePane()
{
#if DBG
dbg_cRef = 0;
#endif
DEBUG_INCREMENT_INSTANCE_COUNTER(CScopePane);
DebugMsg((DM_VERBOSE, TEXT("CScopePane::CScopePane this=%08x ref=%u"), this, dbg_cRef));
m_pToolDefs = NULL;
m_pTracking = NULL;
m_pCatList = NULL;
m_pFileExt = NULL;
m_bIsDirty = FALSE;
m_hwndMainWindow = NULL;
m_fMachine = FALSE;
m_fRSOP = FALSE;
m_iViewState = IDM_WINNER;
m_pScope = NULL;
m_pConsole = NULL;
m_pIClassAdmin = NULL;
m_pIPropertySheetProvider = NULL;
m_fLoaded = FALSE;
m_fExtension = FALSE;
m_pIGPEInformation = NULL;
m_pIRSOPInformation = NULL;
m_dwRSOPFlags = 0;
m_lLastAllocated = 0;
m_ToolDefaults.NPBehavior = NP_PUBLISHED;
m_ToolDefaults.fUseWizard = TRUE;
m_ToolDefaults.fCustomDeployment = FALSE;
m_ToolDefaults.UILevel = INSTALLUILEVEL_FULL;
m_ToolDefaults.szStartPath = L""; // UNDONE - need to come up with a
// good default setting for this
m_ToolDefaults.iDebugLevel = 0;
m_ToolDefaults.fShowPkgDetails = 0;
m_ToolDefaults.nUninstallTrackingMonths = 12;
m_ToolDefaults.fUninstallOnPolicyRemoval = FALSE;
m_ToolDefaults.fZapOn64 = FALSE;
m_ToolDefaults.f32On64 = TRUE;
m_ToolDefaults.fExtensionsOnly = TRUE;
m_CatList.cCategory = 0;
m_CatList.pCategoryInfo = NULL;
m_fBlockAddPackage = FALSE;
m_fDisplayedRsopARPWarning = FALSE;
}
CScopePane::~CScopePane()
{
DEBUG_DECREMENT_INSTANCE_COUNTER(CScopePane);
DebugMsg((DM_VERBOSE, TEXT("CScopePane::~CScopePane this=%08x ref=%u"), this, dbg_cRef));
ClearCategories();
ASSERT(m_pScope == NULL);
ASSERT(CResultPane::lDataObjectRefCount == 0);
}
#include <msi.h>
STDMETHODIMP CScopePane::Initialize(LPUNKNOWN pUnknown)
{
ASSERT(pUnknown != NULL);
HRESULT hr;
AFX_MANAGE_STATE(AfxGetStaticModuleState());
// MMC should only call ::Initialize once!
ASSERT(m_pScope == NULL);
hr = pUnknown->QueryInterface(IID_IConsoleNameSpace,
reinterpret_cast<void**>(&m_pScope));
ASSERT(hr == S_OK);
hr = pUnknown->QueryInterface(IID_IPropertySheetProvider,
(void **)&m_pIPropertySheetProvider);
ASSERT(hr == S_OK);
hr = pUnknown->QueryInterface(IID_IConsole, reinterpret_cast<void**>(&m_pConsole));
ASSERT(hr == S_OK);
#ifdef SET_SCOPE_ICONS
LPIMAGELIST lpScopeImage;
hr = m_pConsole->QueryScopeImageList(&lpScopeImage);
ASSERT(hr == S_OK);
// Load the bitmaps from the dll
CBitmap bmp16x16;
CBitmap bmp32x32;
bmp16x16.LoadBitmap(IDB_16x16);
bmp32x32.LoadBitmap(IDB_32x32);
// Set the images
lpScopeImage->ImageListSetStrip(reinterpret_cast<LONG_PTR *>(static_cast<HBITMAP>(bmp16x16)),
reinterpret_cast<LONG_PTR *>(static_cast<HBITMAP>(bmp32x32)),
0, RGB(255,0,255));
SAFE_RELEASE(lpScopeImage);
#endif
// get the main window
hr = m_pConsole->GetMainWindow(&m_hwndMainWindow);
ASSERT(hr == S_OK);
return S_OK;
}
void CScopePane::RemoveResultPane(CResultPane * pRP)
{
m_sResultPane.erase(pRP);
}
STDMETHODIMP CScopePane::CreateComponent(LPCOMPONENT* ppComponent)
{
ASSERT(ppComponent != NULL);
DebugMsg((DM_VERBOSE, TEXT("CScopePane::CreateComponent this=%08x ppComponent=%08x."), this, ppComponent));
CComObject<CResultPane>* pObject;
CComObject<CResultPane>::CreateInstance(&pObject);
ASSERT(pObject != NULL);
DebugMsg((DM_VERBOSE, TEXT("CScopePane::CreateComponent pObject=%08x."), pObject));
m_sResultPane.insert(pObject);
// Store IComponentData
pObject->SetIComponentData(this);
return pObject->QueryInterface(IID_IComponent,
reinterpret_cast<void**>(ppComponent));
}
HRESULT CScopePane::TestForRSoPData(BOOL * pfPolicyFailed)
{
*pfPolicyFailed = FALSE;
HRESULT hr = S_OK;
IWbemLocator * pLocator = NULL;
IWbemServices * pNamespace = NULL;
IWbemClassObject * pObj = NULL;
IEnumWbemClassObject * pEnum = NULL;
BSTR strQueryLanguage = SysAllocString(TEXT("WQL"));
BSTR strNamespace = SysAllocString(m_szRSOPNamespace);
BSTR strObject = SysAllocString(TEXT("RSOP_ExtensionStatus.extensionGuid=\"{c6dc5466-785a-11d2-84d0-00c04fb169f7}\""));
BSTR strQuery = SysAllocString(TEXT("SELECT * FROM RSOP_ApplicationManagementPolicySetting"));
ULONG n = 0;
hr = CoCreateInstance(CLSID_WbemLocator,
0,
CLSCTX_INPROC_SERVER,
IID_IWbemLocator,
(LPVOID *) & pLocator);
DebugReportFailure(hr, (DM_WARNING, TEXT("TestForRSoPData: CoCreateInstance failed with 0x%x"), hr));
if (FAILED(hr))
{
goto cleanup;
}
hr = pLocator->ConnectServer(strNamespace,
NULL,
NULL,
NULL,
0,
NULL,
NULL,
&pNamespace);
DebugReportFailure(hr, (DM_WARNING, TEXT("TestForRSoPData: pLocator->ConnectServer failed with 0x%x"), hr));
if (FAILED(hr))
{
goto cleanup;
}
hr = pNamespace->ExecQuery(strQueryLanguage,
strQuery,
WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY,
NULL,
&pEnum);
DebugReportFailure(hr, (DM_WARNING, TEXT("TestForRSoPData: pNamespace->ExecQuery failed with 0x%x"), hr));
if (FAILED(hr))
{
goto cleanup;
}
hr = pEnum->Next(WBEM_INFINITE, 1, &pObj, &n);
DebugReportFailure(hr, (DM_WARNING, TEXT("TestForRSoPData: pEnum->Next failed with 0x%x"), hr));
if (FAILED(hr))
{
goto cleanup;
}
if (n == 0)
{
// there's no data here
hr = E_FAIL;
goto cleanup;
}
if (pObj)
{
pObj->Release();
pObj=NULL;
}
// check for failed settings
hr = pNamespace->GetObject(strObject,
WBEM_FLAG_RETURN_WBEM_COMPLETE,
NULL,
&pObj,
NULL);
DebugReportFailure(hr, (DM_WARNING, TEXT("TestForRSoPData: pNamespace->GetObject failed with 0x%x"), hr));
if (SUCCEEDED(hr))
{
HRESULT hrStatus;
hr = GetParameter(pObj,
TEXT("error"),
hrStatus);
DebugReportFailure(hr, (DM_WARNING, TEXT("TestForRSoPData: GetParameter(\"error\") failed with 0x%x"), hr));
if (SUCCEEDED(hr))
{
*pfPolicyFailed = hrStatus != 0;
}
}
cleanup:
SysFreeString(strObject);
SysFreeString(strQuery);
SysFreeString(strQueryLanguage);
SysFreeString(strNamespace);
if (pObj)
{
pObj->Release();
}
if (pEnum)
{
pEnum->Release();
}
if (pNamespace)
{
pNamespace->Release();
}
if (pLocator)
{
pLocator->Release();
}
return hr;
}
STDMETHODIMP CScopePane::Notify(LPDATAOBJECT lpDataObject, MMC_NOTIFY_TYPE event, LPARAM arg, LPARAM param)
{
ASSERT(m_pScope != NULL);
HRESULT hr = S_OK;
// Since it's my folder it has an internal format.
// Design Note: for extension. I can use the fact, that the data object doesn't have
// my internal format and I should look at the node type and see how to extend it.
if (event == MMCN_PROPERTY_CHANGE)
{
SaveToolDefaults();
hr = OnProperties(param);
}
else
{
INTERNAL* pInternal = ExtractInternalFormat(lpDataObject);
MMC_COOKIE cookie = 0;
if (pInternal != NULL)
{
cookie = pInternal->m_cookie;
FREE_INTERNAL(pInternal);
}
else
{
// only way we could not be able to extract our own format is if we're operating as an extension
m_fExtension = TRUE;
}
if (m_fRSOP)
{
if (m_pIRSOPInformation == NULL)
{
WCHAR szBuffer[MAX_DS_PATH];
m_fRSOPEnumerate = FALSE;
IRSOPInformation * pIRSOPInformation;
hr = lpDataObject->QueryInterface(IID_IRSOPInformation,
reinterpret_cast<void**>(&pIRSOPInformation));
if (SUCCEEDED(hr))
{
m_pIRSOPInformation = pIRSOPInformation;
m_pIRSOPInformation->AddRef();
hr = m_pIRSOPInformation->GetFlags(&m_dwRSOPFlags);
if (SUCCEEDED(hr))
{
/* extract the namespace here */
hr = m_pIRSOPInformation->GetNamespace(m_fMachine ? GPO_SECTION_MACHINE : GPO_SECTION_USER, szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]));
if (SUCCEEDED(hr))
{
m_szRSOPNamespace = szBuffer;
// check to be sure that there is data to show in the RSoP database
if SUCCEEDED(TestForRSoPData(&m_fRSOPPolicyFailed))
m_fRSOPEnumerate = TRUE;
}
pIRSOPInformation->Release();
}
}
}
}
else
{
if (m_pIGPEInformation == NULL)
{
IGPEInformation * pIGPEInformation;
hr = lpDataObject->QueryInterface(IID_IGPEInformation,
reinterpret_cast<void**>(&pIGPEInformation));
if (SUCCEEDED(hr))
{
GROUP_POLICY_OBJECT_TYPE gpoType;
hr = pIGPEInformation->GetType(&gpoType);
if (SUCCEEDED(hr))
{
if (gpoType == GPOTypeDS)
{
WCHAR szBuffer[MAX_DS_PATH];
do
{
hr = pIGPEInformation->GetDSPath(GPO_SECTION_ROOT, szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]));
if (FAILED(hr))
{
break;
}
m_szGPO = szBuffer;
hr = pIGPEInformation->GetDisplayName(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]));
if (FAILED(hr))
{
break;
}
m_szGPODisplayName = szBuffer;
hr = pIGPEInformation->GetDSPath(m_fMachine ? GPO_SECTION_MACHINE : GPO_SECTION_USER, szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]));
if (FAILED(hr))
{
break;
}
m_pIGPEInformation = pIGPEInformation;
m_pIGPEInformation->AddRef();
m_szLDAP_Path = szBuffer;
hr = pIGPEInformation->GetFileSysPath(m_fMachine ? GPO_SECTION_MACHINE : GPO_SECTION_USER, szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]));
if (FAILED(hr)) break;
m_szGPT_Path = szBuffer;
// Here we get the domain name from the GPT_Path.
// The domain name is the very first element in
// the path so this is quite trivial.
m_szDomainName = &((LPCTSTR)m_szGPT_Path)[2]; // skip the "\\"
m_szDomainName = m_szDomainName.SpanExcluding(L"\\");
m_szGPT_Path += L"\\Applications";
hr = InitializeADE();
LoadToolDefaults();
if (SUCCEEDED(hr))
{
// cleanup archived records in the class store
FILETIME ft;
SYSTEMTIME st;
// get current time
GetSystemTime(&st);
// convert it to a FILETIME value
SystemTimeToFileTime(&st, &ft);
// subtract the right number of days
LARGE_INTEGER li;
li.LowPart = ft.dwLowDateTime;
li.HighPart = ft.dwHighDateTime;
li.QuadPart -= ONE_FILETIME_DAY * (((LONGLONG)m_ToolDefaults.nUninstallTrackingMonths * 365)/12);
ft.dwLowDateTime = li.LowPart;
ft.dwHighDateTime = li.HighPart;
// tell the CS to clean up anything older
m_pIClassAdmin->Cleanup(&ft);
}
else
{
// we can still continue even if
// initialization failed provided
// that the reason it failed is that
// the ClassStore object doesn't exist.
if (CS_E_OBJECT_NOTFOUND == hr)
{
hr = S_OK;
}
else
{
// report error
LogADEEvent(EVENTLOG_ERROR_TYPE, EVENT_ADE_INIT_FAILED, hr);
}
}
} while (0);
}
else
{
// force this to fail
hr = E_FAIL;
}
}
pIGPEInformation->Release();
}
}
}
if (SUCCEEDED(hr))
{
switch(event)
{
case MMCN_EXPAND:
{
hr = OnExpand(cookie, arg, param);
}
break;
case MMCN_SELECT:
hr = OnSelect(cookie, arg, param);
break;
case MMCN_CONTEXTMENU:
hr = OnContextMenu(cookie, arg, param);
break;
case MMCN_REFRESH:
hr = Command(IDM_REFRESH, lpDataObject);
break;
default:
break;
}
}
}
return hr;
}
STDMETHODIMP CScopePane::Destroy()
{
// Delete enumerated scope items
DeleteList();
SAFE_RELEASE(m_pScope);
SAFE_RELEASE(m_pConsole);
SAFE_RELEASE(m_pIClassAdmin);
SAFE_RELEASE(m_pIPropertySheetProvider);
SAFE_RELEASE(m_pIGPEInformation);
SAFE_RELEASE(m_pIRSOPInformation);
return S_OK;
}
STDMETHODIMP CScopePane::QueryDataObject(MMC_COOKIE cookie, DATA_OBJECT_TYPES type, LPDATAOBJECT* ppDataObject)
{
ASSERT(ppDataObject != NULL);
CComObject<CDataObject>* pObject;
CComObject<CDataObject>::CreateInstance(&pObject);
ASSERT(pObject != NULL);
pObject->m_fMachine = m_fMachine;
// Save cookie and type for delayed rendering
pObject->SetType(type);
pObject->SetCookie(cookie);
return pObject->QueryInterface(IID_IDataObject,
reinterpret_cast<void**>(ppDataObject));
}
///////////////////////////////////////////////////////////////////////////////
//// IPersistStreamInit interface members
STDMETHODIMP CScopePane::GetClassID(CLSID *pClassID)
{
ASSERT(pClassID != NULL);
// Copy the CLSID for this snapin
if (m_fRSOP)
{
if (m_fMachine)
*pClassID = CLSID_RSOP_MachineSnapin;
else
*pClassID = CLSID_RSOP_Snapin;
}
else
{
if (m_fMachine)
*pClassID = CLSID_MachineSnapin;
else
*pClassID = CLSID_Snapin;
}
return S_OK;
}
STDMETHODIMP CScopePane::IsDirty()
{
return ThisIsDirty() ? S_OK : S_FALSE;
}
STDMETHODIMP CScopePane::Load(IStream *pStm)
{
#ifdef PERSIST_DATA
ASSERT(pStm);
// Read the string
TCHAR psz[MAX_DS_PATH];
ULONG nBytesRead;
ULONG cb;
HRESULT hr = pStm->Read(&cb, sizeof(ULONG), &nBytesRead);
if (SUCCEEDED(hr))
{
hr = pStm->Read(psz, cb, &nBytesRead);
if (SUCCEEDED(hr))
{
if (cb > MAX_DS_PATH * sizeof(TCHAR))
{
return E_FAIL;
}
m_szLDAP_Path = psz;
hr = pStm->Read(&cb, sizeof(ULONG), &nBytesRead);
if (SUCCEEDED(hr))
{
if (cb > MAX_DS_PATH * sizeof(TCHAR))
{
return E_FAIL;
}
hr = pStm->Read(psz, cb, &nBytesRead);
if (SUCCEEDED(hr))
{
m_szGPT_Path = psz;
m_fLoaded = TRUE;
ClearDirty();
LoadToolDefaults();
}
}
}
}
return SUCCEEDED(hr) ? S_OK : E_FAIL;
#else
return S_OK;
#endif
}
STDMETHODIMP CScopePane::Save(IStream *pStm, BOOL fClearDirty)
{
#ifdef PERSIST_DATA
ASSERT(pStm);
// Write the string
ULONG nBytesWritten;
ULONG cb = (m_szLDAP_Path.GetLength() + 1) * sizeof(TCHAR);
HRESULT hr = pStm->Write(&cb, sizeof(ULONG), &nBytesWritten);
if (FAILED(hr))
return STG_E_CANTSAVE;
hr = pStm->Write(m_szLDAP_Path, cb, &nBytesWritten);
if (FAILED(hr))
return STG_E_CANTSAVE;
cb = (m_szGPT_Path.GetLength() + 1) * sizeof(TCHAR);
hr = pStm->Write(&cb, sizeof(ULONG), &nBytesWritten);
if (FAILED(hr))
return STG_E_CANTSAVE;
hr = pStm->Write(m_szGPT_Path, cb, &nBytesWritten);
if (FAILED(hr))
return STG_E_CANTSAVE;
#endif
if (fClearDirty)
ClearDirty();
return S_OK;
}
STDMETHODIMP CScopePane::GetSizeMax(ULARGE_INTEGER *pcbSize)
{
#ifdef PERSIST_DATA
ASSERT(pcbSize);
ULONG cb = (m_szLDAP_Path.GetLength() + m_szGPT_Path.GetLength() + 2) * sizeof(TCHAR) + 2 * sizeof(ULONG);
// Set the size of the string to be saved
#else
ULONG cb = 0;
#endif
ULISet32(*pcbSize, cb);
return S_OK;
}
STDMETHODIMP CScopePane::InitNew(void)
{
return S_OK;
}
void CScopePane::LoadToolDefaults()
{
CString szFileName = m_szGPT_Path;
szFileName += L"\\";
szFileName += CFGFILE;
FILE * f = _wfopen(szFileName, L"rt");
if (f)
{
WCHAR sz[256];
CString szData;
CString szKey;
while (fgetws(sz, 256, f))
{
szData = sz;
szKey = szData.SpanExcluding(L"=");
szData = szData.Mid(szKey.GetLength()+1);
szData.TrimRight();
szData.TrimLeft();
szKey.TrimRight();
if (0 == szKey.CompareNoCase(KEY_NPBehavior))
{
swscanf(szData, L"%i", &m_ToolDefaults.NPBehavior);
}
else if (0 == szKey.CompareNoCase(KEY_fUseWizard))
{
swscanf(szData, L"%i", &m_ToolDefaults.fUseWizard);
}
else if (0 == szKey.CompareNoCase(KEY_fCustomDeployment))
{
swscanf(szData, L"%i", &m_ToolDefaults.fCustomDeployment);
}
else if (0 == szKey.CompareNoCase(KEY_UILevel))
{
swscanf(szData, L"%i", &m_ToolDefaults.UILevel);
}
else if (0 == szKey.CompareNoCase(KEY_szStartPath))
{
m_ToolDefaults.szStartPath = szData;
}
else if (0 == szKey.CompareNoCase(KEY_nUninstallTrackingMonths))
{
swscanf(szData, L"%i", &m_ToolDefaults.nUninstallTrackingMonths);
}
else if (0 == szKey.CompareNoCase(KEY_iDebugLevel))
{
swscanf(szData, L"%i", &m_ToolDefaults.iDebugLevel);
}
else if (0 == szKey.CompareNoCase(KEY_fShowPkgDetails))
{
swscanf(szData, L"%i", &m_ToolDefaults.fShowPkgDetails);
}
else if (0 == szKey.CompareNoCase(KEY_fUninstallOnPolicyRemoval))
{
swscanf(szData, L"%i", &m_ToolDefaults.fUninstallOnPolicyRemoval);
}
else if (0 == szKey.CompareNoCase(KEY_f32On64))
{
swscanf(szData, L"%i", &m_ToolDefaults.f32On64);
}
else if (0 == szKey.CompareNoCase(KEY_fZapOn64))
{
swscanf(szData, L"%i", &m_ToolDefaults.fZapOn64);
}
else if (0 == szKey.CompareNoCase(KEY_fExtensionsOnly))
{
swscanf(szData, L"%i", &m_ToolDefaults.fExtensionsOnly);
}
}
fclose(f);
}
}
void CScopePane::SaveToolDefaults()
{
CString szFileName = m_szGPT_Path;
szFileName += L"\\";
szFileName += CFGFILE;
FILE * f = _wfopen(szFileName, L"wt");
if (f)
{
fwprintf(f, L"%s=%i\n", KEY_NPBehavior, m_ToolDefaults.NPBehavior);
fwprintf(f, L"%s=%i\n", KEY_fUseWizard, m_ToolDefaults.fUseWizard);
fwprintf(f, L"%s=%i\n", KEY_fCustomDeployment, m_ToolDefaults.fCustomDeployment);
fwprintf(f, L"%s=%i\n", KEY_UILevel, m_ToolDefaults.UILevel);
fwprintf(f, L"%s=%s\n", KEY_szStartPath, m_ToolDefaults.szStartPath);
fwprintf(f, L"%s=%i\n", KEY_nUninstallTrackingMonths, m_ToolDefaults.nUninstallTrackingMonths);
fwprintf(f, L"%s=%i\n", KEY_fUninstallOnPolicyRemoval, m_ToolDefaults.fUninstallOnPolicyRemoval);
fwprintf(f, L"%s=%i\n", KEY_f32On64, m_ToolDefaults.f32On64);
fwprintf(f, L"%s=%i\n", KEY_fZapOn64, m_ToolDefaults.fZapOn64);
fwprintf(f, L"%s=%i\n", KEY_fExtensionsOnly, m_ToolDefaults.fExtensionsOnly);
if (m_ToolDefaults.iDebugLevel > 0)
{
fwprintf(f, L"%s=%i\n", KEY_iDebugLevel, m_ToolDefaults.iDebugLevel);
}
if (m_ToolDefaults.fShowPkgDetails > 0)
{
fwprintf(f, L"%s=%i\n", KEY_fShowPkgDetails, m_ToolDefaults.fShowPkgDetails);
}
fclose(f);
}
}
//+--------------------------------------------------------------------------
//
// Member: CScopePane::GetClassStoreName
//
// Synopsis: Gets the name of the class store from the DS.
// If the name isn't stored under the "defaultClassStore"
// property then the name "CN = Class Store" is used and the
// property is set.
//
// Arguments: [sz] - [out] name of the class store
// [fCreateOK] - [in] TRUE if the class store is to be created
// if it doesn't already exist. Otherwise this
// routine fails if the class store isn't found.
//
// Returns: S_OK on success
//
// History: 2-17-1998 stevebl Created
//
// Notes: Assumes m_szLDAP_Path contains the path to the DS object.
//
//---------------------------------------------------------------------------
HRESULT CScopePane::GetClassStoreName(CString &sz, BOOL fCreateOK)
{
if (m_fRSOP)
{
return E_UNEXPECTED;
}
HRESULT hr;
LPOLESTR szCSPath;
hr = CsGetClassStorePath((LPOLESTR)((LPCOLESTR)m_szLDAP_Path), &szCSPath);
if (SUCCEEDED(hr))
{
sz = szCSPath;
OLESAFE_DELETE(szCSPath);
}
else
{
if (fCreateOK)
{
// set sz to the default setting and save the path
IADsPathname * pADsPathname = NULL;
hr = CoCreateInstance(CLSID_Pathname,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsPathname,
(LPVOID*)&pADsPathname);
if (FAILED(hr))
{
return hr;
}
hr = pADsPathname->Set((LPOLESTR)((LPCOLESTR)m_szLDAP_Path), ADS_SETTYPE_FULL);
if (FAILED(hr))
{
pADsPathname->Release();
return hr;
}
hr = pADsPathname->AddLeafElement(L"CN=Class Store");
if (FAILED(hr))
{
pADsPathname->Release();
return hr;
}
BSTR bstr;
hr = pADsPathname->Retrieve(ADS_FORMAT_X500_NO_SERVER, &bstr);
pADsPathname->Release();
if (FAILED(hr))
{
return hr;
}
sz = bstr;
SysFreeString(bstr);
// This has to be here becuase CsSetClassStorePath will fail if the
// class store doesn't already exist.
hr = CsCreateClassStore((LPOLESTR)((LPCOLESTR)sz));
if (FAILED(hr))
{
// Changed to CS_E_OBJECT_ALREADY_EXISTS.
// I check for both ERROR_ALREAD_EXISTS and CS_E_OBJECT_ALREADY_EXISTS
// just to be safe.
if ((hr != HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS)) && (hr != CS_E_OBJECT_ALREADY_EXISTS))
{
return hr;
}
}
}
}
return hr;
}
//+--------------------------------------------------------------------------
//
// Member: CScopePane::GetPackageDSPath
//
// Synopsis: gets the path to an individual package's DS object
//
// Arguments: [szPath] - [out] LDAP path to the package
// [szPackageName] - [in] name of the package
//
// Returns: S_OK on success
//
// History: 3-26-1998 stevebl Created
//
//---------------------------------------------------------------------------
HRESULT CScopePane::GetPackageDSPath(CString &szPath, LPOLESTR szPackageName)
{
#if 1
LPOLESTR sz;
HRESULT hr = m_pIClassAdmin->GetDNFromPackageName(szPackageName, &sz);
if (FAILED(hr))
{
return hr;
}
szPath = sz;
OLESAFE_DELETE(sz);
#else
HRESULT hr = GetClassStoreName(szPath, FALSE);
if (FAILED(hr))
{
return hr;
}
// set sz to the default setting and save the path
IADsPathname * pADsPathname = NULL;
hr = CoCreateInstance(CLSID_Pathname,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsPathname,
(LPVOID*)&pADsPathname);
if (FAILED(hr))
{
return hr;
}
hr = pADsPathname->Set((LPOLESTR)((LPCOLESTR)szPath), ADS_SETTYPE_FULL);
if (FAILED(hr))
{
pADsPathname->Release();
return hr;
}
hr = pADsPathname->AddLeafElement(L"CN=Packages");
if (FAILED(hr))
{
pADsPathname->Release();
return hr;
}
CString sz = L"CN=";
sz+= szPackageName;
hr = pADsPathname->AddLeafElement((LPOLESTR)((LPCOLESTR)sz));
if (FAILED(hr))
{
pADsPathname->Release();
return hr;
}
BSTR bstr;
hr = pADsPathname->Retrieve(ADS_FORMAT_X500_NO_SERVER, &bstr);
pADsPathname->Release();
if (FAILED(hr))
{
return hr;
}
szPath = bstr;
SysFreeString(bstr);
#endif
return S_OK;
}
//+--------------------------------------------------------------------------
//
// Member: CScopePane::GetClassStore
//
// Synopsis: gets the IClassAdmin interface and creates a class store if
// it doesn't already exist.
//
// Arguments: [fCreateOK] - TRUE if the Class Store should be created if
// it doesn't already exist.
//
// Returns:
//
// Modifies: m_pIClassAdmin
//
// Derivation:
//
// History: 2-11-1998 stevebl Created
//
// Notes: Assumes m_szLDAP_Path contains the path to the DS object
//
//---------------------------------------------------------------------------
HRESULT CScopePane::GetClassStore(BOOL fCreateOK)
{
HRESULT hr;
CString szCSPath;
hr = GetClassStoreName(szCSPath, fCreateOK);
if (FAILED(hr))
{
return hr;
}
hr = CsGetClassStore((LPOLESTR)((LPCOLESTR)szCSPath), (LPVOID*)&m_pIClassAdmin);
if (FAILED(hr) && fCreateOK)
{
// Sometimes we can get into this wierd state where
// GetClassStoreName was able to create a entry for the class store
// name but it wasn't able to actually create the class store. This
// should handle that special case.
// Try and create it here and then bind to it again.
hr = CsCreateClassStore((LPOLESTR)((LPCOLESTR)szCSPath));
if (FAILED(hr))
{
// Changed to CS_E_OBJECT_ALREADY_EXISTS.
// I check for both ERROR_ALREAD_EXISTS and CS_E_OBJECT_ALREADY_EXISTS
// just to be safe.
// I'll check for both just to be safe.
if ((hr != HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS)) && (hr != CS_E_OBJECT_ALREADY_EXISTS))
{
return hr;
}
}
hr = CsGetClassStore((LPOLESTR)((LPCOLESTR)szCSPath), (LPVOID*)&m_pIClassAdmin);
}
return hr;
}
UINT CScopePane::CreateNestedDirectory (LPTSTR lpDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes)
{
TCHAR szDirectory[MAX_PATH];
LPTSTR lpEnd;
//
// Check for NULL pointer
//
if (!lpDirectory || !(*lpDirectory)) {
SetLastError(ERROR_INVALID_DATA);
return 0;
}
//
// First, see if we can create the directory without having
// to build parent directories.
//
if (CreateDirectory (lpDirectory, lpSecurityAttributes)) {
return 1;
}
//
// If this directory exists already, this is OK too.
//
if (GetLastError() == ERROR_ALREADY_EXISTS) {
return ERROR_ALREADY_EXISTS;
}
//
// No luck, copy the string to a buffer we can munge
//
lstrcpy (szDirectory, lpDirectory);
//
// Find the first subdirectory name
//
lpEnd = szDirectory;
if (szDirectory[1] == TEXT(':')) {
lpEnd += 3;
} else if (szDirectory[1] == TEXT('\\')) {
//
// Skip the first two slashes
//
lpEnd += 2;
//
// Find the slash between the server name and
// the share name.
//
while (*lpEnd && *lpEnd != TEXT('\\')) {
lpEnd++;
}
if (!(*lpEnd)) {
return 0;
}
//
// Skip the slash, and find the slash between
// the share name and the directory name.
//
lpEnd++;
while (*lpEnd && *lpEnd != TEXT('\\')) {
lpEnd++;
}
if (!(*lpEnd)) {
return 0;
}
//
// Leave pointer at the beginning of the directory.
//
lpEnd++;
} else if (szDirectory[0] == TEXT('\\')) {
lpEnd++;
}
while (*lpEnd) {
while (*lpEnd && *lpEnd != TEXT('\\')) {
lpEnd++;
}
if (*lpEnd == TEXT('\\')) {
*lpEnd = TEXT('\0');
if (!CreateDirectory (szDirectory, NULL)) {
if (GetLastError() != ERROR_ALREADY_EXISTS) {
return 0;
}
}
*lpEnd = TEXT('\\');
lpEnd++;
}
}
//
// Create the final directory
//
if (CreateDirectory (szDirectory, lpSecurityAttributes)) {
return 1;
}
if (GetLastError() == ERROR_ALREADY_EXISTS) {
return ERROR_ALREADY_EXISTS;
}
//
// Failed
//
return 0;
}
///////////////////////////////////////////////////////////////////////////////
//// Notify handlers for IComponentData
HRESULT CScopePane::OnAdd(MMC_COOKIE cookie, LPARAM arg, LPARAM param)
{
return E_UNEXPECTED;
}
HRESULT CScopePane::OnExpand(MMC_COOKIE cookie, LPARAM arg, LPARAM param)
{
if (arg == TRUE)
{
// Did Initialize get called?
ASSERT(m_pScope != NULL);
EnumerateScopePane(cookie,
param);
}
return S_OK;
}
HRESULT CScopePane::OnSelect(MMC_COOKIE cookie, LPARAM arg, LPARAM param)
{
return E_UNEXPECTED;
}
HRESULT CScopePane::OnContextMenu(MMC_COOKIE cookie, LPARAM arg, LPARAM param)
{
return S_OK;
}
HRESULT CScopePane::OnProperties(LPARAM param)
{
if (param == NULL)
{
return S_OK;
}
ASSERT(param != NULL);
return S_OK;
}
void CScopePane::EnumerateScopePane(MMC_COOKIE cookie, HSCOPEITEM pParent)
{
if (m_fRSOP && !m_fRSOPEnumerate)
{
// don't allow an empty RSOP database to enumerate the snapin
return;
}
// make sure that the result pane gets enumerated once
// so that internal structures get initialized.
// We only have one folder so this is really easy.
if (cookie != NULL)
return ;
if (m_fExtension)
{
// if we're an extension then add a root folder to hang everything off of
SCOPEDATAITEM * m_pScopeItem = new SCOPEDATAITEM;
memset(m_pScopeItem, 0, sizeof(SCOPEDATAITEM));
m_pScopeItem->mask = SDI_STR | SDI_PARAM | SDI_CHILDREN;
#ifdef SET_SCOPE_ICONS
m_pScopeItem->mask |= SDI_IMAGE | SDI_OPENIMAGE;
if (m_fRSOP && m_fRSOPPolicyFailed)
{
m_pScopeItem->nImage = IMG_CLOSED_FAILED;
m_pScopeItem->nOpenImage = IMG_OPEN_FAILED;
}
else
{
m_pScopeItem->nImage = IMG_CLOSEDBOX;
m_pScopeItem->nOpenImage = IMG_OPENBOX;
}
#endif
m_pScopeItem->relativeID = pParent;
m_pScopeItem->displayname = (unsigned short *)-1;
m_pScopeItem->lParam = -1; // made up cookie for my main folder
m_pScope->InsertItem(m_pScopeItem);
}
if (m_pIClassAdmin)
{
// if there's no IClassAdmin then there's nothing to enumerate
set <CResultPane *>::iterator i;
for (i = m_sResultPane.begin(); i != m_sResultPane.end(); i++)
{
(*i)->EnumerateResultPane(cookie);
}
}
}
STDMETHODIMP CScopePane::GetSnapinDescription(LPOLESTR * lpDescription)
{
OLESAFE_COPYSTRING(*lpDescription, L"description");
return S_OK;
}
STDMETHODIMP CScopePane::GetProvider(LPOLESTR * lpName)
{
OLESAFE_COPYSTRING(*lpName, L"provider");
return S_OK;
}
STDMETHODIMP CScopePane::GetSnapinVersion(LPOLESTR * lpVersion)
{
OLESAFE_COPYSTRING(*lpVersion, L"version");
return S_OK;
}
STDMETHODIMP CScopePane::GetSnapinImage(HICON * hAppIcon)
{
return E_NOTIMPL;
}
STDMETHODIMP CScopePane::GetStaticFolderImage(HBITMAP * hSmallImage,
HBITMAP * hSmallImageOpen,
HBITMAP * hLargeImage,
COLORREF * cMask)
{
return E_NOTIMPL;
}
STDMETHODIMP CScopePane::GetHelpTopic(LPOLESTR *lpCompiledHelpFile)
{
LPOLESTR lpHelpFile;
lpHelpFile = (LPOLESTR) CoTaskMemAlloc (MAX_PATH * sizeof(WCHAR));
if (!lpHelpFile)
{
DebugMsg((DM_WARNING, TEXT("CScopePane::GetHelpTopic: Failed to allocate memory.")));
return E_OUTOFMEMORY;
}
if (m_fRSOP)
{
ExpandEnvironmentStringsW (L"%SystemRoot%\\Help\\RSOP.chm::/RSPintro.htm",
lpHelpFile, MAX_PATH);
}
else
{
ExpandEnvironmentStringsW (L"%SystemRoot%\\Help\\SPConcepts.chm::/ADE.htm",
lpHelpFile, MAX_PATH);
}
*lpCompiledHelpFile = lpHelpFile;
return S_OK;
}
void CScopePane::DeleteList()
{
return;
}
STDMETHODIMP CScopePane::GetDisplayInfo(SCOPEDATAITEM* pScopeDataItem)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
ASSERT(pScopeDataItem != NULL);
if (pScopeDataItem == NULL)
return E_POINTER;
if (pScopeDataItem->lParam == -1)
{
m_szFolderTitle.LoadString(IDS_FOLDER_TITLE);
pScopeDataItem->displayname = (unsigned short *)((LPCOLESTR)m_szFolderTitle);
}
else
{
ASSERT(pScopeDataItem->mask == TVIF_TEXT);
pScopeDataItem->displayname = (unsigned short *)((LPCOLESTR)m_AppData[pScopeDataItem->lParam].m_pDetails->pszPackageName);
}
ASSERT(pScopeDataItem->displayname != NULL);
return S_OK;
}
STDMETHODIMP CScopePane::CompareObjects(LPDATAOBJECT lpDataObjectA, LPDATAOBJECT lpDataObjectB)
{
if (lpDataObjectA == NULL || lpDataObjectB == NULL)
return E_POINTER;
// Make sure both data object are mine
INTERNAL* pA;
INTERNAL* pB;
HRESULT hr = S_FALSE;
pA = ExtractInternalFormat(lpDataObjectA);
pB = ExtractInternalFormat(lpDataObjectB);
if (pA != NULL && pB != NULL)
hr = ((pA->m_type == pB->m_type) && (pA->m_cookie == pB->m_cookie)) ? S_OK : S_FALSE;
FREE_INTERNAL(pA);
FREE_INTERNAL(pB);
return hr;
}
// Scope item property pages:
STDMETHODIMP CScopePane::CreatePropertyPages(LPPROPERTYSHEETCALLBACK lpProvider,
LONG_PTR handle,
LPDATAOBJECT lpIDataObject)
{
HRESULT hr;
AFX_MANAGE_STATE(AfxGetStaticModuleState());
INTERNAL* pInternal = ExtractInternalFormat(lpIDataObject);
if (!pInternal)
{
return E_UNEXPECTED;
}
MMC_COOKIE cookie = pInternal->m_cookie;
FREE_INTERNAL(pInternal);
//
// make sure we have an up-to-date categories list
//
ClearCategories();
if (m_fRSOP)
{
GetRSoPCategories();
}
else
{
hr = CsGetAppCategories(&m_CatList);
if (FAILED(hr))
{
// report it
LogADEEvent(EVENTLOG_ERROR_TYPE, EVENT_ADE_GETCATEGORIES_ERROR, hr, NULL);
// Since failure only means the categories list will be
// empty, we'll proceed as if nothing happened.
hr = S_OK;
}
}
//
// Create the ToolDefs property page
//
m_pToolDefs = new CToolDefs();
m_pToolDefs->m_ppThis = &m_pToolDefs;
m_pToolDefs->m_pToolDefaults = & m_ToolDefaults;
m_pToolDefs->m_cookie = cookie;
m_pToolDefs->m_hConsoleHandle = handle;
m_pToolDefs->m_fMachine = m_fMachine;
hr = SetPropPageToDeleteOnClose(&m_pToolDefs->m_psp);
if (SUCCEEDED(hr))
{
HPROPSHEETPAGE hToolDefs = CreateThemedPropertySheetPage(&m_pToolDefs->m_psp);
if (hToolDefs == NULL)
return E_UNEXPECTED;
lpProvider->AddPage(hToolDefs);
}
//
// Create the ToolAdvDefs property page
//
m_pToolAdvDefs = new CToolAdvDefs();
m_pToolAdvDefs->m_ppThis = &m_pToolAdvDefs;
m_pToolAdvDefs->m_pToolDefaults = & m_ToolDefaults;
m_pToolAdvDefs->m_cookie = cookie;
m_pToolAdvDefs->m_hConsoleHandle = handle;
m_pToolAdvDefs->m_fMachine = m_fMachine;
hr = SetPropPageToDeleteOnClose(&m_pToolAdvDefs->m_psp);
if (SUCCEEDED(hr))
{
HPROPSHEETPAGE hToolAdvDefs = CreateThemedPropertySheetPage(&m_pToolAdvDefs->m_psp);
if (hToolAdvDefs == NULL)
return E_UNEXPECTED;
lpProvider->AddPage(hToolAdvDefs);
}
CString szCSPath;
hr = GetClassStoreName(szCSPath, FALSE);
if (SUCCEEDED(hr) && m_pIClassAdmin)
{
//
// Create the FileExt property page
//
m_pFileExt = new CFileExt();
m_pFileExt->m_ppThis = &m_pFileExt;
m_pFileExt->m_pScopePane = this;
// no longer need to marshal this, just set it
m_pFileExt->m_pIClassAdmin = m_pIClassAdmin;
m_pIClassAdmin->AddRef();
hr = SetPropPageToDeleteOnClose(&m_pFileExt->m_psp);
if (SUCCEEDED(hr))
{
HPROPSHEETPAGE hFileExt = CreateThemedPropertySheetPage(&m_pFileExt->m_psp);
if (hFileExt == NULL)
return E_UNEXPECTED;
lpProvider->AddPage(hFileExt);
}
}
else
{
//
// Create the FileExt property page without an IClassAdmin
//
m_pFileExt = new CFileExt();
m_pFileExt->m_ppThis = &m_pFileExt;
m_pFileExt->m_pScopePane = this;
hr = SetPropPageToDeleteOnClose(&m_pFileExt->m_psp);
if (SUCCEEDED(hr))
{
HPROPSHEETPAGE hFileExt = CreateThemedPropertySheetPage(&m_pFileExt->m_psp);
if (hFileExt == NULL)
return E_UNEXPECTED;
lpProvider->AddPage(hFileExt);
}
}
//
// Create the CatList property page
//
m_pCatList = new CCatList();
m_pCatList->m_szDomainName = m_szDomainName;
m_pCatList->m_ppThis = &m_pCatList;
m_pCatList->m_pScopePane = this;
m_pCatList->m_fRSOP = m_fRSOP;
hr = SetPropPageToDeleteOnClose(&m_pCatList->m_psp);
if (SUCCEEDED(hr))
{
HPROPSHEETPAGE hCatList = CreateThemedPropertySheetPage(&m_pCatList->m_psp);
if (hCatList == NULL)
return E_UNEXPECTED;
lpProvider->AddPage(hCatList);
}
#ifdef DIGITAL_SIGNATURES
//
// Create the Digital Signatures property page
//
m_pSignatures = new CSignatures();
m_pSignatures->m_ppThis = &m_pSignatures;
m_pSignatures->m_pScopePane = this;
m_pSignatures->m_fRSOP = m_fRSOP;
m_pSignatures->m_pIGPEInformation = m_pIGPEInformation;
hr = SetPropPageToDeleteOnClose(&m_pSignatures->m_psp);
if (SUCCEEDED(hr))
{
HPROPSHEETPAGE hSignatures = CreateThemedPropertySheetPage(&m_pSignatures->m_psp);
if (hSignatures == NULL)
return E_UNEXPECTED;
lpProvider->AddPage(hSignatures);
}
#endif // DIGITAL_SIGNATURES
return S_OK;
}
// Scope item property pages:
STDMETHODIMP CScopePane::QueryPagesFor(LPDATAOBJECT lpDataObject)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
// Look at the data object and see if it an item that we want to have a property sheet
INTERNAL* pInternal = ExtractInternalFormat(lpDataObject);
if (pInternal)
{
// The main Software Installation node only has a property sheet if
// we are not in RSOP mode.
if ((m_fRSOP != TRUE) && (CCT_SCOPE == pInternal->m_type))
{
FREE_INTERNAL(pInternal);
return S_OK;
}
FREE_INTERNAL(pInternal);
}
return S_FALSE;
}
BOOL CScopePane::IsScopePaneNode(LPDATAOBJECT lpDataObject)
{
BOOL bResult = FALSE;
INTERNAL* pInternal = ExtractInternalFormat(lpDataObject);
if (pInternal)
{
if (pInternal->m_type == CCT_SCOPE)
bResult = TRUE;
FREE_INTERNAL(pInternal);
}
return bResult;
}
///////////////////////////////////////////////////////////////////////////////
// IExtendContextMenu implementation
//
STDMETHODIMP CScopePane::AddMenuItems(LPDATAOBJECT pDataObject,
LPCONTEXTMENUCALLBACK pContextMenuCallback,
LONG * pInsertionAllowed)
{
HRESULT hr = S_OK;
INTERNAL* pInternal = ExtractInternalFormat(pDataObject);
if (!pInternal)
{
return E_UNEXPECTED;
}
CONTEXTMENUITEM menuitem;
WCHAR szName[256];
WCHAR szStatus[256];
menuitem.strName = szName;
menuitem.strStatusBarText = szStatus;
menuitem.fFlags = 0;
menuitem.fSpecialFlags = 0;
do {
if ((m_fRSOP != TRUE) && ((*pInsertionAllowed) & CCM_INSERTIONALLOWED_NEW))
{
//
// Add Application menu item
//
::LoadString(ghInstance, IDM_ADD_APP, szName, 256);
::LoadString(ghInstance, IDS_ADD_APP_DESC, szStatus, 256);
menuitem.lCommandID = IDM_ADD_APP;
menuitem.lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_NEW;
hr = pContextMenuCallback->AddItem(&menuitem);
if (FAILED(hr))
break;
}
if ((m_fRSOP == TRUE) && ((*pInsertionAllowed) & CCM_INSERTIONALLOWED_VIEW))
{
menuitem.lCommandID = 0;
menuitem.fFlags = MFT_SEPARATOR;
menuitem.lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_VIEW;
menuitem.fSpecialFlags = CCM_SPECIAL_SEPARATOR;
hr = pContextMenuCallback->AddItem(&menuitem);
if (FAILED(hr))
break;
::LoadString(ghInstance, IDM_WINNER, szName, 256);
::LoadString(ghInstance, IDS_WINNER_DESC, szStatus, 256);
menuitem.lCommandID = IDM_WINNER;
menuitem.fFlags = menuitem.lCommandID == m_iViewState ? MFS_CHECKED | MFT_RADIOCHECK : 0;
menuitem.fSpecialFlags = 0;
hr = pContextMenuCallback->AddItem(&menuitem);
if (FAILED(hr))
break;
if ((m_dwRSOPFlags & RSOP_INFO_FLAG_DIAGNOSTIC_MODE) == RSOP_INFO_FLAG_DIAGNOSTIC_MODE)
{
// removed packages should only apply when I'm in diagnostic mode
::LoadString(ghInstance, IDM_REMOVED, szName, 256);
::LoadString(ghInstance, IDS_REMOVED_DESC, szStatus, 256);
menuitem.lCommandID = IDM_REMOVED;
menuitem.fFlags = menuitem.lCommandID == m_iViewState ? MFS_CHECKED | MFT_RADIOCHECK : 0;
hr = pContextMenuCallback->AddItem(&menuitem);
if (FAILED(hr))
break;
}
if (!m_fMachine)
{
::LoadString(ghInstance, IDM_ARP, szName, 256);
::LoadString(ghInstance, IDS_ARP_DESC, szStatus, 256);
menuitem.lCommandID = IDM_ARP;
menuitem.fFlags = menuitem.lCommandID == m_iViewState ? MFS_CHECKED | MFT_RADIOCHECK : 0;
hr = pContextMenuCallback->AddItem(&menuitem);
if (FAILED(hr))
break;
}
}
//
// Update & Remove application if this is a result pane item
//
if (pInternal->m_type == CCT_RESULT)
{
CAppData & data = m_AppData[pInternal->m_cookie];
DWORD dwFlags = data.m_pDetails->pInstallInfo->dwActFlags;
if ((m_fRSOP != TRUE) && ((*pInsertionAllowed) & CCM_INSERTIONALLOWED_TOP))
{
::LoadString(ghInstance, IDM_AUTOINST, szName, 256);
::LoadString(ghInstance, IDS_AUTOINST_DESC, szStatus, 256);
menuitem.lCommandID = IDM_AUTOINST;
menuitem.lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_TOP;
// only enable for published apps
if (dwFlags & ACTFLG_Published)
menuitem.fFlags = 0;
else
menuitem.fFlags = MFS_DISABLED;
if (dwFlags & ACTFLG_OnDemandInstall)
menuitem.fFlags += MFS_CHECKED;
hr = pContextMenuCallback->AddItem(&menuitem);
if (FAILED(hr))
break;
::LoadString(ghInstance, IDM_ASSIGN, szName, 256);
::LoadString(ghInstance, IDS_ASSIGN_DESC, szStatus, 256);
menuitem.lCommandID = IDM_ASSIGN;
if ((dwFlags & ACTFLG_Assigned) || (data.m_pDetails->pInstallInfo->PathType == SetupNamePath))
menuitem.fFlags = MFS_DISABLED;
else
menuitem.fFlags = 0;
hr = pContextMenuCallback->AddItem(&menuitem);
if (FAILED(hr))
break;
::LoadString(ghInstance, IDM_PUBLISH, szName, 256);
::LoadString(ghInstance, IDS_PUBLISH_DESC, szStatus, 256);
menuitem.lCommandID = IDM_PUBLISH;
if ((dwFlags & ACTFLG_Published) || m_fMachine)
menuitem.fFlags = MFS_DISABLED;
else
menuitem.fFlags = 0;
hr = pContextMenuCallback->AddItem(&menuitem);
if (FAILED(hr))
break;
#if 0
::LoadString(ghInstance, IDM_DISABLE, szName, 256);
::LoadString(ghInstance, IDS_DISABLE_DESC, szStatus, 256);
if (dwFlags & (ACTFLG_Published | ACTFLG_Assigned))
menuitem.fFlags = 0;
else
menuitem.fFlags = MFS_DISABLED;
menuitem.lCommandID = IDM_DISABLE;
hr = pContextMenuCallback->AddItem(&menuitem);
if (FAILED(hr))
break;
#endif
menuitem.lCommandID = 0;
menuitem.fFlags = MFT_SEPARATOR;
menuitem.fSpecialFlags = CCM_SPECIAL_SEPARATOR;
hr = pContextMenuCallback->AddItem(&menuitem);
if (FAILED(hr))
break;
}
if ((m_fRSOP != TRUE) && ((*pInsertionAllowed) & CCM_INSERTIONALLOWED_TASK))
{
::LoadString(ghInstance, IDM_ASSIGN, szName, 256);
::LoadString(ghInstance, IDS_ASSIGN_DESC, szStatus, 256);
menuitem.lCommandID = IDM_ASSIGN_T;
menuitem.fSpecialFlags = 0;
if ((dwFlags & ACTFLG_Assigned) || (data.m_pDetails->pInstallInfo->PathType == SetupNamePath))
menuitem.fFlags = MFS_DISABLED;
else
menuitem.fFlags = 0;
menuitem.lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_TASK;
hr = pContextMenuCallback->AddItem(&menuitem);
if (FAILED(hr))
break;
::LoadString(ghInstance, IDM_PUBLISH, szName, 256);
::LoadString(ghInstance, IDS_PUBLISH_DESC, szStatus, 256);
menuitem.lCommandID = IDM_PUBLISH_T;
if ((dwFlags & ACTFLG_Published) || m_fMachine)
menuitem.fFlags = MFS_DISABLED;
else
menuitem.fFlags = 0;
hr = pContextMenuCallback->AddItem(&menuitem);
if (FAILED(hr))
break;
#if 0
::LoadString(ghInstance, IDM_DISABLE, szName, 256);
::LoadString(ghInstance, IDS_DISABLE_DESC, szStatus, 256);
menuitem.lCommandID = IDM_DISABLE_T;
if (dwFlags & (ACTFLG_Published | ACTFLG_Assigned))
menuitem.fFlags = 0;
else
menuitem.fFlags = MFS_DISABLED;
hr = pContextMenuCallback->AddItem(&menuitem);
if (FAILED(hr))
break;
#endif
menuitem.lCommandID = 0;
menuitem.fFlags = MFT_SEPARATOR;
menuitem.fSpecialFlags = CCM_SPECIAL_SEPARATOR;
hr = pContextMenuCallback->AddItem(&menuitem);
if (FAILED(hr))
break;
::LoadString(ghInstance, IDM_DEL_APP, szName, 256);
::LoadString(ghInstance, IDS_DEL_APP_DESC, szStatus, 256);
menuitem.lCommandID = IDM_DEL_APP;
menuitem.fFlags = 0;
menuitem.fSpecialFlags = 0;
hr = pContextMenuCallback->AddItem(&menuitem);
if (FAILED(hr))
break;
::LoadString(ghInstance, IDM_REDEPLOY, szName, 256);
::LoadString(ghInstance, IDS_REDEPLOY_DESC, szStatus, 256);
menuitem.lCommandID = IDM_REDEPLOY;
if (data.m_pDetails->pInstallInfo->PathType == SetupNamePath)
menuitem.fFlags = MFS_DISABLED;
else
menuitem.fFlags = 0;
hr = pContextMenuCallback->AddItem(&menuitem);
if (FAILED(hr))
break;
menuitem.lCommandID = 0;
menuitem.fFlags = MFT_SEPARATOR;
menuitem.fSpecialFlags = CCM_SPECIAL_SEPARATOR;
hr = pContextMenuCallback->AddItem(&menuitem);
if (FAILED(hr))
break;
}
}
} while (FALSE);
FREE_INTERNAL(pInternal);
return hr;
}
HRESULT CScopePane::GetRSoPCategories(void)
{
HRESULT hr = S_OK;
list <APPCATEGORYINFO> CatList;
IWbemLocator * pLocator = NULL;
IWbemServices * pNamespace = NULL;
IWbemClassObject * pObj = NULL;
IEnumWbemClassObject * pEnum = NULL;
BSTR strQueryLanguage = SysAllocString(TEXT("WQL"));
BSTR strQueryCategories = SysAllocString(TEXT("SELECT * FROM RSOP_ApplicationManagementCategory"));
BSTR strNamespace = SysAllocString(m_szRSOPNamespace);
ULONG n = 0;
hr = CoCreateInstance(CLSID_WbemLocator,
0,
CLSCTX_INPROC_SERVER,
IID_IWbemLocator,
(LPVOID *) & pLocator);
DebugReportFailure(hr, (DM_WARNING, L"GetRSoPCategories: CoCreateInstance failed with 0x%x", hr));
if (FAILED(hr))
{
goto cleanup;
}
hr = pLocator->ConnectServer(strNamespace,
NULL,
NULL,
NULL,
0,
NULL,
NULL,
&pNamespace);
DebugReportFailure(hr, (DM_WARNING, L"GetRSoPCategories: pLocator->ConnectServer failed with 0x%x", hr));
if (FAILED(hr))
{
goto cleanup;
}
// First perform the query to get the list of categories
// erase any existing list
ClearCategories();
// create a new one
hr = pNamespace->ExecQuery(strQueryLanguage,
strQueryCategories,
WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY,
NULL,
&pEnum);
DebugReportFailure(hr, (DM_WARNING, L"GetRSoPCategories: pNamespace->ExecQuery failed with 0x%x", hr));
if (FAILED(hr))
{
goto cleanup;
}
do
{
hr = pEnum->Next(WBEM_INFINITE, 1, &pObj, &n);
if (FAILED(hr))
{
goto cleanup;
}
if (n > 0)
{
APPCATEGORYINFO ci;
memset(&ci, 0, sizeof(APPCATEGORYINFO));
ci.Locale = 0;
hr = GetParameter(pObj,
TEXT("CategoryId"),
ci.AppCategoryId);
DebugReportFailure(hr, (DM_WARNING, L"GetRSoPCategories: GetParameter(\"CategoryId\") failed with 0x%x", hr));
hr = GetParameter(pObj,
TEXT("Name"),
ci.pszDescription);
DebugReportFailure(hr, (DM_WARNING, L"GetRSoPCategories: GetParameter(\"Name\") failed with 0x%x", hr));
CatList.push_back(ci);
}
} while (n > 0);
// put the list of categories into the proper format so it matches
// what we would get from the class store
n = CatList.size();
if (n > 0)
{
m_CatList.pCategoryInfo =
(APPCATEGORYINFO *)OLEALLOC(sizeof(APPCATEGORYINFO) * n);
if (m_CatList.pCategoryInfo)
{
m_CatList.cCategory = n;
while (n--)
{
m_CatList.pCategoryInfo[n] = *CatList.begin();
CatList.erase(CatList.begin());
}
}
}
cleanup:
SysFreeString(strQueryLanguage);
SysFreeString(strQueryCategories);
SysFreeString(strNamespace);
if (pObj)
{
pObj->Release();
}
if (pEnum)
{
pEnum->Release();
}
if (pNamespace)
{
pNamespace->Release();
}
if (pLocator)
{
pLocator->Release();
}
return hr;
}
HRESULT CScopePane::InitializeADE()
{
HRESULT hr = S_OK;
if ((!m_fRSOP) && (!m_pIClassAdmin))
{
// make sure directories are created:
CreateNestedDirectory ((LPOLESTR)((LPCOLESTR)m_szGPT_Path), NULL);
// try and get IClassAdmin
hr = GetClassStore(FALSE);
}
return hr;
}
void CScopePane::Refresh()
{
if (m_fRSOP || ((!m_fBlockAddPackage) && (m_pIClassAdmin)))
{
map <MMC_COOKIE, CAppData>::iterator i;
set <CResultPane *>::iterator i2;
for (i2 = m_sResultPane.begin(); i2 != m_sResultPane.end(); i2++)
{
(*i2)->m_pResult->DeleteAllRsltItems();
}
for (i=m_AppData.begin(); i != m_AppData.end(); i++)
{
// if (i->second.m_fVisible)
// {
// }
OLESAFE_DELETE(i->second.m_psd);
FreePackageDetail(i->second.m_pDetails);
}
m_AppData.erase(m_AppData.begin(), m_AppData.end());
m_UpgradeIndex.erase(m_UpgradeIndex.begin(), m_UpgradeIndex.end());
m_Extensions.erase(m_Extensions.begin(), m_Extensions.end());
m_lLastAllocated = 0;
for (i2 = m_sResultPane.begin(); i2 != m_sResultPane.end(); i2++)
{
(*i2)->EnumerateResultPane(0);
}
}
}
STDMETHODIMP CScopePane::Command(long nCommandID, LPDATAOBJECT pDataObject)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
INTERNAL* pInternal = ExtractInternalFormat(pDataObject);
if (!pInternal)
{
return E_UNEXPECTED;
}
// Note - snap-ins need to look at the data object and determine
// in what context the command is being called.
// Handle each of the commands.
switch (nCommandID)
{
case IDM_AUTOINST:
if (pInternal->m_type == CCT_RESULT)
{
CAppData &data = m_AppData[pInternal->m_cookie];
DWORD dwNewFlags = data.m_pDetails->pInstallInfo->dwActFlags ^ ACTFLG_OnDemandInstall;
ChangePackageState(data, dwNewFlags, TRUE);
}
break;
case IDM_ASSIGN:
case IDM_ASSIGN_T:
if (pInternal->m_type == CCT_RESULT)
{
CAppData &data = m_AppData[pInternal->m_cookie];
DWORD dwNewFlags = data.m_pDetails->pInstallInfo->dwActFlags;
dwNewFlags &= ~(ACTFLG_Published);
dwNewFlags |= (ACTFLG_Assigned | ACTFLG_UserInstall | ACTFLG_OnDemandInstall);
ChangePackageState(data, dwNewFlags, TRUE);
}
break;
case IDM_PUBLISH:
case IDM_PUBLISH_T:
if (pInternal->m_type == CCT_RESULT)
{
CAppData &data = m_AppData[pInternal->m_cookie];
DWORD dwNewFlags = data.m_pDetails->pInstallInfo->dwActFlags;
dwNewFlags &= ~ACTFLG_Assigned;
dwNewFlags |= ACTFLG_Published | ACTFLG_UserInstall;
ChangePackageState(data, dwNewFlags, TRUE);
}
break;
case IDM_DISABLE:
case IDM_DISABLE_T:
if (pInternal->m_type == CCT_RESULT)
{
CAppData &data = m_AppData[pInternal->m_cookie];
DWORD dwNewFlags = data.m_pDetails->pInstallInfo->dwActFlags;
dwNewFlags &= ~(ACTFLG_OnDemandInstall | ACTFLG_Assigned | ACTFLG_UserInstall | ACTFLG_Published);
ChangePackageState(data, dwNewFlags, TRUE);
}
break;
case IDM_REDEPLOY:
{
CAppData &data = m_AppData[pInternal->m_cookie];
CString sz;
sz.LoadString(IDS_REDEPLOYWARNING);
int iReturn = IDNO;
m_pConsole->MessageBox( sz,
data.m_pDetails->pszPackageName,
MB_YESNO,
&iReturn);
if (IDYES == iReturn)
{
CHourglass hourglass;
//CString szScriptPath = data.m_pDetails->pInstallInfo->pszScriptPath;
CString szScriptPath = m_szGPT_Path;
DWORD dwRevision;
HRESULT hr = S_OK;
BOOL bStatus;
szScriptPath += L"\\temp.aas";
CString szTransformList = L"";
int i;
if (data.m_pDetails->cSources > 1)
{
CString szSource = data.m_pDetails->pszSourceList[0];
int nChars = 1 + szSource.ReverseFind(L'\\');
BOOL fTransformsAtSource = TRUE;
for (i = 1; i < data.m_pDetails->cSources && TRUE == fTransformsAtSource; i++)
{
if (0 == wcsncmp(szSource, data.m_pDetails->pszSourceList[i], nChars))
{
// make sure there isn't a sub-path
int n = nChars;
while (0 != data.m_pDetails->pszSourceList[i][n] && TRUE == fTransformsAtSource)
{
if (data.m_pDetails->pszSourceList[i][n] == L'\\')
{
fTransformsAtSource = FALSE;
}
n++;
}
}
else
{
fTransformsAtSource = FALSE;
}
}
if (fTransformsAtSource)
{
szTransformList = L"@";
}
else
{
szTransformList = L"|";
nChars = 0;
}
for (i = 1; i < data.m_pDetails->cSources; i++)
{
if (i > 1)
{
szTransformList += L";";
}
szTransformList += &data.m_pDetails->pszSourceList[i][nChars];
}
}
// disable MSI ui
MsiSetInternalUI(INSTALLUILEVEL_NONE, NULL);
// build the script file
DWORD dwPlatform;
if ( CAppData::Is64Bit( data.m_pDetails ) )
{
dwPlatform = MSIARCHITECTUREFLAGS_IA64;
}
else
{
dwPlatform = MSIARCHITECTUREFLAGS_X86;
}
UINT uMsiStatus = MsiAdvertiseProductEx(
data.m_pDetails->pszSourceList[0],
szScriptPath,
szTransformList,
LANGIDFROMLCID(data.m_pDetails->pPlatformInfo->prgLocale[0]),
dwPlatform,
0);
if (uMsiStatus)
{
DebugMsg((DM_WARNING, TEXT("MsiAdvertiseProduct failed with %u"), uMsiStatus));
hr = HRESULT_FROM_WIN32(uMsiStatus);
}
if (SUCCEEDED(hr))
{
dwRevision = data.m_pDetails->pInstallInfo->dwRevision + 1;
hr = m_pIClassAdmin->ChangePackageProperties(data.m_pDetails->pszPackageName,
NULL,
NULL,
NULL,
NULL,
NULL,
&dwRevision);
}
if (SUCCEEDED(hr))
{
// delete the old script
bStatus = DeleteFile(data.m_pDetails->pInstallInfo->pszScriptPath);
// rename the new one
if ( bStatus )
bStatus = MoveFile(szScriptPath, data.m_pDetails->pInstallInfo->pszScriptPath);
data.m_pDetails->pInstallInfo->dwRevision = dwRevision;
if ( bStatus )
{
if (FAILED(m_pIGPEInformation->PolicyChanged(m_fMachine, TRUE, &guidExtension,
m_fMachine ? &guidMachSnapin
: &guidUserSnapin)))
{
ReportPolicyChangedError(m_hwndMainWindow);
}
}
else
hr = HRESULT_FROM_WIN32(GetLastError());
}
if ( ! SUCCEEDED(hr) )
{
DebugMsg((DM_WARNING, TEXT("ChangePackageProperties failed with 0x%x"), hr));
// display failure message
sz.LoadString(IDS_REDEPLOYERROR);
m_pConsole->MessageBox(sz,
data.m_pDetails->pszPackageName,
MB_OK | MB_ICONEXCLAMATION, NULL);
}
}
}
break;
case IDM_ADD_APP:
{
if (!m_fBlockAddPackage)
{
m_fBlockAddPackage=TRUE;
CString szExtension;
CString szFilter;
szExtension.LoadString(IDS_DEF_EXTENSION);
if (m_fMachine)
{
szFilter.LoadString(IDS_EXTENSION_FILTER_M);
}
else
szFilter.LoadString(IDS_EXTENSION_FILTER);
OPENFILENAME ofn;
memset(&ofn, 0, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = GetActiveWindow();
ofn.hInstance = ghInstance;
TCHAR lpstrFilter[MAX_PATH];
wcsncpy(lpstrFilter, szFilter, MAX_PATH);
ofn.lpstrFilter = lpstrFilter;
TCHAR szFileTitle[MAX_PATH];
TCHAR szFile[MAX_PATH];
szFile[0] = NULL;
ofn.lpstrFile = szFile;
ofn.nMaxFile = MAX_PATH;
ofn.lpstrFileTitle = szFileTitle;
ofn.nMaxFileTitle = MAX_PATH;
ofn.lpstrInitialDir = m_ToolDefaults.szStartPath;
ofn.Flags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT | OFN_FILEMUSTEXIST | OFN_EXPLORER | OFN_ALLOWMULTISELECT;
ofn.lpstrDefExt = szExtension;
int iBreak = 0;
while (lpstrFilter[iBreak])
{
if (lpstrFilter[iBreak] == TEXT('|'))
{
lpstrFilter[iBreak] = 0;
}
iBreak++;
}
if (GetOpenFileName(&ofn))
{
CHourglass hourglass;
CString szPackagePath;
HRESULT hr = E_FAIL;
TCHAR szFile[MAX_PATH];
TCHAR * szNextFile = ofn.lpstrFile + ofn.nFileOffset;
TCHAR * szFileTitle = szFile + ofn.nFileOffset;
_tcscpy(szFile, ofn.lpstrFile);
if (0 == szFile[ofn.nFileOffset - 1])
{
// this is a list of files (not just one)
// need to put a slash here so it will work
szFile[ofn.nFileOffset - 1] = TEXT('\\');
}
TCHAR * szFileExtension;
// don't allow deployment over http or ftp
if (_wcsnicmp(ofn.lpstrFile, TEXT("http:"), 5) == 0
||
_wcsnicmp(ofn.lpstrFile, TEXT("ftp:"), 4) == 0)
{
CString sz;
sz.LoadString(IDS_ILLEGAL_PATH);
int iReturn = IDNO;
m_pConsole->MessageBox(sz, szPackagePath,
MB_OK | MB_ICONEXCLAMATION,
&iReturn);
goto skip_deployment;
}
// at this point I have a path and I have a list of file names
do
{
_tcscpy(szFileTitle, szNextFile);
hr = GetUNCPath (szFile, szPackagePath);
DebugMsg((DM_VERBOSE, TEXT("GetUNCPath(%s) returned %s"), szFile, szPackagePath));
if (FAILED(hr))
{
CString sz;
sz.LoadString(IDS_NO_UNIVERSAL_NAME);
int iReturn = IDNO;
m_pConsole->MessageBox(sz, szPackagePath,
MB_YESNO | MB_ICONEXCLAMATION,
&iReturn);
if (IDYES != iReturn)
{
goto skip_deployment;
}
}
szFileExtension = _tcsrchr(szFile, TEXT('.'));
if ((szFileExtension) &&
(0 == _wcsicmp(szFileExtension, L".zap")))
{
if (m_fMachine)
{
CString szText;
CString szTitle;
szText.LoadString(IDS_NO_ZAPS_ALLOWED);
// only allow ZAP files to be deployed to users
m_pConsole->MessageBox(
szText,
szTitle,
MB_OK | MB_ICONEXCLAMATION,
NULL);
hr = E_FAIL;
}
else
{
hr = AddZAPPackage(szPackagePath, szFileTitle);
}
}
else
{
hr = AddMSIPackage(szPackagePath, szFileTitle);
}
szNextFile += _tcslen(szNextFile) + 1;
} while (szNextFile[0]);
skip_deployment:
// Notify clients of change
if (SUCCEEDED(hr) && m_pIGPEInformation)
{
if (FAILED(m_pIGPEInformation->PolicyChanged(m_fMachine, TRUE, &guidExtension,
m_fMachine ? &guidMachSnapin
: &guidUserSnapin)))
{
ReportPolicyChangedError(m_hwndMainWindow);
}
}
}
m_fBlockAddPackage = FALSE;
}
else
{
// consider a message here
}
}
break;
case IDM_WINNER:
case IDM_REMOVED:
case IDM_FAILED:
case IDM_ARP:
m_iViewState = nCommandID;
{
// change toolbar state
set <CResultPane *>::iterator i;
for (i = m_sResultPane.begin(); i != m_sResultPane.end(); i++)
{
if ((*i)->m_pToolbar)
{
(*i)->m_pToolbar->SetButtonState(IDM_WINNER,
BUTTONPRESSED,
FALSE);
(*i)->m_pToolbar->SetButtonState(IDM_REMOVED,
BUTTONPRESSED,
FALSE);
(*i)->m_pToolbar->SetButtonState(IDM_ARP,
BUTTONPRESSED,
FALSE);
(*i)->m_pToolbar->SetButtonState(nCommandID,
BUTTONPRESSED,
TRUE);
}
}
}
// deliberately fall through to REFRESH
case IDM_REFRESH:
Refresh();
//
// In logging mode, we need to show a message box to the user
// in the case that ARP view is empty so that users are clear
// that this may be because ARP has not been run yet
//
if ( m_fRSOP &&
( IDM_ARP == nCommandID ) &&
( m_dwRSOPFlags & RSOP_INFO_FLAG_DIAGNOSTIC_MODE ) &&
! m_fDisplayedRsopARPWarning &&
( m_AppData.end() == m_AppData.begin() ) )
{
CString szTitle;
CString szText;
szTitle.LoadString(IDS_RSOP_ARP_WARNING_TITLE);
szText.LoadString(IDS_RSOP_ARP_WARNING);
int iReturn;
m_pConsole->MessageBox(szText,
szTitle,
MB_OK,
&iReturn);
m_fDisplayedRsopARPWarning = TRUE;
}
break;
case IDM_DEL_APP:
if (pInternal->m_type == CCT_RESULT)
{
CAppData & data = m_AppData[pInternal->m_cookie];
if ((data.m_pDetails->pInstallInfo->PathType == SetupNamePath))
{
// this is a legacy app it can't be uninstalled
CString szTitle;
CString szText;
szTitle.LoadString(IDS_REMOVE_LEGACY_TITLE);
szText.LoadString(IDS_REMOVE_LEGACY_TEXT);
int iReturn = IDNO;
m_pConsole->MessageBox(szText,
szTitle,
MB_YESNO,
&iReturn);
if (IDYES == iReturn)
{
RemovePackage(pInternal->m_cookie, FALSE, FALSE);
}
}
else
{
CRemove dlg;
// Activate the theme context in order to theme this dialog
CThemeContextActivator themer;
int iReturn = dlg.DoModal();
if (IDOK == iReturn)
{
switch (dlg.m_iState)
{
case 0:
RemovePackage(pInternal->m_cookie, TRUE, FALSE);
break;
case 1:
RemovePackage(pInternal->m_cookie, FALSE, FALSE);
break;
}
}
}
}
break;
default:
break;
}
return S_OK;
}
static PFNDSCREATEISECINFO pDSCreateISecurityInfoObject = NULL;
static HINSTANCE hInst_dssec = NULL;
STDAPI DSCreateISecurityInfoObject(LPCWSTR pwszObjectPath,
LPCWSTR pwszObjectClass,
DWORD dwFlags,
LPSECURITYINFO * ppSI,
PFNREADOBJECTSECURITY pfnReadSD,
PFNWRITEOBJECTSECURITY pfnWriteSD,
LPARAM lpContext)
{
if (NULL == pDSCreateISecurityInfoObject)
{
if (NULL == hInst_dssec)
{
hInst_dssec = LoadLibrary(L"dssec.dll");
if (NULL == hInst_dssec)
{
return E_UNEXPECTED;
}
}
pDSCreateISecurityInfoObject = (PFNDSCREATEISECINFO)
GetProcAddress(hInst_dssec, "DSCreateISecurityInfoObject");
if (NULL == pDSCreateISecurityInfoObject)
{
return E_UNEXPECTED;
}
}
return pDSCreateISecurityInfoObject(pwszObjectPath, pwszObjectClass, dwFlags, ppSI, pfnReadSD, pfnWriteSD, lpContext);
}
//+--------------------------------------------------------------------------
//
// Function: GetUNCPath
//
// Synopsis: This function takes in a driver based path and converts
// it to a UNC path
//
// Arguments:
// [in] [szPath] - The drive based path
// [out][szUNCPath] - The UNC path
//
// Returns:
// S_OK - If the function succeeds in obtaining a UNC path
// E_FAIL - If the function cannot obtain a UNC path
//
// History: 5/20/1998 RahulTh created
//
// Notes: If the function cannot obtain a UNC path, it simply copies szPath
// into szUNCPath on return.
//
//---------------------------------------------------------------------------
HRESULT GetUNCPath (LPCOLESTR szPath, CString& szUNCPath)
{
TCHAR* lpszUNCName;
UNIVERSAL_NAME_INFO * pUni;
ULONG cbSize;
HRESULT hr;
DWORD retVal;
szUNCPath.Empty(); //safety measure
lpszUNCName = new TCHAR[MAX_PATH];
pUni = (UNIVERSAL_NAME_INFO*) lpszUNCName;
cbSize = MAX_PATH * sizeof(TCHAR);
retVal = WNetGetUniversalName(szPath,
UNIVERSAL_NAME_INFO_LEVEL,
(LPVOID) pUni,
&cbSize);
if (ERROR_MORE_DATA == retVal) //if the buffer was not large enough
{
delete [] pUni;
pUni = (UNIVERSAL_NAME_INFO *) new BYTE [cbSize];
retVal = WNetGetUniversalName(szPath,
UNIVERSAL_NAME_INFO_LEVEL,
pUni,
&cbSize);
}
if (NO_ERROR == retVal)
{
szUNCPath = pUni->lpUniversalName;
hr = S_OK;
}
else
{
szUNCPath = szPath;
if (0 != wcsncmp(szPath, L"\\\\", 2))
hr = E_FAIL; //probably not a remote share.
else
hr = S_OK; //probably a remote share.
}
delete[] pUni;
return hr;
}
//+--------------------------------------------------------------------------
//
// Function: LogADEEvent
//
// Synopsis: logs an ADE event in the event log
//
// Arguments: [wType] - type of event
// [dwEventID] - event ID
// [hr] - HRESULT that triggered the event to be logged
// [szOptional] - additional descriptive text used by some events
//
// Returns: nothing
//
// Modifies: nothing
//
// History: 05-27-1999 stevebl Created
// 04-28-2000 stevebl Modified to allow more complex logging
//
// Notes: We attempt to use FormatMessage to craft a legible message
// but in the case that it fails, we just log the HRESULT.
//
//---------------------------------------------------------------------------
void LogADEEvent(WORD wType, DWORD dwEventID, HRESULT hr, LPCWSTR szOptional)
{
TCHAR szBuffer[256];
DWORD dw = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
hr,
0,
szBuffer,
sizeof(szBuffer) / sizeof(szBuffer[0]),
NULL);
if (0 == dw)
{
// FormatMessage failed.
// We'll have to come up with some sort of reasonable message.
wsprintf(szBuffer, TEXT("(HRESULT: 0x%lX)"), hr);
}
HANDLE hEventLog = OpenEventLog( NULL, ADE_EVENT_SOURCE );
if (hEventLog)
{
LPCWSTR rgsz[2];
rgsz[0] = szBuffer;
rgsz[1] = szOptional;
ReportEvent(hEventLog,
wType,
0,
dwEventID,
NULL,
NULL == szOptional ? 1 : 2,
sizeof(hr),
rgsz,
&hr);
CloseEventLog(hEventLog);
}
}
//+--------------------------------------------------------------------------
//
// Function: ReportGeneralPropertySheetError
//
// Synopsis: Pops up a message box indicating why changes to a property
// page could not be applies and logs the error in the event log.
//
// Arguments: [sz] - Title bar text
// [hr] - hresult of the error
//
// Returns: nothing
//
// History: 9-30-1998 stevebl Created
//
//---------------------------------------------------------------------------
void ReportGeneralPropertySheetError(HWND hwnd, LPCWSTR sz, HRESULT hr)
{
LogADEEvent(EVENTLOG_ERROR_TYPE, EVENT_ADE_GENERAL_ERROR, hr);
CString szMessage;
szMessage.LoadString(IDS_GENERALERROR);
MessageBox( hwnd,
szMessage,
sz,
MB_OK | MB_ICONEXCLAMATION);
}
void ReportPolicyChangedError(HWND hwnd)
{
CString szMessage;
szMessage.LoadString(IDS_ERRORPOLICYCHANGED);
MessageBox(hwnd,
szMessage,
NULL,
MB_OK | MB_ICONEXCLAMATION);
}
//+--------------------------------------------------------------------------
//
// Function: LoadHelpInfo
//
// Synopsis: routine that loads and locks the help mapping resources
//
// Arguments: [nIDD] - ID of the dialog making the help request
//
// Returns: handle to the locked and loaded mapping table
//
// History: 10-22-1998 stevebl Created
//
//---------------------------------------------------------------------------
LPDWORD LoadHelpInfo(UINT nIDD)
{
HRSRC hrsrc = FindResource(ghInstance, MAKEINTRESOURCE(nIDD),
MAKEINTRESOURCE(RT_HELPINFO));
if (hrsrc == NULL)
return NULL;
HGLOBAL hHelpInfo = LoadResource(ghInstance, hrsrc);
if (hHelpInfo == NULL)
return NULL;
LPDWORD lpdwHelpInfo = (LPDWORD)LockResource(hHelpInfo);
return lpdwHelpInfo;
}
#define RSOP_HELP_FILE TEXT("gpedit.hlp")
//+--------------------------------------------------------------------------
//
// Function: StandardHelp
//
// Synopsis: Standardized routine for bringing up context sensitive help.
//
// Arguments: [hWnd] - window that needs help
// [nIDD] - ID of the dialog making the request
// Notes:
//
//
// History: 10-22-1998 stevebl modified from the OLEDLG sources
//
//---------------------------------------------------------------------------
void WINAPI StandardHelp(HWND hWnd, UINT nIDD, BOOL fRsop /* = FALSE */ )
{
LPDWORD lpdwHelpInfo = LoadHelpInfo(nIDD);
if (lpdwHelpInfo == NULL)
{
DebugMsg((DL_VERBOSE, TEXT("Warning: unable to load help information (RT_HELPINFO)\n")));
return;
}
WinHelp(hWnd, fRsop ? RSOP_HELP_FILE : HELP_FILE, HELP_WM_HELP, (DWORD_PTR)lpdwHelpInfo);
}
//+--------------------------------------------------------------------------
//
// Function: StandardContextMenu
//
// Synopsis: Standardized routine for bringing up context menu based help.
//
// Arguments: [hWnd] -
// [nIDD] - ID of the dialog making the request
//
// History: 10-22-1998 stevebl modified from the OLEDLG sources
//
//---------------------------------------------------------------------------
void WINAPI StandardContextMenu(HWND hWnd, UINT nIDD, BOOL fRsop /* = FALSE */ )
{
LPDWORD lpdwHelpInfo = LoadHelpInfo(nIDD);
if (lpdwHelpInfo == NULL)
{
DebugMsg((DL_VERBOSE, TEXT("Warning: unable to load help information (RT_HELPINFO)\n")));
return;
}
WinHelp(hWnd, fRsop ? RSOP_HELP_FILE : HELP_FILE, HELP_CONTEXTMENU, (DWORD_PTR)lpdwHelpInfo);
}
//+--------------------------------------------------------------------------
//
// Function: CreateThemedPropertyPage
//
// Synopsis: Helper function to make sure that property pages put up
// by the snap-in are themed.
//
// Arguments:
//
// Returns:
//
// History: 4/20/2001 RahulTh created
//
// Notes:
//
//---------------------------------------------------------------------------
HPROPSHEETPAGE CreateThemedPropertySheetPage(AFX_OLDPROPSHEETPAGE* psp)
{
PROPSHEETPAGE_V3 sp_v3 = {0};
CopyMemory (&sp_v3, psp, psp->dwSize);
sp_v3.dwSize = sizeof(sp_v3);
return (::CreatePropertySheetPage (&sp_v3));
}
Reference in a new issue Copy permalink