//---------------------------------------------------------------------------- // // Microsoft Windows // Copyright (C) Microsoft Corporation, 2001. // // File: spolitem.cpp // // Contents: WiF Policy Snapin // // // History: TaroonM // 10/30/01 // //---------------------------------------------------------------------------- #include "stdafx.h" #include #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::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*>(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 spPropshtManager = new CComObject; 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*>(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*>(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*>(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 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 spVerb; pConsole->QueryConsoleVerb( &spVerb ); m_bItemSelected = !!(HIWORD(arg)); // call object to set verb state AdjustVerbState( (IConsoleVerb*)spVerb ); // Remember selected result item CComQIPtr 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 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 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::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 *)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 *)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::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(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); }