1337 lines
40 KiB
C++
1337 lines
40 KiB
C++
//----------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 2001.
|
|
//
|
|
// File: spolitem.cpp
|
|
//
|
|
// Contents: WiF Policy Snapin
|
|
//
|
|
//
|
|
// History: TaroonM
|
|
// 10/30/01
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include "stdafx.h"
|
|
#include <htmlhelp.h>
|
|
|
|
#include "sprpage.h"
|
|
|
|
#include "new.h"
|
|
#include "genpage.h"
|
|
|
|
#ifdef WIZ97WIZARDS
|
|
#include "wiz97run.h"
|
|
#endif
|
|
|
|
|
|
|
|
const TCHAR c_szPolicyAgentServiceName[] = _T("PolicyAgent");
|
|
#define SERVICE_CONTROL_NEW_POLICY 129
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
#define celems(_x) (sizeof(_x) / sizeof(_x[0]))
|
|
|
|
DWORD
|
|
ComputePolicyDN(
|
|
LPWSTR pszDirDomainName,
|
|
GUID PolicyIdentifier,
|
|
LPWSTR pszPolicyDN
|
|
);
|
|
|
|
// Construction/destruction
|
|
CSecPolItem::CSecPolItem () :
|
|
m_pDisplayInfo( NULL ),
|
|
m_nResultSelected( -1 ),
|
|
m_bWiz97On( FALSE ),
|
|
m_bBlockDSDelete( FALSE ),
|
|
m_bItemSelected( FALSE )
|
|
{
|
|
m_pPolicy = NULL;
|
|
m_bNewPol = FALSE;
|
|
ZeroMemory( &m_ResultItem, sizeof( RESULTDATAITEM ) );
|
|
}
|
|
|
|
CSecPolItem::~CSecPolItem()
|
|
{
|
|
if (m_pDisplayInfo != NULL)
|
|
{
|
|
delete m_pDisplayInfo;
|
|
m_pDisplayInfo = NULL;
|
|
}
|
|
if (m_pPolicy)
|
|
{
|
|
FreeWirelessPolicyData(m_pPolicy);
|
|
}
|
|
};
|
|
|
|
void CSecPolItem::Initialize (WIRELESS_POLICY_DATA *pPolicy, CComponentDataImpl* pComponentDataImpl, CComponentImpl* pComponentImpl, BOOL bTemporaryDSObject)
|
|
{
|
|
PWIRELESS_POLICY_DATA pWirelessPolicyData = NULL;
|
|
HANDLE hLocalPolicyStore = NULL;
|
|
|
|
// call base class initialize
|
|
CSnapObject::Initialize( pComponentDataImpl, pComponentImpl, bTemporaryDSObject );
|
|
ZeroMemory( &m_ResultItem, sizeof( RESULTDATAITEM ) );
|
|
|
|
m_bNewPol = bTemporaryDSObject;
|
|
|
|
if (m_pPolicy)
|
|
{
|
|
FreeWirelessPolicyData(m_pPolicy);
|
|
}
|
|
|
|
m_pPolicy = pPolicy;
|
|
|
|
|
|
if (m_pPolicy) {
|
|
|
|
m_strName = pPolicy->pszWirelessName;
|
|
}
|
|
|
|
|
|
// Set default resultItem settings
|
|
GetResultItem()->mask = RDI_STR | RDI_IMAGE;
|
|
GetResultItem()->str = MMC_CALLBACK;
|
|
|
|
// Set the image. Active items get an image to indicate this state.
|
|
BOOL bEnabled = FALSE;
|
|
bEnabled = CheckForEnabled();
|
|
|
|
GetResultItem()->nImage = bEnabled ? ENABLEDSECPOLICY_IMAGE_IDX : SECPOLICY_IMAGE_IDX;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// handle IExtendContextMenu
|
|
STDMETHODIMP CSecPolItem::AddMenuItems
|
|
(
|
|
LPCONTEXTMENUCALLBACK pContextMenuCallback,
|
|
long *pInsertionAllowed
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
HRESULT hr = S_OK;
|
|
CONTEXTMENUITEM mItem;
|
|
LONG lCommandID;
|
|
|
|
// only add these menu items if we are pointed to the local machine
|
|
if ((m_pComponentDataImpl->EnumLocation()==LOCATION_REMOTE)
|
|
|| (m_pComponentDataImpl->EnumLocation()==LOCATION_LOCAL)
|
|
// extension snapin?
|
|
|| ((m_pComponentDataImpl->EnumLocation()==LOCATION_GLOBAL) && (NULL != m_pComponentDataImpl->GetStaticScopeObject()->GetExtScopeObject())))
|
|
{
|
|
// getthe active/inactive strings
|
|
CString strMenuText;
|
|
CString strMenuDescription;
|
|
|
|
/*
|
|
if (CheckForEnabled ())
|
|
{
|
|
strMenuText.LoadString (IDS_MENUTEXT_UNASSIGN);
|
|
strMenuDescription.LoadString (IDS_MENUDESCRIPTION_UNASSIGN);
|
|
lCommandID = IDM_UNASSIGN;
|
|
} else
|
|
{
|
|
strMenuText.LoadString (IDS_MENUTEXT_ASSIGN);
|
|
strMenuDescription.LoadString (IDS_MENUDESCRIPTION_ASSIGN);
|
|
lCommandID = IDM_ASSIGN;
|
|
}
|
|
|
|
|
|
// see if we can insert into the top
|
|
if (*pInsertionAllowed & CCM_INSERTIONALLOWED_TOP)
|
|
{
|
|
// set active/inactive
|
|
CONFIGUREITEM (mItem, strMenuText, strMenuDescription, lCommandID, CCM_INSERTIONPOINTID_PRIMARY_TOP, 0, 0);
|
|
hr = pContextMenuCallback->AddItem(&mItem);
|
|
ASSERT(hr == S_OK);
|
|
}
|
|
|
|
// see if we can insert into the tasks
|
|
if (*pInsertionAllowed & CCM_INSERTIONALLOWED_TASK)
|
|
{
|
|
// set active/inactive
|
|
CONFIGUREITEM (mItem, strMenuText, strMenuDescription, lCommandID, CCM_INSERTIONPOINTID_PRIMARY_TASK, 0, 0);
|
|
hr = pContextMenuCallback->AddItem(&mItem);
|
|
ASSERT(hr == S_OK);
|
|
}
|
|
*/
|
|
}
|
|
|
|
// we are done
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CSecPolItem::Command
|
|
(
|
|
long lCommandID,
|
|
IConsoleNameSpace* // not used for result items
|
|
)
|
|
{
|
|
|
|
WCHAR szMachinePath[256];
|
|
HRESULT hr = S_OK;
|
|
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
return CWirelessSnapInDataObjectImpl<CSecPolItem>::Command( lCommandID, (IConsoleNameSpace*)NULL );
|
|
|
|
// we handled it
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CSecPolItem::IsPolicyExist()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
PWIRELESS_POLICY_DATA pWirelessPolicyData = NULL;
|
|
HANDLE hPolicyStore = NULL;
|
|
PWIRELESS_PS_DATA * ppWirelessPSData = NULL;
|
|
DWORD dwNumPSObjects = 0;
|
|
|
|
hPolicyStore = m_pComponentDataImpl->GetPolicyStoreHandle();
|
|
pWirelessPolicyData = GetWirelessPolicy();
|
|
|
|
return hr;
|
|
}
|
|
|
|
// handle IExtendPropertySheet
|
|
STDMETHODIMP CSecPolItem::CreatePropertyPages
|
|
(
|
|
LPPROPERTYSHEETCALLBACK lpProvider,
|
|
LONG_PTR handle
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
HRESULT hr = S_OK;
|
|
ASSERT(lpProvider != NULL);
|
|
|
|
// save this notification handle
|
|
SetNotificationHandle (handle);
|
|
|
|
//check if the policy exists before pops up the property page
|
|
//may be deleted by some other instance, if so return FALSE, force the refresh
|
|
if ( !m_bNewPol )
|
|
{
|
|
hr = IsPolicyExist();
|
|
if ( FAILED(hr) )
|
|
{
|
|
ReportError(IDS_LOAD_ERROR, hr);
|
|
// trigger a refresh
|
|
m_pComponentDataImpl->GetConsole()->UpdateAllViews( this, 0,0 );
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
#ifdef WIZ97WIZARDS
|
|
if (m_bWiz97On)
|
|
{
|
|
// We only run the wizard in the case of a new object, if that changes we will need to
|
|
// verify we are doing an 'add' here
|
|
|
|
// IF the wizard wants to it will associate these two
|
|
|
|
PWIRELESS_PS_DATA pWirelessPSData = NULL;
|
|
|
|
ASSERT(GetWirelessPolicy());
|
|
ASSERT(GetWirelessPolicy()->ppWirelessPSData);
|
|
|
|
/*
|
|
pWirelessPSData = *GetWirelessPolicy()->ppWirelessPSData;
|
|
if (pWirelessPSData)
|
|
{
|
|
*/
|
|
HRESULT hr = CreateSecPolItemWiz97PropertyPages(dynamic_cast<CComObject<CSecPolItem>*>(this), pWirelessPSData, lpProvider);
|
|
// the wizard should have done an addref on the pWirelessPSData pointer we just passed into it, so
|
|
// it so we can feel free to releaseref now
|
|
/*
|
|
} else
|
|
{
|
|
// we don't want to save the notification handle after all
|
|
SetNotificationHandle (NULL);
|
|
hr = E_UNEXPECTED;
|
|
}
|
|
*/
|
|
|
|
return hr;
|
|
} else
|
|
{
|
|
#endif
|
|
|
|
CComPtr<CSecPolPropSheetManager> spPropshtManager =
|
|
new CComObject<CSecPolPropSheetManager>;
|
|
|
|
if (NULL == spPropshtManager.p)
|
|
{
|
|
ReportError(IDS_OPERATION_FAIL, E_OUTOFMEMORY);
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
// Create the property page(s); gets deleted when the window is destroyed
|
|
CGenPage* pGenPage = new CGenPage(IDD_WIRELESSGENPROP);
|
|
CSecPolRulesPage* pRulesPage = new CSecPolRulesPage();
|
|
if ((pRulesPage == NULL) || (pGenPage == NULL))
|
|
return E_UNEXPECTED;
|
|
|
|
// if the first page can't initialize this probably means that there was a problem
|
|
// talking to the DS, in which case we fail to bring up the propery pages and figure
|
|
// that a refresh will get us back to a valid state
|
|
hr = pGenPage->Initialize (dynamic_cast<CComObject<CSecPolItem>*>(this));
|
|
if (hr != S_OK)
|
|
{
|
|
// since we are not going to display the tab dialog we need to clean up
|
|
delete pGenPage;
|
|
delete pRulesPage;
|
|
|
|
// we don't want to save the notification handle after all
|
|
SetNotificationHandle (NULL);
|
|
|
|
// trigger a refresh
|
|
m_pComponentDataImpl->GetConsole()->UpdateAllViews( this, 0,0 );
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
// yes, we ignore the return value on these guys, since the only return value that
|
|
// can currently come back would have come back on the first guy anyway
|
|
pRulesPage->Initialize (dynamic_cast<CComObject<CSecPolItem>*>(this));
|
|
|
|
HPROPSHEETPAGE hGenPage = MyCreatePropertySheetPage(&(pGenPage->m_psp));
|
|
HPROPSHEETPAGE hRulesPage = MyCreatePropertySheetPage(&(pRulesPage->m_psp));
|
|
|
|
if ((hGenPage == NULL) || (hRulesPage == NULL))
|
|
{
|
|
// we don't want to save the notification handle after all
|
|
SetNotificationHandle (NULL);
|
|
return E_UNEXPECTED;
|
|
}
|
|
lpProvider->AddPage(hGenPage);
|
|
lpProvider->AddPage(hRulesPage);
|
|
|
|
|
|
spPropshtManager->Initialize(dynamic_cast<CComObject<CSecPolItem>*>(this));
|
|
spPropshtManager->AddPage(pRulesPage);
|
|
spPropshtManager->AddPage(pGenPage);
|
|
|
|
|
|
return S_OK;
|
|
|
|
#ifdef WIZ97WIZARDS
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
STDMETHODIMP CSecPolItem::QueryPagesFor( void )
|
|
{
|
|
// display our locations dialog via this
|
|
return S_OK;
|
|
}
|
|
|
|
// Destroy helper
|
|
STDMETHODIMP CSecPolItem::Destroy( void )
|
|
{
|
|
// just return success
|
|
return S_OK;
|
|
}
|
|
|
|
// handle IComponent and IComponentData
|
|
STDMETHODIMP CSecPolItem::Notify
|
|
(
|
|
MMC_NOTIFY_TYPE event,
|
|
LPARAM arg,
|
|
LPARAM param,
|
|
BOOL bComponentData, // TRUE when caller is IComponentData
|
|
IConsole *pConsole,
|
|
IHeaderCtrl *pHeader
|
|
)
|
|
{
|
|
#ifdef DO_TRACE
|
|
OPT_TRACE(_T("CSecPolItem::Notify this-%p "), this);
|
|
switch (event)
|
|
{
|
|
case MMCN_ACTIVATE:
|
|
OPT_TRACE(_T("MMCN_ACTIVATE\n"));
|
|
break;
|
|
case MMCN_ADD_IMAGES:
|
|
OPT_TRACE(_T("MMCN_ADD_IMAGES\n"));
|
|
break;
|
|
case MMCN_BTN_CLICK:
|
|
OPT_TRACE(_T("MMCN_BTN_CLICK\n"));
|
|
break;
|
|
case MMCN_CLICK:
|
|
OPT_TRACE(_T("MMCN_CLICK\n"));
|
|
break;
|
|
case MMCN_COLUMN_CLICK:
|
|
OPT_TRACE(_T("MMCN_COLUMN_CLICK\n"));
|
|
break;
|
|
case MMCN_CONTEXTMENU:
|
|
OPT_TRACE(_T("MMCN_CONTEXTMENU\n"));
|
|
break;
|
|
case MMCN_CUTORMOVE:
|
|
OPT_TRACE(_T("MMCN_CUTORMOVE\n"));
|
|
break;
|
|
case MMCN_DBLCLICK:
|
|
OPT_TRACE(_T("MMCN_DBLCLICK\n"));
|
|
break;
|
|
case MMCN_DELETE:
|
|
OPT_TRACE(_T("MMCN_DELETE\n"));
|
|
break;
|
|
case MMCN_DESELECT_ALL:
|
|
OPT_TRACE(_T("MMCN_DESELECT_ALL\n"));
|
|
break;
|
|
case MMCN_EXPAND:
|
|
OPT_TRACE(_T("MMCN_EXPAND\n"));
|
|
break;
|
|
case MMCN_HELP:
|
|
OPT_TRACE(_T("MMCN_HELP\n"));
|
|
break;
|
|
case MMCN_MENU_BTNCLICK:
|
|
OPT_TRACE(_T("MMCN_MENU_BTNCLICK\n"));
|
|
break;
|
|
case MMCN_MINIMIZED:
|
|
OPT_TRACE(_T("MMCN_MINIMIZED\n"));
|
|
break;
|
|
case MMCN_PASTE:
|
|
OPT_TRACE(_T("MMCN_PASTE\n"));
|
|
break;
|
|
case MMCN_PROPERTY_CHANGE:
|
|
OPT_TRACE(_T("MMCN_PROPERTY_CHANGE\n"));
|
|
break;
|
|
case MMCN_QUERY_PASTE:
|
|
OPT_TRACE(_T("MMCN_QUERY_PASTE\n"));
|
|
break;
|
|
case MMCN_REFRESH:
|
|
OPT_TRACE(_T("MMCN_REFRESH\n"));
|
|
break;
|
|
case MMCN_REMOVE_CHILDREN:
|
|
OPT_TRACE(_T("MMCN_REMOVE_CHILDREN\n"));
|
|
break;
|
|
case MMCN_RENAME:
|
|
OPT_TRACE(_T("MMCN_RENAME\n"));
|
|
break;
|
|
case MMCN_SELECT:
|
|
OPT_TRACE(_T("MMCN_SELECT\n"));
|
|
break;
|
|
case MMCN_SHOW:
|
|
OPT_TRACE(_T("MMCN_SHOW\n"));
|
|
break;
|
|
case MMCN_VIEW_CHANGE:
|
|
OPT_TRACE(_T("MMCN_VIEW_CHANGE\n"));
|
|
break;
|
|
case MMCN_SNAPINHELP:
|
|
OPT_TRACE(_T("MMCN_SNAPINHELP\n"));
|
|
break;
|
|
case MMCN_CONTEXTHELP:
|
|
OPT_TRACE(_T("MMCN_CONTEXTHELP\n"));
|
|
break;
|
|
case MMCN_INITOCX:
|
|
OPT_TRACE(_T("MMCN_INITOCX\n"));
|
|
break;
|
|
case MMCN_FILTER_CHANGE:
|
|
OPT_TRACE(_T("MMCN_FILTER_CHANGE\n"));
|
|
break;
|
|
default:
|
|
OPT_TRACE(_T("Unknown event\n"));
|
|
break;
|
|
}
|
|
#endif //#ifdef DO_TRACE
|
|
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
// if didn't handle something... then return FALSE
|
|
HRESULT hr = S_FALSE;
|
|
|
|
// handle the event
|
|
switch(event)
|
|
{
|
|
case MMCN_CONTEXTHELP:
|
|
{
|
|
CComQIPtr <IDisplayHelp, &IID_IDisplayHelp> pDisplayHelp ( pConsole );
|
|
ASSERT( pDisplayHelp != NULL );
|
|
if (pDisplayHelp)
|
|
{
|
|
// need to form a complete path to the .chm file
|
|
CString s, s2;
|
|
s.LoadString(IDS_HELPCONCEPTSFILE);
|
|
DWORD dw = ExpandEnvironmentStrings (s, s2.GetBuffer (512), 512);
|
|
s2.ReleaseBuffer (-1);
|
|
if ((dw == 0) || (dw > 512))
|
|
{
|
|
return E_UNEXPECTED;
|
|
}
|
|
pDisplayHelp->ShowTopic(s2.GetBuffer(512));
|
|
s2.ReleaseBuffer (-1);
|
|
hr = S_OK;
|
|
}
|
|
break;
|
|
}
|
|
case MMCN_SELECT:
|
|
{
|
|
// Obtain IConsoleVerb from console
|
|
CComPtr<IConsoleVerb> spVerb;
|
|
pConsole->QueryConsoleVerb( &spVerb );
|
|
|
|
m_bItemSelected = !!(HIWORD(arg));
|
|
|
|
// call object to set verb state
|
|
AdjustVerbState( (IConsoleVerb*)spVerb );
|
|
|
|
// Remember selected result item
|
|
CComQIPtr <IResultData, &IID_IResultData> spResult( pConsole );
|
|
if (spResult == NULL)
|
|
{
|
|
TRACE(_T("CComponentDataImpl::Notify QI for IResultData FAILED\n"));
|
|
break;
|
|
}
|
|
hr = OnSelect( arg, param, (IResultData*)spResult);
|
|
break;
|
|
}
|
|
case MMCN_PROPERTY_CHANGE:
|
|
{
|
|
// the object pointer should be in lParam
|
|
OnPropertyChange( param, pConsole );
|
|
// This message is received whenever the property sheet is dismissed.
|
|
// Now is a good time to make sure the result item which was originally
|
|
// selected remains so.
|
|
CComQIPtr <IResultData, &IID_IResultData> spResult( pConsole );
|
|
if (spResult == NULL)
|
|
{
|
|
TRACE(_T("CComponentDataImpl::Notify QI for IResultData FAILED\n"));
|
|
break;
|
|
}
|
|
SelectResult( (IResultData*)spResult );
|
|
break;
|
|
}
|
|
case MMCN_VIEW_CHANGE:
|
|
{
|
|
// Refresh the entire result pane if view has changed.
|
|
hr = pConsole->UpdateAllViews( m_pComponentDataImpl->GetStaticScopeObject(), 0, 0 );
|
|
break;
|
|
}
|
|
case MMCN_RENAME:
|
|
{
|
|
hr = OnRename( arg, param );
|
|
// even if the rename failed mmc will still display with the
|
|
// new name... thus we have to force a refresh in the failure case
|
|
if (hr != S_OK)
|
|
{
|
|
if (S_FALSE == hr)
|
|
{
|
|
CThemeContextActivator activator;
|
|
AfxMessageBox(IDS_ERROR_EMPTY_POL_NAME);
|
|
}
|
|
else
|
|
{
|
|
ReportError(IDS_SAVE_ERROR, hr);
|
|
hr = S_FALSE;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case MMCN_DELETE:
|
|
{
|
|
CThemeContextActivator activator;
|
|
|
|
// delete the item
|
|
if (AfxMessageBox (IDS_SUREYESNO, MB_YESNO | MB_DEFBUTTON2) == IDYES)
|
|
{
|
|
// turn on wait cursor
|
|
CWaitCursor waitCursor;
|
|
|
|
// Obtain IResultData
|
|
CComQIPtr <IResultData, &IID_IResultData> pResultData( pConsole );
|
|
ASSERT( pResultData != NULL );
|
|
|
|
// param is not used on MMCN_DELETE, replace it with IResultData*
|
|
hr = OnDelete( arg, (LPARAM)(IResultData*)pResultData );
|
|
|
|
if (hr != S_OK)
|
|
{
|
|
ReportError(IDS_SAVE_ERROR, hr);
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
}
|
|
else
|
|
hr = S_FALSE; // tell IComponent the delete wasn't done.
|
|
break;
|
|
}
|
|
// we didn't handle it... do default behaviour
|
|
case MMCN_DBLCLICK:
|
|
{
|
|
PWIRELESS_POLICY_DATA pWirelessPolicyData = NULL;
|
|
pWirelessPolicyData = GetWirelessPolicy();
|
|
break;
|
|
}
|
|
|
|
|
|
case MMCN_ACTIVATE:
|
|
case MMCN_MINIMIZED:
|
|
case MMCN_BTN_CLICK:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT GetGpoDisplayName(WCHAR *szGpoId, WCHAR *pszGpoName, DWORD dwSize )
|
|
{
|
|
LPGROUPPOLICYOBJECT pGPO = NULL; //Group Policy Object
|
|
HRESULT hr = S_OK; //result returned by functions
|
|
|
|
//
|
|
// Create an IGroupPolicyObject instance to work with
|
|
//
|
|
hr = CoCreateInstance(CLSID_GroupPolicyObject, NULL, CLSCTX_SERVER, IID_IGroupPolicyObject, (void **)&pGPO);
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
|
|
hr = pGPO->OpenDSGPO((LPOLESTR)szGpoId,GPO_OPEN_READ_ONLY);
|
|
if (FAILED(hr))
|
|
{
|
|
pGPO->Release();
|
|
return hr;
|
|
}
|
|
|
|
hr = pGPO->GetDisplayName( pszGpoName,
|
|
dwSize
|
|
);
|
|
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
pGPO->Release();
|
|
return hr;
|
|
}
|
|
|
|
pGPO->Release();
|
|
return hr;
|
|
}
|
|
|
|
|
|
// handle IComponent
|
|
STDMETHODIMP CSecPolItem::GetResultDisplayInfo( RESULTDATAITEM *pResultDataItem )
|
|
{
|
|
TCHAR *temp = NULL;
|
|
DWORD dwError = S_OK;
|
|
|
|
OPT_TRACE(_T("CSecPolItem::GetResultDisplayInfo this-%p\n"), this);
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
// are they looking for the image?
|
|
if (pResultDataItem->mask & RDI_IMAGE)
|
|
{
|
|
pResultDataItem->nImage = GetResultItem()->nImage;
|
|
OPT_TRACE(_T(" returning image[%i]\n"), GetResultItem()->nImage);
|
|
}
|
|
|
|
// are they looking for a string?
|
|
if (pResultDataItem->mask & RDI_STR)
|
|
{
|
|
if (GetWirelessPolicy() != NULL)
|
|
{
|
|
|
|
switch (pResultDataItem->nCol)
|
|
{
|
|
case COL_NAME:
|
|
{
|
|
|
|
CString str = m_pPolicy->pszWirelessName;
|
|
|
|
temp = (TCHAR*) realloc (m_pDisplayInfo, (str.GetLength()+1)*sizeof(TCHAR));
|
|
if (temp == NULL)
|
|
{
|
|
dwError = GetLastError();
|
|
} else
|
|
{
|
|
m_pDisplayInfo = temp;
|
|
lstrcpy (m_pDisplayInfo, str.GetBuffer(20));
|
|
}
|
|
pResultDataItem->str = m_pDisplayInfo;
|
|
OPT_TRACE(_T(" returning COL_NAME-%s\n"), m_pDisplayInfo);
|
|
}
|
|
break;
|
|
case COL_DESCRIPTION:
|
|
{
|
|
CString str = m_pPolicy->pszDescription;
|
|
temp = (TCHAR*) realloc (m_pDisplayInfo, (str.GetLength()+1)*sizeof(TCHAR));
|
|
if (temp == NULL)
|
|
{
|
|
dwError = GetLastError();
|
|
} else
|
|
{
|
|
m_pDisplayInfo = temp;
|
|
lstrcpy (m_pDisplayInfo, str.GetBuffer(20));
|
|
}
|
|
pResultDataItem->str = m_pDisplayInfo;
|
|
OPT_TRACE(_T(" returning COL_DESCRIPTION-%s\n"), m_pDisplayInfo);
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
if ( !m_pComponentDataImpl->IsRsop() )
|
|
{
|
|
switch( pResultDataItem->nCol )
|
|
{
|
|
|
|
case COL_LAST_MODIFIED:
|
|
{
|
|
CString strTime;
|
|
if(SUCCEEDED(FormatTime((time_t)m_pPolicy->dwWhenChanged, strTime)))
|
|
{
|
|
temp = (TCHAR*) realloc (m_pDisplayInfo, (strTime.GetLength()+1)*sizeof(TCHAR));
|
|
if (temp != NULL) {
|
|
m_pDisplayInfo = temp;
|
|
lstrcpy(m_pDisplayInfo, strTime);
|
|
} else
|
|
{
|
|
dwError = GetLastError();
|
|
}
|
|
pResultDataItem->str = m_pDisplayInfo;
|
|
OPT_TRACE(_T(" returning COL_ACTIVE-%s\n"), m_pDisplayInfo);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
// for debugging
|
|
ASSERT (0);
|
|
break;
|
|
} //inner switch
|
|
} //if ( !m_pComponentDataImpl->IsRsop() )
|
|
else
|
|
{
|
|
//rsop case
|
|
switch( pResultDataItem->nCol )
|
|
{
|
|
case COL_GPONAME:
|
|
if ( m_pPolicy->pRsopInfo )
|
|
{
|
|
WCHAR szGpoName[512];
|
|
CString strGpoId;
|
|
strGpoId.Format(_T("LDAP://%s"),m_pPolicy->pRsopInfo->pszGPOID);
|
|
HRESULT hr = GetGpoDisplayName( (WCHAR*)(LPCTSTR)strGpoId, szGpoName, 512 );
|
|
|
|
if (S_OK == hr )
|
|
{
|
|
INT iSize = (lstrlen(szGpoName) + 1) * sizeof(WCHAR);
|
|
temp = (TCHAR*) realloc (m_pDisplayInfo, iSize);
|
|
if (temp!= NULL)
|
|
{
|
|
m_pDisplayInfo = temp;
|
|
lstrcpy(m_pDisplayInfo, szGpoName);
|
|
} else
|
|
{
|
|
dwError = GetLastError();
|
|
}
|
|
pResultDataItem->str = m_pDisplayInfo;
|
|
OPT_TRACE(_T(" returning COL_ACTIVE-%s\n"), m_pDisplayInfo);
|
|
}
|
|
}
|
|
break;
|
|
case COL_PRECEDENCE:
|
|
if ( m_pPolicy->pRsopInfo )
|
|
{
|
|
const int cchMaxDigits = 33;
|
|
temp = (TCHAR*) realloc (m_pDisplayInfo, cchMaxDigits * sizeof(TCHAR));
|
|
if (temp!=NULL) {
|
|
m_pDisplayInfo = temp;
|
|
wsprintf(m_pDisplayInfo, _T("%d"),m_pPolicy->pRsopInfo->uiPrecedence);
|
|
} else
|
|
{
|
|
dwError = GetLastError();
|
|
}
|
|
pResultDataItem->str = m_pDisplayInfo;
|
|
OPT_TRACE(_T(" returning COL_ACTIVE-%s\n"), m_pDisplayInfo);
|
|
}
|
|
break;
|
|
case COL_OU:
|
|
if ( m_pPolicy->pRsopInfo )
|
|
{
|
|
INT iLen = (lstrlen(m_pPolicy->pRsopInfo->pszSOMID) + 1) *sizeof(TCHAR);
|
|
temp = (TCHAR*) realloc (m_pDisplayInfo, iLen);
|
|
if (temp!=NULL) {
|
|
m_pDisplayInfo = temp;
|
|
lstrcpy(m_pDisplayInfo, m_pPolicy->pRsopInfo->pszSOMID);
|
|
} else
|
|
{
|
|
dwError = GetLastError();
|
|
}
|
|
pResultDataItem->str = m_pDisplayInfo;
|
|
OPT_TRACE(_T(" returning COL_ACTIVE-%s\n"), m_pDisplayInfo);
|
|
}
|
|
break;
|
|
default:
|
|
// for debugging
|
|
ASSERT (0);
|
|
break;
|
|
}//inner switch
|
|
}
|
|
}//default case
|
|
} //outer switch
|
|
} //if (GetWirelessPolicy() != NULL)
|
|
|
|
|
|
else
|
|
{
|
|
CString str;
|
|
str.LoadString (IDS_COLUMN_INVALID);
|
|
temp = (TCHAR*) realloc (m_pDisplayInfo, (str.GetLength()+1)*sizeof(TCHAR));
|
|
if (temp == NULL)
|
|
{
|
|
dwError = GetLastError();
|
|
} else
|
|
{
|
|
m_pDisplayInfo = temp;
|
|
lstrcpy (m_pDisplayInfo, str.GetBuffer(20));
|
|
}
|
|
pResultDataItem->str = m_pDisplayInfo;
|
|
}
|
|
}
|
|
|
|
return HRESULT_FROM_WIN32(dwError);
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CAdvIpcfgDlg::FormatTime
|
|
//
|
|
// Purpose: convert time_t to a string.
|
|
//
|
|
// Returns: error code
|
|
//
|
|
// Note: _wasctime has some localization problems. So we do the formatting ourselves
|
|
HRESULT CSecPolItem::FormatTime(time_t t, CString & str)
|
|
{
|
|
time_t timeCurrent = time(NULL);
|
|
LONGLONG llTimeDiff = 0;
|
|
FILETIME ftCurrent = {0};
|
|
FILETIME ftLocal = {0};
|
|
SYSTEMTIME SysTime;
|
|
WCHAR szBuff[256] = {0};
|
|
|
|
|
|
str = L"";
|
|
|
|
GetSystemTimeAsFileTime(&ftCurrent);
|
|
|
|
llTimeDiff = (LONGLONG)t - (LONGLONG)timeCurrent;
|
|
|
|
llTimeDiff *= 10000000;
|
|
|
|
*((LONGLONG UNALIGNED64 *)&ftCurrent) += llTimeDiff;
|
|
|
|
if (!FileTimeToLocalFileTime(&ftCurrent, &ftLocal ))
|
|
{
|
|
return HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
if (!FileTimeToSystemTime( &ftLocal, &SysTime ))
|
|
{
|
|
return HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
if (0 == GetDateFormat(LOCALE_USER_DEFAULT,
|
|
0,
|
|
&SysTime,
|
|
NULL,
|
|
szBuff,
|
|
celems(szBuff)))
|
|
{
|
|
return HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
str = szBuff;
|
|
str += L" ";
|
|
|
|
ZeroMemory(szBuff, sizeof(szBuff));
|
|
if (0 == GetTimeFormat(LOCALE_USER_DEFAULT,
|
|
0,
|
|
&SysTime,
|
|
NULL,
|
|
szBuff,
|
|
celems(szBuff)))
|
|
{
|
|
return HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
str += szBuff;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
// IIWirelessSnapInData
|
|
STDMETHODIMP CSecPolItem::GetResultData( RESULTDATAITEM **ppResultDataItem )
|
|
{
|
|
ASSERT( NULL != ppResultDataItem );
|
|
ASSERT( NULL != GetResultItem() );
|
|
|
|
if (NULL == ppResultDataItem)
|
|
return E_INVALIDARG;
|
|
*ppResultDataItem = GetResultItem();
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CSecPolItem::GetGuidForCompare( GUID *pGuid )
|
|
{
|
|
ASSERT( NULL != pGuid );
|
|
if (NULL == pGuid)
|
|
return E_INVALIDARG;
|
|
CopyMemory( pGuid, &m_pPolicy->PolicyIdentifier, sizeof( GUID ) );
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CSecPolItem::AdjustVerbState (LPCONSOLEVERB pConsoleVerb)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// pass to base class
|
|
hr = CWirelessSnapInDataObjectImpl<CSecPolItem>::AdjustVerbState( pConsoleVerb );
|
|
ASSERT (hr == S_OK);
|
|
|
|
|
|
MMC_BUTTON_STATE buttonProperties = (m_bItemSelected) ? ENABLED : HIDDEN;
|
|
|
|
if ( m_pComponentDataImpl->IsRsop() )
|
|
{
|
|
PWIRELESS_POLICY_DATA pWirelessPolicyData = NULL;
|
|
pWirelessPolicyData = GetWirelessPolicy();
|
|
|
|
hr = pConsoleVerb->SetVerbState(MMC_VERB_PROPERTIES, buttonProperties, TRUE);
|
|
ASSERT (hr == S_OK);
|
|
}
|
|
else
|
|
{
|
|
hr = pConsoleVerb->SetVerbState(MMC_VERB_PROPERTIES, buttonProperties, TRUE);
|
|
ASSERT (hr == S_OK);
|
|
|
|
hr = pConsoleVerb->SetVerbState(MMC_VERB_RENAME, ENABLED, TRUE);
|
|
ASSERT (hr == S_OK);
|
|
|
|
hr = pConsoleVerb->SetVerbState(MMC_VERB_DELETE, ENABLED, TRUE);
|
|
ASSERT (hr == S_OK);
|
|
}
|
|
|
|
|
|
|
|
hr = pConsoleVerb->SetDefaultVerb(m_bItemSelected ?
|
|
MMC_VERB_PROPERTIES : MMC_VERB_NONE);
|
|
ASSERT (hr == S_OK);
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CSecPolItem::DoPropertyChangeHook( void )
|
|
{
|
|
return DisplaySecPolProperties( m_pPolicy->pszWirelessName, FALSE );
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
STDMETHODIMP CSecPolItem::DisplaySecPolProperties( CString strTitle, BOOL bWiz97On /*= TRUE*/ )
|
|
{
|
|
HRESULT hr;
|
|
|
|
// Add a ref for the prop sheet/wizard.
|
|
((CComObject <CSecPolItem>*)this)->AddRef();
|
|
|
|
// switch from the IComponentDataImpl to pUnk
|
|
LPUNKNOWN pUnk = m_pComponentDataImpl->GetUnknown();
|
|
|
|
// bring up the sheet
|
|
#ifdef WIZ97WIZARDS
|
|
if (bWiz97On)
|
|
{
|
|
// because we are creating a new one we need to turn on the wiz97 wizard
|
|
// unless it has been overridden
|
|
m_bWiz97On = bWiz97On;
|
|
|
|
hr = m_pComponentDataImpl->m_pPrshtProvider->CreatePropertySheet(
|
|
strTitle, FALSE, (LONG_PTR)this, (LPDATAOBJECT)this,
|
|
MMC_PSO_NOAPPLYNOW | MMC_PSO_NEWWIZARDTYPE );
|
|
} else
|
|
{
|
|
#endif
|
|
hr = m_pComponentDataImpl->m_pPrshtProvider->CreatePropertySheet(
|
|
strTitle, TRUE, (LONG_PTR)this, (LPDATAOBJECT)this,
|
|
MMC_PSO_NOAPPLYNOW );
|
|
|
|
#ifdef WIZ97WIZARDS
|
|
}
|
|
#endif
|
|
ASSERT (hr == S_OK);
|
|
|
|
// TODO: get the mmc team to fix this hack, we shouldn't need to do the FindWindow calls
|
|
// NOTE: if there are multiple MDI windows open this will fail
|
|
HWND hWnd = NULL;
|
|
|
|
// (nsun) As of 5/21/99, we no longer need to do this
|
|
// hr = m_pComponentDataImpl->GetConsole()->GetMainWindow(&hWnd);
|
|
// hWnd = ::FindWindowEx(hWnd, NULL, L"MDIClient", NULL);
|
|
// hWnd = ::FindWindowEx(hWnd, NULL, L"MMCChildFrm", NULL);
|
|
// hWnd = ::FindWindowEx(hWnd, NULL, L"MMCView", NULL);
|
|
// ASSERT(hWnd);
|
|
|
|
|
|
// TODO: need to check return value and call AddExtensionPages if it was successful
|
|
hr = m_pComponentDataImpl->m_pPrshtProvider->AddPrimaryPages (pUnk, TRUE, hWnd, TRUE);
|
|
ASSERT (hr == S_OK);
|
|
|
|
// m_dwRef should be at least 3; 2 from MMC, 1 from this function
|
|
((CComObject <CSecPolItem>*)this)->Release();
|
|
|
|
|
|
hr = m_pComponentDataImpl->GetConsole()->GetMainWindow(&hWnd);
|
|
ASSERT(hWnd);
|
|
|
|
// Show() returns 1 if wizard is cancelled, 0 if it finished
|
|
hr = m_pComponentDataImpl->m_pPrshtProvider->Show ((LONG_PTR)hWnd, 0);
|
|
|
|
#ifdef WIZ97WIZARDS
|
|
m_bWiz97On = FALSE;
|
|
#endif
|
|
|
|
// Pass prop sheet return code back to caller.
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CSecPolItem::OnDelete (LPARAM arg, LPARAM param) // param == IResultData*
|
|
{
|
|
HRESULT hr;
|
|
|
|
// remove the item from the UI
|
|
LPRESULTDATA pResultData = (LPRESULTDATA)param;
|
|
hr = pResultData->DeleteItem( m_ResultItem.itemID, 0 );
|
|
ASSERT(hr == S_OK);
|
|
|
|
// need to check to see if WE are the current active policy
|
|
|
|
PWIRELESS_POLICY_DATA pPolicy = GetWirelessPolicy();
|
|
ASSERT(pPolicy);
|
|
|
|
DWORD dwError = 0;
|
|
|
|
//for machine policy, unassign the policy if the policy to delete is assigned
|
|
//for domain policy, we cannot do much here because we have no idea about which group
|
|
//units are using the policy
|
|
hr = DeleteWirelessPolicy(m_pComponentDataImpl->GetPolicyStoreHandle(), pPolicy);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
|
|
GUID guidClientExt = CLSID_WIRELESSClientEx;
|
|
GUID guidSnapin = CLSID_Snapin;
|
|
|
|
m_pComponentDataImpl->UseGPEInformationInterface()->PolicyChanged (
|
|
TRUE,
|
|
FALSE,
|
|
&guidClientExt,
|
|
&guidSnapin
|
|
);
|
|
|
|
// Remove the item from the result list
|
|
//m_pComponentDataImpl->GetStaticScopeObject()->RemoveResultItem( (LPDATAOBJECT)this );
|
|
|
|
// do a refresh of all views, we pass in the scope item to refresh all
|
|
m_pComponentDataImpl->GetConsole()->UpdateAllViews( m_pComponentDataImpl->GetStaticScopeObject(), 0, 0 );
|
|
|
|
// TODO: return value from OnDelete is wrong
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CSecPolItem::OnPropertyChange(LPARAM lParam, LPCONSOLE pConsole )
|
|
{
|
|
// call base class
|
|
return CWirelessSnapInDataObjectImpl<CSecPolItem>::OnPropertyChange( lParam, pConsole );
|
|
}
|
|
|
|
STDMETHODIMP CSecPolItem::OnRename( LPARAM arg, LPARAM param )
|
|
{
|
|
DWORD dwError = 0;
|
|
|
|
// TODO: what are the valid args for MMCN_RENAME?
|
|
if (arg == 0)
|
|
return S_OK;
|
|
|
|
LPOLESTR pszNewName = reinterpret_cast<LPOLESTR>(param);
|
|
if (pszNewName == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
CString strTemp = pszNewName;
|
|
|
|
strTemp.TrimLeft();
|
|
strTemp.TrimRight();
|
|
|
|
if (strTemp.IsEmpty())
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
|
|
|
|
HRESULT hr = S_FALSE;
|
|
PWIRELESS_POLICY_DATA pPolicy = GetWirelessPolicy();
|
|
|
|
if (pPolicy)
|
|
{
|
|
|
|
if (pPolicy->pszOldWirelessName)
|
|
FreePolStr(pPolicy->pszOldWirelessName);
|
|
|
|
if (pPolicy->pszWirelessName) {
|
|
pPolicy->pszOldWirelessName = pPolicy->pszWirelessName;
|
|
}
|
|
pPolicy->pszWirelessName = AllocPolStr(strTemp);
|
|
|
|
if (NULL == pPolicy->pszWirelessName)
|
|
{
|
|
CThemeContextActivator activator;
|
|
CString strMsg;
|
|
strMsg.LoadString(IDS_ERR_OUTOFMEMORY);
|
|
AfxMessageBox(strMsg);
|
|
return S_FALSE;
|
|
}
|
|
|
|
dwError = WirelessSetPolicyData(
|
|
m_pComponentDataImpl->GetPolicyStoreHandle(),
|
|
pPolicy
|
|
);
|
|
if (ERROR_SUCCESS != dwError)
|
|
{
|
|
ReportError(IDS_SAVE_ERROR, HRESULT_FROM_WIN32(dwError));
|
|
return S_FALSE;
|
|
}
|
|
|
|
GUID guidClientExt = CLSID_WIRELESSClientEx;
|
|
GUID guidSnapin = CLSID_Snapin;
|
|
|
|
m_pComponentDataImpl->UseGPEInformationInterface()->PolicyChanged (
|
|
TRUE,
|
|
TRUE,
|
|
&guidClientExt,
|
|
&guidSnapin
|
|
);
|
|
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function: OnSelect
|
|
// Description:
|
|
// On MMCN_SELECT determine which result item has been selected and
|
|
// remember it so we can ensure it remains selected when its property
|
|
// sheet (with General and SecPol pages) is dismissed.
|
|
//
|
|
HRESULT CSecPolItem::OnSelect(LPARAM arg, LPARAM param, IResultData *pResultData )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BOOL bScope = (BOOL) LOWORD(arg);
|
|
BOOL bSelected = (BOOL) HIWORD(arg);
|
|
|
|
if (!bScope)
|
|
{
|
|
if (bSelected)
|
|
{
|
|
// A result item was selected, save its index.
|
|
RESULTDATAITEM rdi;
|
|
ZeroMemory( &rdi, sizeof( RESULTDATAITEM ) );
|
|
rdi.mask = RDI_STATE | RDI_INDEX;
|
|
m_nResultSelected = -1;
|
|
do
|
|
{
|
|
hr = pResultData->GetItem( &rdi );
|
|
if (hr == S_OK)
|
|
{
|
|
if (!rdi.bScopeItem &&
|
|
rdi.nState & LVIS_FOCUSED && rdi.nState & LVIS_SELECTED)
|
|
{
|
|
OPT_TRACE( _T("CComponentImpl::OnSelect GetItem index-%i ID-%i\n"), rdi.nIndex, rdi.itemID );
|
|
m_nResultSelected = rdi.nIndex;
|
|
ASSERT( -1 != m_nResultSelected );
|
|
break;
|
|
}
|
|
rdi.nIndex++;
|
|
rdi.nState = 0;
|
|
}
|
|
} while ((S_OK == hr) && (rdi.nIndex >= 0));
|
|
}
|
|
}
|
|
else
|
|
// A scope item was selected
|
|
m_nResultSelected = -1;
|
|
return hr;
|
|
}
|
|
|
|
// Function: SelectResult
|
|
// Description:
|
|
// Select the result item indexed by m_nResultSelected when the index
|
|
// is valid (0, or greater)
|
|
//
|
|
void CSecPolItem::SelectResult( IResultData *pResultData )
|
|
{
|
|
if (-1 == m_nResultSelected)
|
|
return;
|
|
|
|
HRESULT hr = pResultData->ModifyItemState( m_nResultSelected,
|
|
(HRESULTITEM)0, LVIS_FOCUSED | LVIS_SELECTED, 0 );
|
|
// This fails if a property sheet is being displayed.
|
|
//ASSERT( S_OK == hr );
|
|
}
|
|
|
|
// Function: CheckForEnabled
|
|
// Description:
|
|
// Checks GetPolicy() policy to see if it is enabled given the current
|
|
// storage location. Returns FALSE if the storage location doesn't support
|
|
// Enabled/Disabled
|
|
BOOL CSecPolItem::CheckForEnabled ()
|
|
{
|
|
BOOL bRetVal = FALSE;
|
|
HRESULT hr = S_OK;
|
|
WCHAR szMachinePath[256];
|
|
WCHAR szPolicyDN[256];
|
|
BSTR pszCurrentDN = NULL;
|
|
PWIRELESS_POLICY_DATA pWirelessPolicyData = NULL;
|
|
HANDLE hLocalPolicyStore = NULL;
|
|
WCHAR szPathName[MAX_PATH];
|
|
DWORD dwError = 0;
|
|
|
|
|
|
// if we are an extension snapin then look to the GPE we are extending, otherwise
|
|
// use the normal storage location
|
|
// NOTE: we also check to make sure we are talking to the global store
|
|
// because we don't want to use the GPO object settings in anything but the
|
|
// DS case
|
|
|
|
|
|
|
|
pWirelessPolicyData = GetWirelessPolicy();
|
|
|
|
szPolicyDN[0] = L'\0';
|
|
szPathName[0] = L'\0';
|
|
|
|
if ( m_pComponentDataImpl->IsRsop() )
|
|
{
|
|
if ( pWirelessPolicyData->pRsopInfo && pWirelessPolicyData->pRsopInfo->uiPrecedence == 1 )
|
|
{
|
|
bRetVal = TRUE;
|
|
return bRetVal;
|
|
}
|
|
}
|
|
|
|
return bRetVal;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// IExtendControlbar helpers
|
|
|
|
STDMETHODIMP_(BOOL) CSecPolItem::UpdateToolbarButton
|
|
(
|
|
UINT id, // button ID
|
|
BOOL bSnapObjSelected, // ==TRUE when result/scope item is selected
|
|
BYTE fsState // enable/disable this button state by returning TRUE/FALSE
|
|
)
|
|
{
|
|
BOOL bActive = FALSE;
|
|
PWIRELESS_POLICY_DATA pWirelessPolicyData = NULL;
|
|
HANDLE hLocalPolicyStore = NULL;
|
|
STORAGE_LOCATION eStgLocation = m_pComponentDataImpl->EnumLocation();
|
|
|
|
|
|
pWirelessPolicyData = GetWirelessPolicy();
|
|
|
|
bActive = CheckForEnabled();
|
|
|
|
// Handle only the enable/disable state
|
|
if (ENABLED == fsState)
|
|
{
|
|
// Our toolbar has only two items
|
|
if (IDM_ASSIGN == id || IDM_UNASSIGN == id)
|
|
{
|
|
|
|
// The toolbar items should be enabled only if we are pointed to the local machine
|
|
if (LOCATION_REMOTE == eStgLocation || LOCATION_LOCAL == eStgLocation
|
|
// extension snapin?
|
|
|| (LOCATION_GLOBAL == eStgLocation && (NULL != m_pComponentDataImpl->GetStaticScopeObject()->GetExtScopeObject())))
|
|
{
|
|
// Disable the SetActive button when policy is already active
|
|
if (IDM_ASSIGN == id)
|
|
{
|
|
if (bActive)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
// Disable the SetInactive button when policy is already inactive
|
|
else if (IDM_UNASSIGN == id)
|
|
{
|
|
if (!bActive)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Disable both the SetActive and SetInactive buttons for DS based snap-in
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
ComputePolicyDN(
|
|
LPWSTR pszDirDomainName,
|
|
GUID PolicyIdentifier,
|
|
LPWSTR pszPolicyDN
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
LPWSTR pszPolicyIdentifier = NULL;
|
|
|
|
|
|
if (!pszDirDomainName) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = StringFromCLSID(
|
|
PolicyIdentifier,
|
|
&pszPolicyIdentifier
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
wcscpy(pszPolicyDN,L"cn=msieee80211-Policy");
|
|
wcscat(pszPolicyDN,pszPolicyIdentifier);
|
|
wcscat(pszPolicyDN,L",cn=Wireless Policy,cn=System,");
|
|
wcscat(pszPolicyDN, pszDirDomainName);
|
|
|
|
error:
|
|
|
|
if (pszPolicyIdentifier) {
|
|
CoTaskMemFree(pszPolicyIdentifier);
|
|
}
|
|
|
|
return(dwError);
|
|
}
|
|
|