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

3935 lines
114 KiB
Raw Permalink Blame History

//*************************************************************
// File name: GPMGR.C
//
// Description: Group Policy Manager - property sheet extension
// for DS Admin
//
//
// Microsoft Confidential
// Copyright (c) Microsoft Corporation 1998
// All rights reserved
//
//*************************************************************
#include "main.h"
unsigned int CGroupPolicyMgr::m_cfDSObjectName = RegisterClipboardFormat(CFSTR_DSOBJECTNAMES);
unsigned int CGroupPolicyMgr::m_cfNodeTypeString = RegisterClipboardFormat(CCF_SZNODETYPE);
//
// Snapin manager's CLSID
//
const CLSID CLSID_NodeInit = {0x43136EB5,0xD36C,0x11CF,{0xAD,0xBC,0x00,0xAA,0x00,0xA8,0x00,0x33}};
//
// CheckMark string
//
TCHAR szCheckMark[] = TEXT("a"); // In the Marlett font, "a" becomes a check mark
TCHAR szNoCheckMark[] = TEXT("");
//
// Help ids
//
DWORD aGroupPolicyMgrHelpIds[] =
{
IDC_GPM_DCNAME, IDH_GPMGR_DCNAME,
IDC_GPM_LIST, IDH_GPMGR_LIST,
IDC_GPM_UP, IDH_GPMGR_UP,
IDC_GPM_DOWN, IDH_GPMGR_DOWN,
IDC_GPM_ADD, IDH_GPMGR_ADD,
IDC_GPM_EDIT, IDH_GPMGR_EDIT,
IDC_GPM_DELETE, IDH_GPMGR_DELETE,
IDC_GPM_PROPERTIES, IDH_GPMGR_PROPERTIES,
IDC_GPM_BLOCK, IDH_GPMGR_BLOCK,
IDC_GPM_NEW, IDH_GPMGR_NEW,
IDC_GPM_OPTIONS, IDH_GPMGR_OPTIONS,
IDC_GPM_TITLE, -1,
IDC_GPM_ICON, -1,
IDC_GPM_LINE1, -1,
IDC_GPM_PRIORITY, -1,
IDC_GPM_LINE2, -1,
0, 0
};
DWORD aLinkOptionsHelpIds[] =
{
IDC_GPM_NOOVERRIDE, IDH_GPMGR_NOOVERRIDE,
IDC_GPM_DISABLED, IDH_GPMGR_DISABLED,
0, 0
};
DWORD aRemoveGPOHelpIds[] =
{
IDC_REMOVE_LIST, IDH_REMOVE_LIST,
IDC_REMOVE_DS, IDH_REMOVE_DS,
0, 0
};
///////////////////////////////////////////////////////////////////////////////
// //
// CGroupPolicyMgr object implementation //
// //
///////////////////////////////////////////////////////////////////////////////
CGroupPolicyMgr::CGroupPolicyMgr()
{
InterlockedIncrement(&g_cRefThisDll);
m_cRef = 1;
m_lpDSObject = NULL;
m_lpGPODCName = NULL;
m_lpDSADCName = NULL;
m_lpDomainName = NULL;
m_hDefaultFont = NULL;
m_hMarlettFont = NULL;
m_bReadOnly = FALSE;
m_bDirty = FALSE;
m_gpHint = GPHintUnknown;
}
CGroupPolicyMgr::~CGroupPolicyMgr()
{
if (m_hMarlettFont)
{
DeleteObject (m_hMarlettFont);
}
if (m_lpDSObject)
{
LocalFree (m_lpDSObject);
}
if (m_lpGPODCName)
{
LocalFree (m_lpGPODCName);
}
if (m_lpDSADCName)
{
LocalFree (m_lpDSADCName);
}
if (m_lpDomainName)
{
LocalFree (m_lpDomainName);
}
InterlockedDecrement(&g_cRefThisDll);
}
///////////////////////////////////////////////////////////////////////////////
// //
// CGroupPolicyMgr object implementation (IUnknown) //
// //
///////////////////////////////////////////////////////////////////////////////
HRESULT CGroupPolicyMgr::QueryInterface (REFIID riid, void **ppv)
{
if (IsEqualIID(riid, IID_IUnknown) ||IsEqualIID(riid, IID_IExtendPropertySheet))
{
*ppv = (LPEXTENDPROPERTYSHEET)this;
m_cRef++;
return S_OK;
}
else if (IsEqualIID(riid, IID_ISnapinHelp))
{
*ppv = (LPSNAPINHELP)this;
m_cRef++;
return S_OK;
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
}
ULONG CGroupPolicyMgr::AddRef (void)
{
return ++m_cRef;
}
ULONG CGroupPolicyMgr::Release (void)
{
if (--m_cRef == 0) {
delete this;
return 0;
}
return m_cRef;
}
///////////////////////////////////////////////////////////////////////////////
// //
// CGroupPolicyMgr object implementation (ISnapinHelp) //
// //
///////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CGroupPolicyMgr::GetHelpTopic(LPOLESTR *lpCompiledHelpFile)
{
LPOLESTR lpHelpFile;
lpHelpFile = (LPOLESTR) CoTaskMemAlloc (MAX_PATH * sizeof(WCHAR));
if (!lpHelpFile)
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::GetHelpTopic: Failed to allocate memory.")));
return E_OUTOFMEMORY;
}
ExpandEnvironmentStringsW (L"%SystemRoot%\\Help\\gpedit.chm",
lpHelpFile, MAX_PATH);
*lpCompiledHelpFile = lpHelpFile;
return S_OK;
}
///////////////////////////////////////////////////////////////////////////////
// //
// CGroupPolicyMgr object implementation (IExtendPropertySheet) //
// //
///////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CGroupPolicyMgr::CreatePropertyPages(LPPROPERTYSHEETCALLBACK lpProvider,
LONG_PTR handle, LPDATAOBJECT lpDataObject)
{
HRESULT hr;
PROPSHEETPAGE psp;
HPROPSHEETPAGE hPage;
FORMATETC fm;
STGMEDIUM medium;
LPDSOBJECTNAMES lpNames;
LPTSTR lpTemp;
//
// Ask DS admin for the ldap path to the selected object
//
ZeroMemory (&fm, sizeof(fm));
fm.cfFormat = (WORD)m_cfDSObjectName;
fm.tymed = TYMED_HGLOBAL;
ZeroMemory (&medium, sizeof(medium));
medium.tymed = TYMED_HGLOBAL;
medium.hGlobal = GlobalAlloc (GMEM_MOVEABLE | GMEM_NODISCARD, 512);
if (medium.hGlobal)
{
hr = lpDataObject->GetData(&fm, &medium);
if (SUCCEEDED(hr))
{
lpNames = (LPDSOBJECTNAMES) GlobalLock (medium.hGlobal);
lpTemp = (LPWSTR) (((LPBYTE)lpNames) + lpNames->aObjects[0].offsetName);
if (m_lpDSObject)
{
LocalFree (m_lpDSObject);
}
ULONG ulNoChars = lstrlen (lpTemp) + 1;
m_lpDSObject = (LPTSTR) LocalAlloc (LPTR, ulNoChars * sizeof(TCHAR));
if (m_lpDSObject)
{
hr = StringCchCopy (m_lpDSObject, ulNoChars, lpTemp);
ASSERT(SUCCEEDED(hr));
DebugMsg((DM_VERBOSE, TEXT("CGroupPolicyMgr::CreatePropertyPages: LDAP path from DS Admin %s"), m_lpDSObject));
//
// Now look at the object type to get a hint type
//
m_gpHint = GPHintUnknown;
if (lpNames->aObjects[0].offsetClass) {
lpTemp = (LPWSTR) (((LPBYTE)lpNames) + lpNames->aObjects[0].offsetClass);
if (CompareString( LOCALE_INVARIANT, NORM_IGNORECASE, lpTemp, -1, TEXT("domainDNS"), -1) == CSTR_EQUAL)
{
m_gpHint = GPHintDomain;
}
else if (CompareString( LOCALE_INVARIANT, NORM_IGNORECASE, lpTemp, -1, TEXT("organizationalUnit"), -1) == CSTR_EQUAL)
{
m_gpHint = GPHintOrganizationalUnit;
}
else if (CompareString( LOCALE_INVARIANT, NORM_IGNORECASE, lpTemp, -1, TEXT("site"), -1) == CSTR_EQUAL)
{
m_gpHint = GPHintSite;
}
DebugMsg((DM_VERBOSE, TEXT("CGroupPolicyMgr::CreatePropertyPages: m_gpHint = %d"), m_gpHint));
} else {
DebugMsg((DM_VERBOSE, TEXT("CGroupPolicyMgr::CreatePropertyPages: No objectclass defined.")));
}
}
else
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
GlobalUnlock (medium.hGlobal);
}
GlobalFree (medium.hGlobal);
}
else
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
//
// Add the GPM property sheet page
//
if (SUCCEEDED(hr))
{
ZeroMemory (&psp, sizeof(psp));
psp.dwSize = sizeof(psp);
psp.dwFlags = PSP_USECALLBACK;
psp.hInstance = g_hInstance;
psp.pszTemplate = MAKEINTRESOURCE (IDD_GPMANAGER);
psp.pfnDlgProc = GPMDlgProc;
psp.lParam = (LPARAM) this;
psp.pfnCallback = PropSheetPageCallback;
hPage = CreatePropertySheetPage(&psp);
if (hPage)
{
hr = lpProvider->AddPage(hPage);
}
else
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::CreatePropertyPages: Failed to create property sheet page with %d."),
GetLastError()));
hr = E_FAIL;
}
}
return (hr);
}
STDMETHODIMP CGroupPolicyMgr::QueryPagesFor(LPDATAOBJECT lpDataObject)
{
return S_OK;
}
UINT CALLBACK CGroupPolicyMgr::PropSheetPageCallback(HWND hwnd, UINT uMsg, LPPROPSHEETPAGE ppsp)
{
CGroupPolicyMgr * pGPM;
pGPM = (CGroupPolicyMgr *) ppsp->lParam;
if (uMsg == PSPCB_ADDREF)
{
pGPM->AddRef();
}
else if (uMsg == PSPCB_RELEASE)
{
pGPM->Release();
}
return 1;
}
INT_PTR CALLBACK CGroupPolicyMgr::GPMDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
CGroupPolicyMgr * pGPM;
static BOOL bDisableWarningIssued;
switch (message)
{
case WM_INITDIALOG:
pGPM = (CGroupPolicyMgr *) (((LPPROPSHEETPAGE)lParam)->lParam);
SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pGPM);
SetWaitCursor();
bDisableWarningIssued = FALSE;
EnableWindow (GetDlgItem (hDlg, IDC_GPM_DELETE), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_GPM_EDIT), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_GPM_UP), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_GPM_DOWN), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_GPM_OPTIONS), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_GPM_PROPERTIES), FALSE);
if (!pGPM->OnInitDialog(hDlg))
{
EnableWindow (GetDlgItem (hDlg, IDC_GPM_LIST), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_GPM_NEW), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_GPM_ADD), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_GPM_BLOCK), FALSE);
}
if (pGPM->m_bReadOnly)
{
EnableWindow (GetDlgItem (hDlg, IDC_GPM_NEW), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_GPM_ADD), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_GPM_DELETE), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_GPM_UP), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_GPM_DOWN), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_GPM_OPTIONS), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_GPM_BLOCK), FALSE);
}
#if FGPO_SUPPORT
if (pGPM->m_gpHint == GPHintForest)
#else
if (pGPM->m_gpHint == GPHintSite)
#endif
{
EnableWindow (GetDlgItem (hDlg, IDC_GPM_BLOCK), FALSE);
}
ClearWaitCursor();
break;
case WM_COMMAND:
pGPM = (CGroupPolicyMgr *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pGPM) {
break;
}
if ((LOWORD(wParam) == IDC_GPM_ADD) || (LOWORD(wParam) == IDM_GPM_ADD))
{
TCHAR szPath[512];
TCHAR szName[MAX_FRIENDLYNAME];
TCHAR szTitle[100];
LPTSTR lpNamelessPath;
GPOBROWSEINFO stGBI;
IADs * pADs;
HRESULT hr;
BOOL bReadOnly = FALSE;
LoadString (g_hInstance, IDS_GPM_ADDTITLE, szTitle, ARRAYSIZE(szTitle));
ZeroMemory(&stGBI, sizeof(GPOBROWSEINFO));
stGBI.dwSize = sizeof(GPOBROWSEINFO);
stGBI.dwFlags = GPO_BROWSE_NOCOMPUTERS | GPO_BROWSE_DISABLENEW;
stGBI.hwndOwner = hDlg;
stGBI.lpTitle = szTitle;
stGBI.lpInitialOU = pGPM->m_lpDSObject;
stGBI.lpDSPath = szPath;
stGBI.dwDSPathSize = ARRAYSIZE(szPath);
stGBI.lpName = szName;
stGBI.dwNameSize = ARRAYSIZE(szName);
if (SUCCEEDED(BrowseForGPO(&stGBI)))
{
//
// Check if the user has write access to the select GPO
//
lpNamelessPath = MakeNamelessPath (szPath);
if (lpNamelessPath)
{
hr = OpenDSObject(szPath, IID_IADs, (void **)&pADs);
if (SUCCEEDED(hr)) {
if (FAILED(CheckDSWriteAccess((LPUNKNOWN) pADs, GPO_VERSION_PROPERTY)))
{
bReadOnly = TRUE;
}
pADs->Release();
}
//
// Read the policy value for the GPO link
//
HKEY hKey;
DWORD dwSize, dwType;
BOOL bDisabledLink = FALSE;
//
// Check if there is a user preference or policy that
// any new GPOs should be created with a disabled link
// by default
//
if (RegOpenKeyEx (HKEY_CURRENT_USER, GPE_KEY, 0,
KEY_READ, &hKey) == ERROR_SUCCESS)
{
dwSize = sizeof(bDisabledLink);
RegQueryValueEx (hKey, NEW_LINKS_DISABLED_VALUE, NULL, &dwType,
(LPBYTE) &bDisabledLink, &dwSize);
RegCloseKey (hKey);
}
if (RegOpenKeyEx (HKEY_CURRENT_USER, GPE_POLICIES_KEY, 0,
KEY_READ, &hKey) == ERROR_SUCCESS)
{
dwSize = sizeof(bDisabledLink);
RegQueryValueEx (hKey, NEW_LINKS_DISABLED_VALUE, NULL, &dwType,
(LPBYTE) &bDisabledLink, &dwSize);
RegCloseKey (hKey);
}
if (pGPM->AddGPOToList (GetDlgItem(hDlg, IDC_GPM_LIST),
szName, lpNamelessPath, (bDisabledLink ? GPO_FLAG_DISABLE : 0), FALSE,
pGPM->IsGPODisabled (lpNamelessPath), bReadOnly))
{
pGPM->m_bDirty = TRUE;
SendMessage (GetParent(hDlg), PSM_CHANGED, (WPARAM) hDlg, 0);
SetFocus (GetDlgItem(hDlg, IDC_GPM_LIST));
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
LocalFree (lpNamelessPath);
}
}
}
if ((LOWORD(wParam) == IDC_GPM_DELETE) || (LOWORD(wParam) == IDM_GPM_DELETE))
{
INT iIndex, iNext;
HWND hLV = GetDlgItem(hDlg, IDC_GPM_LIST);
LVITEM item;
//
// Enumerate through the selected items
//
iIndex = ListView_GetNextItem (hLV, -1, LVNI_ALL | LVNI_SELECTED);
if (iIndex != -1)
{
HRESULT hr;
LPGPOITEM lpGPO, lpTemp;
LPGROUPPOLICYOBJECT pGPO;
TCHAR szMessageFmt[100];
LPTSTR lpMessage;
TCHAR szTitle[100];
INT iResult;
LPTSTR lpDSPath;
LPTSTR lpFullPath;
//
// The GPO item pointer
//
item.mask = LVIF_PARAM;
item.iItem = iIndex;
item.iSubItem = 0;
if (!ListView_GetItem (hLV, &item))
{
break;
}
lpGPO = (LPGPOITEM) item.lParam;
if ( !lpGPO )
{
break;
}
lpGPO->bLocked = TRUE;
//
// Offer the user a choice of Remove actions
//
iResult = (INT)DialogBoxParam (g_hInstance, MAKEINTRESOURCE(IDD_REMOVE_GPO),
hDlg, RemoveGPODlgProc, (LPARAM) lpGPO);
if ((iResult == -1) || (iResult == 0))
{
SetFocus (hLV);
lpGPO->bLocked = FALSE;
break;
}
iNext = ListView_GetNextItem (hLV, iIndex, LVNI_ALL);
if (iNext > 0)
{
iNext--;
}
else
{
iNext = 0;
}
if (iResult == 1)
{
IADs * pADs;
//
// Bind to the DS object to make sure it's still reachable
//
hr = OpenDSObject(pGPM->m_lpDSObject, IID_IADs, (void **)&pADs);
if (SUCCEEDED(hr))
{
pADs->Release();
ListView_DeleteItem (hLV, iIndex);
lpGPO = NULL;
}
else
{
DebugMsg((DM_WARNING, TEXT("GPMDlgProc: Failed to get IADs interface with 0x%x"), hr));
ReportError(hDlg, hr, IDS_FAILEDGPINFO);
lpGPO->bLocked = FALSE;
break;
}
}
else if (iResult == 2)
{
//
// Confirm the delete operation
//
LoadString (g_hInstance, IDS_DELETECONFIRM, szMessageFmt, ARRAYSIZE(szMessageFmt));
ULONG ulNoChars;
ulNoChars = lstrlen(szMessageFmt) + lstrlen(lpGPO->lpDisplayName) + 1;
lpMessage = (LPTSTR) LocalAlloc (LPTR, ulNoChars * sizeof(TCHAR));
if (lpMessage)
{
hr = StringCchPrintf (lpMessage, ulNoChars, szMessageFmt, lpGPO->lpDisplayName);
if (FAILED(hr))
{
LocalFree(lpMessage);
lpMessage = NULL;
}
}
if (!lpMessage)
{
DebugMsg((DM_WARNING, TEXT("GPMDlgProc: Failed to allocate memory with %d."),
GetLastError()));
SetFocus (hLV);
ClearWaitCursor ();
lpGPO->bLocked = FALSE;
break;
}
LoadString (g_hInstance, IDS_CONFIRMTITLE, szTitle, ARRAYSIZE(szTitle));
if (MessageBox (hDlg, lpMessage, szTitle,
MB_YESNO | MB_ICONEXCLAMATION) != IDYES)
{
LocalFree (lpMessage);
SetFocus (hLV);
lpGPO->bLocked = FALSE;
break;
}
LocalFree (lpMessage);
SetWaitCursor ();
ulNoChars = lstrlen(lpGPO->lpDSPath) + 1;
lpDSPath = (LPTSTR) LocalAlloc (LPTR, ulNoChars * sizeof(TCHAR));
if (!lpDSPath)
{
DebugMsg((DM_WARNING, TEXT("GPMDlgProc: Failed to allocate memory with %d."),
GetLastError()));
SetFocus (hLV);
ClearWaitCursor ();
lpGPO->bLocked = FALSE;
break;
}
hr = StringCchCopy (lpDSPath, ulNoChars, lpGPO->lpDSPath);
ASSERT(SUCCEEDED(hr));
//
// Create a new GPO object to work with
//
hr = CoCreateInstance (CLSID_GroupPolicyObject, NULL,
CLSCTX_SERVER, IID_IGroupPolicyObject,
(void**)&pGPO);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("GPMDlgProc: Failed to create GPO object with 0x%x."), hr));
LocalFree (lpDSPath);
SetFocus (hLV);
ClearWaitCursor ();
lpGPO->bLocked = FALSE;
break;
}
lpFullPath = pGPM->GetFullGPOPath (lpGPO->lpDSPath, hDlg);
if (!lpFullPath)
{
pGPO->Release();
LocalFree (lpDSPath);
SetFocus (hLV);
ClearWaitCursor ();
lpGPO->bLocked = FALSE;
break;
}
//
// Open the requested object without mounting the registry
//
hr = pGPO->OpenDSGPO(lpFullPath, 0);
LocalFree (lpFullPath);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("GPMDlgProc: Failed to open GPO object with 0x%x."), hr));
ReportError(hDlg, hr, IDS_FAILEDGPODELETE, lpGPO->lpDisplayName);
pGPO->Release();
LocalFree (lpDSPath);
SetFocus (hLV);
ClearWaitCursor ();
lpGPO->bLocked = FALSE;
break;
}
//
// Delete the object
//
hr = pGPO->Delete();
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("GPMDlgProc: Failed to delete GPO object with 0x%x."), hr));
ReportError(hDlg, hr, IDS_FAILEDGPODELETE, lpGPO->lpDisplayName);
pGPO->Release();
LocalFree (lpDSPath);
SetFocus (hLV);
ClearWaitCursor ();
lpGPO->bLocked = FALSE;
break;
}
pGPO->Release();
//
// Delete all the entries of this item in the listview
//
iIndex = (ListView_GetItemCount (hLV) - 1);
while (iIndex >= 0)
{
item.mask = LVIF_PARAM;
item.iItem = iIndex;
item.iSubItem = 0;
if (!ListView_GetItem (hLV, &item))
{
lpGPO->bLocked = FALSE;
break;
}
lpTemp = (LPGPOITEM) item.lParam;
if (lpTemp)
{
if (!lstrcmpi(lpTemp->lpDSPath, lpDSPath))
{
if (iNext == iIndex)
{
iNext--;
}
ListView_DeleteItem (hLV, iIndex);
lpGPO = NULL;
}
}
iIndex--;
}
LocalFree (lpDSPath);
ClearWaitCursor ();
}
if (iNext < 0)
{
iNext = 0;
}
//
// Select the next item
//
item.mask = LVIF_STATE;
item.iItem = iNext;
item.iSubItem = 0;
item.state = LVIS_SELECTED | LVIS_FOCUSED;
item.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
SendMessage (hLV, LVM_SETITEMSTATE, iNext, (LPARAM) &item);
pGPM->m_bDirty = TRUE;
if (!pGPM->Save(hDlg))
{
pGPM->RefreshGPM (hDlg, FALSE);
}
SendMessage (GetParent(hDlg), PSM_CANCELTOCLOSE, 0, 0);
SetFocus (hLV);
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
}
if (LOWORD(wParam) == IDC_GPM_UP)
{
INT iSrc, iDest, iSrcImage, iDestImage;
LPGPOITEM lpSrc, lpDest;
HWND hLV = GetDlgItem(hDlg, IDC_GPM_LIST);
LVITEM item;
ListView_EditLabel (hLV, -1);
iSrc = ListView_GetNextItem (hLV, -1,
LVNI_ALL | LVNI_SELECTED);
if (iSrc != -1)
{
iDest = iSrc - 1;
//
// Get the current lpGPOItem pointers
//
item.mask = LVIF_PARAM | LVIF_IMAGE;
item.iItem = iSrc;
item.iSubItem = 0;
if (!ListView_GetItem (hLV, &item))
{
break;
}
lpSrc = (LPGPOITEM) item.lParam;
iSrcImage = item.iImage;
item.mask = LVIF_PARAM | LVIF_IMAGE;
item.iItem = iDest;
item.iSubItem = 0;
if (!ListView_GetItem (hLV, &item))
{
break;
}
lpDest = (LPGPOITEM) item.lParam;
iDestImage = item.iImage;
//
// Swap them
//
item.mask = LVIF_PARAM | LVIF_IMAGE;
item.iItem = iSrc;
item.iImage = iDestImage;
item.iSubItem = 0;
item.lParam = (LPARAM)lpDest;
if (!ListView_SetItem (hLV, &item))
{
break;
}
item.mask = LVIF_PARAM | LVIF_IMAGE;
item.iItem = iDest;
item.iImage = iSrcImage;
item.iSubItem = 0;
item.lParam = (LPARAM)lpSrc;
if (!ListView_SetItem (hLV, &item))
{
break;
}
//
// Select the item
//
item.mask = LVIF_STATE;
item.iItem = iSrc;
item.iSubItem = 0;
item.state = 0;
item.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
SendMessage (hLV, LVM_SETITEMSTATE, iSrc, (LPARAM) &item);
item.mask = LVIF_STATE;
item.iItem = iDest;
item.iSubItem = 0;
item.state = LVIS_SELECTED | LVIS_FOCUSED;
item.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
SendMessage (hLV, LVM_SETITEMSTATE, iDest, (LPARAM) &item);
SendMessage (hLV, LVM_ENSUREVISIBLE, iDest, (LPARAM) FALSE);
//
// Update the listview
//
ListView_RedrawItems (hLV, iDest, iSrc);
pGPM->m_bDirty = TRUE;
SendMessage (GetParent(hDlg), PSM_CHANGED, (WPARAM) hDlg, 0);
SetFocus (hLV);
}
}
if (LOWORD(wParam) == IDC_GPM_DOWN)
{
INT iSrc, iDest, iSrcImage, iDestImage;
LPGPOITEM lpSrc, lpDest;
HWND hLV = GetDlgItem(hDlg, IDC_GPM_LIST);
LVITEM item;
ListView_EditLabel (hLV, -1);
iSrc = ListView_GetNextItem (hLV, -1,
LVNI_ALL | LVNI_SELECTED);
if (iSrc != -1)
{
iDest = iSrc + 1;
//
// Get the current lpGPOItem pointers
//
item.mask = LVIF_PARAM | LVIF_IMAGE;
item.iItem = iSrc;
item.iSubItem = 0;
if (!ListView_GetItem (hLV, &item))
{
break;
}
lpSrc = (LPGPOITEM) item.lParam;
iSrcImage = item.iImage;
item.mask = LVIF_PARAM | LVIF_IMAGE;
item.iItem = iDest;
item.iSubItem = 0;
if (!ListView_GetItem (hLV, &item))
{
break;
}
lpDest = (LPGPOITEM) item.lParam;
iDestImage = item.iImage;
//
// Swap them
//
item.mask = LVIF_PARAM | LVIF_IMAGE;
item.iItem = iSrc;
item.iImage = iDestImage;
item.iSubItem = 0;
item.lParam = (LPARAM)lpDest;
if (!ListView_SetItem (hLV, &item))
{
break;
}
item.mask = LVIF_PARAM | LVIF_IMAGE;
item.iItem = iDest;
item.iImage = iSrcImage;
item.iSubItem = 0;
item.lParam = (LPARAM)lpSrc;
if (!ListView_SetItem (hLV, &item))
{
break;
}
//
// Select the item
//
item.mask = LVIF_STATE;
item.iItem = iSrc;
item.iSubItem = 0;
item.state = 0;
item.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
SendMessage (hLV, LVM_SETITEMSTATE, iSrc, (LPARAM) &item);
item.mask = LVIF_STATE;
item.iItem = iDest;
item.iSubItem = 0;
item.state = LVIS_SELECTED | LVIS_FOCUSED;
item.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
SendMessage (hLV, LVM_SETITEMSTATE, iDest, (LPARAM) &item);
SendMessage (hLV, LVM_ENSUREVISIBLE, iDest, (LPARAM) FALSE);
//
// Update the listview
//
ListView_RedrawItems (hLV, iSrc, iDest);
pGPM->m_bDirty = TRUE;
SendMessage (GetParent(hDlg), PSM_CHANGED, (WPARAM) hDlg, 0);
SetFocus (hLV);
}
}
if (LOWORD(wParam) == IDM_GPM_NOOVERRIDE)
{
INT iIndex;
LPGPOITEM lpItem;
LVITEM item;
HWND hLV = GetDlgItem(hDlg, IDC_GPM_LIST);
//
// Enumerate through the selected items
//
iIndex = ListView_GetNextItem (hLV, -1,
LVNI_ALL | LVNI_SELECTED);
if (iIndex != -1)
{
item.mask = LVIF_PARAM;
item.iItem = iIndex;
item.iSubItem = 0;
if (ListView_GetItem (hLV, &item))
{
lpItem = (LPGPOITEM) item.lParam;
lpItem->bLocked = TRUE;
if (lpItem->dwOptions & GPO_FLAG_FORCE)
lpItem->dwOptions &= ~GPO_FLAG_FORCE;
else
lpItem->dwOptions |= GPO_FLAG_FORCE;
ListView_RedrawItems (hLV, iIndex, iIndex);
UpdateWindow (hLV);
pGPM->m_bDirty = TRUE;
SendMessage (GetParent(hDlg), PSM_CHANGED, (WPARAM) hDlg, 0);
SetFocus (hLV);
lpItem->bLocked = FALSE;
}
}
}
if (LOWORD(wParam) == IDM_GPM_DISABLED)
{
INT iIndex;
LPGPOITEM lpItem;
LVITEM item;
HWND hLV = GetDlgItem(hDlg, IDC_GPM_LIST);
//
// Enumerate through the selected items
//
iIndex = ListView_GetNextItem (hLV, -1,
LVNI_ALL | LVNI_SELECTED);
if (iIndex != -1)
{
item.mask = LVIF_PARAM;
item.iItem = iIndex;
item.iSubItem = 0;
if (ListView_GetItem (hLV, &item))
{
lpItem = (LPGPOITEM) item.lParam;
if (lpItem->dwOptions & GPO_FLAG_DISABLE)
lpItem->dwOptions &= ~GPO_FLAG_DISABLE;
else
{
if (bDisableWarningIssued)
{
lpItem->dwOptions |= GPO_FLAG_DISABLE;
}
else
{
TCHAR szMessage[200];
TCHAR szTitle[100];
bDisableWarningIssued = TRUE;
LoadString (g_hInstance, IDS_CONFIRMDISABLE, szMessage, ARRAYSIZE(szMessage));
LoadString (g_hInstance, IDS_CONFIRMTITLE2, szTitle, ARRAYSIZE(szTitle));
if (MessageBox (hDlg, szMessage, szTitle, MB_YESNO |
MB_ICONWARNING | MB_DEFBUTTON2) == IDYES) {
lpItem->dwOptions |= GPO_FLAG_DISABLE;
}
}
}
ListView_RedrawItems (hLV, iIndex, iIndex);
UpdateWindow (hLV);
pGPM->m_bDirty = TRUE;
SendMessage (GetParent(hDlg), PSM_CHANGED, (WPARAM) hDlg, 0);
SetFocus (hLV);
}
}
}
if ((LOWORD(wParam) == IDC_GPM_EDIT) || (LOWORD(wParam) == IDM_GPM_EDIT))
{
INT iIndex;
LPGPOITEM lpItem;
LVITEM item;
HWND hLV = GetDlgItem(hDlg, IDC_GPM_LIST);
//
// Enumerate through the selected items
//
iIndex = ListView_GetNextItem (hLV, -1,
LVNI_ALL | LVNI_SELECTED);
if (iIndex != -1)
{
item.mask = LVIF_PARAM;
item.iItem = iIndex;
item.iSubItem = 0;
if (ListView_GetItem (hLV, &item))
{
lpItem = (LPGPOITEM) item.lParam;
lpItem->bLocked = TRUE;
pGPM->StartGPE (lpItem->lpDSPath, hDlg);
lpItem->bLocked = FALSE;
SetFocus (hLV);
}
}
}
if ((LOWORD(wParam) == IDC_GPM_NEW) || (LOWORD(wParam) == IDM_GPM_NEW))
{
SetWaitCursor();
pGPM->OnNew (hDlg);
ClearWaitCursor();
}
if (LOWORD(wParam) == IDC_GPM_OPTIONS)
{
INT iIndex;
LPGPOITEM lpItem;
LVITEM item;
HWND hLV = GetDlgItem(hDlg, IDC_GPM_LIST);
//
// Enumerate through the selected items
//
iIndex = ListView_GetNextItem (hLV, -1,
LVNI_ALL | LVNI_SELECTED);
if (iIndex != -1)
{
item.mask = LVIF_PARAM;
item.iItem = iIndex;
item.iSubItem = 0;
if (ListView_GetItem (hLV, &item))
{
lpItem = (LPGPOITEM) item.lParam;
lpItem->bLocked = TRUE;
if (DialogBoxParam (g_hInstance, MAKEINTRESOURCE(IDD_GPM_LINK_OPTIONS),
hDlg, LinkOptionsDlgProc, (LPARAM) lpItem))
{
ListView_RedrawItems (hLV, iIndex, iIndex);
UpdateWindow (hLV);
pGPM->m_bDirty = TRUE;
SendMessage (GetParent(hDlg), PSM_CHANGED, (WPARAM) hDlg, 0);
}
lpItem->bLocked = FALSE;
SetFocus (hLV);
}
}
}
if (LOWORD(wParam) == IDM_GPM_RENAME)
{
INT iIndex;
HWND hLV = GetDlgItem(hDlg, IDC_GPM_LIST);
//
// Enumerate through the selected items
//
iIndex = ListView_GetNextItem (hLV, -1,
LVNI_ALL | LVNI_SELECTED);
if (iIndex != -1)
{
ListView_EditLabel (hLV, iIndex);
}
}
if ((LOWORD(wParam) == IDC_GPM_PROPERTIES) || (LOWORD(wParam) == IDM_GPM_PROPERTIES))
{
pGPM->OnProperties (hDlg);
}
if (LOWORD(wParam) == IDM_GPM_REFRESH)
{
pGPM->RefreshGPM (hDlg, FALSE);
}
if (LOWORD(wParam) == IDC_GPM_BLOCK)
{
pGPM->m_bDirty = TRUE;
SendMessage (GetParent(hDlg), PSM_CHANGED, (WPARAM) hDlg, 0);
}
break;
case WM_NOTIFY:
pGPM = (CGroupPolicyMgr *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pGPM) {
break;
}
switch (((NMHDR FAR*)lParam)->code)
{
case NM_CUSTOMDRAW:
{
LPNMLVCUSTOMDRAW lplvcd = (LPNMLVCUSTOMDRAW)lParam;
SelectObject(lplvcd->nmcd.hdc, pGPM->m_hDefaultFont);
if ((lplvcd->nmcd.dwDrawStage == CDDS_PREPAINT) ||
(lplvcd->nmcd.dwDrawStage == CDDS_ITEMPREPAINT))
{
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, CDRF_NOTIFYSUBITEMDRAW);
return TRUE;
}
if ((lplvcd->nmcd.dwDrawStage == (CDDS_SUBITEM | CDDS_ITEMPREPAINT)) &&
(lplvcd->iSubItem > 0))
{
SelectObject(lplvcd->nmcd.hdc, pGPM->m_hMarlettFont);
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, CDRF_NEWFONT);
return TRUE;
}
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, CDRF_DODEFAULT);
return TRUE;
}
case LVN_GETDISPINFO:
{
NMLVDISPINFO * lpDispInfo = (NMLVDISPINFO *) lParam;
LPGPOITEM lpItem = (LPGPOITEM)lpDispInfo->item.lParam;
if (lpDispInfo->item.iSubItem == 0)
{
lpDispInfo->item.pszText = lpItem->lpDisplayName;
}
else
{
lpDispInfo->item.pszText = szNoCheckMark;
if ((lpDispInfo->item.iSubItem == 1) &&
(lpItem->dwOptions & GPO_FLAG_FORCE))
{
lpDispInfo->item.pszText = szCheckMark;
}
if ((lpDispInfo->item.iSubItem == 2) &&
(lpItem->dwOptions & GPO_FLAG_DISABLE))
{
lpDispInfo->item.pszText = szCheckMark;
}
}
}
break;
case LVN_DELETEITEM:
{
NMLISTVIEW * pLVInfo = (NMLISTVIEW *) lParam;
if (pLVInfo->lParam)
{
LocalFree ((LPTSTR)pLVInfo->lParam);
}
}
break;
case LVN_ITEMCHANGED:
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
break;
case LVN_ITEMACTIVATE:
{
LPNMITEMACTIVATE pItem = (LPNMITEMACTIVATE) lParam;
LPGPOITEM lpItem;
LVITEM item;
HWND hLV = GetDlgItem(hDlg, IDC_GPM_LIST);
if (pItem->uKeyFlags != 0)
{
break;
}
item.mask = LVIF_PARAM;
item.iItem = pItem->iItem;
item.iSubItem = 0;
if (!ListView_GetItem (hLV, &item))
{
break;
}
lpItem = (LPGPOITEM) item.lParam;
if (!lpItem)
{
break;
}
if (pItem->iSubItem == 0)
{
if (!lpItem->bReadOnly)
{
pGPM->StartGPE (lpItem->lpDSPath, hDlg);
}
}
else if (pItem->iSubItem == 1)
{
if (!pGPM->m_bReadOnly)
{
if (lpItem->dwOptions & GPO_FLAG_FORCE)
lpItem->dwOptions &= ~GPO_FLAG_FORCE;
else
lpItem->dwOptions |= GPO_FLAG_FORCE;
ListView_RedrawItems (hLV, pItem->iItem, pItem->iItem);
UpdateWindow (hLV);
pGPM->m_bDirty = TRUE;
SendMessage (GetParent(hDlg), PSM_CHANGED, (WPARAM) hDlg, 0);
}
}
else if (pItem->iSubItem == 2)
{
if (!pGPM->m_bReadOnly)
{
lpItem = (LPGPOITEM) item.lParam;
if (lpItem->dwOptions & GPO_FLAG_DISABLE)
{
lpItem->dwOptions &= ~GPO_FLAG_DISABLE;
}
else
{
if (bDisableWarningIssued)
{
lpItem->dwOptions |= GPO_FLAG_DISABLE;
}
else
{
TCHAR szMessage[200];
TCHAR szTitle[100];
bDisableWarningIssued = TRUE;
LoadString (g_hInstance, IDS_CONFIRMDISABLE, szMessage, ARRAYSIZE(szMessage));
LoadString (g_hInstance, IDS_CONFIRMTITLE2, szTitle, ARRAYSIZE(szTitle));
if (MessageBox (hDlg, szMessage, szTitle, MB_YESNO |
MB_ICONWARNING | MB_DEFBUTTON2) == IDYES) {
lpItem->dwOptions |= GPO_FLAG_DISABLE;
}
}
}
ListView_RedrawItems (hLV, pItem->iItem, pItem->iItem);
UpdateWindow (hLV);
pGPM->m_bDirty = TRUE;
SendMessage (GetParent(hDlg), PSM_CHANGED, (WPARAM) hDlg, 0);
}
}
}
break;
case LVN_BEGINLABELEDIT:
{
NMLVDISPINFO * pInfo = (NMLVDISPINFO *) lParam;
LPGPOITEM lpItem;
if (pInfo)
{
lpItem = (LPGPOITEM) pInfo->item.lParam;
if (lpItem)
{
if (lpItem->bReadOnly)
{
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, 1);
return TRUE;
}
else
{
HWND hEdit;
hEdit = ListView_GetEditControl(GetDlgItem(hDlg, IDC_GPM_LIST));
if (hEdit)
{
SetWindowText (hEdit, lpItem->lpGPOName);
}
}
}
}
}
break;
case LVN_ENDLABELEDIT:
{
NMLVDISPINFO * pInfo = (NMLVDISPINFO *) lParam;
LPGROUPPOLICYOBJECT pGPO;
LPGPOITEM lpItem, lpTemp;
LV_ITEM item;
HRESULT hr;
DWORD dwSize;
LPTSTR lpFullPath;
TCHAR szDisplayName[MAX_FRIENDLYNAME];
if (pInfo->item.pszText && (*pInfo->item.pszText))
{
//
// Get the LPGPOITEM pointer
//
lpItem = (LPGPOITEM) pInfo->item.lParam;
if (!lpItem)
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::GPMDlgProc: NULL lpGPOItem pointer")));
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, 0);
return TRUE;
}
if ( lpItem->bLocked )
{
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, 0);
return TRUE;
}
//
// Create a GPO object to work with
//
hr = CoCreateInstance(CLSID_GroupPolicyObject, NULL,
CLSCTX_SERVER, IID_IGroupPolicyObject,
(void **)&pGPO);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::GPMDlgProc: CoCreateInstance failed with 0x%x"), hr));
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, 0);
return TRUE;
}
lpFullPath = pGPM->GetFullGPOPath (lpItem->lpDSPath, hDlg);
if (!lpFullPath)
{
pGPO->Release();
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, 0);
return TRUE;
}
//
// Open GPO object without opening registry data
//
hr = pGPO->OpenDSGPO(lpFullPath, 0);
LocalFree (lpFullPath);
if (FAILED(hr))
{
ReportError(hDlg, hr, IDS_FAILEDDS);
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::GPMDlgProc: OpenDSGPO failed with 0x%x"), hr));
pGPO->Release();
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, 0);
return TRUE;
}
//
// Rename it
//
hr = pGPO->SetDisplayName(pInfo->item.pszText);
if (FAILED(hr))
{
ReportError(hDlg, hr, IDS_FAILEDSETNAME);
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::GPMDlgProc: SetDisplayName failed with 0x%x"), hr));
pGPO->Release();
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, 0);
return TRUE;
}
//
// Query for the display name again in case its been truncated
//
hr = pGPO->GetDisplayName(szDisplayName, ARRAYSIZE(szDisplayName));
if (FAILED(hr))
{
ReportError(hDlg, hr, IDS_FAILEDSETNAME);
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::GPMDlgProc: GetDisplayName failed with 0x%x"), hr));
pGPO->Release();
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, 0);
return TRUE;
}
pGPO->Release();
//
// Update the name in the LPGPOITEM structure
//
lpTemp = pGPM->CreateEntry (szDisplayName, lpItem->lpDSPath,
lpItem->dwOptions, lpItem->dwDisabled,
lpItem->bReadOnly);
if (!lpTemp) {
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::GPMDlgProc: Failed to create replacement entry.")));
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, 1);
return TRUE;
}
ZeroMemory (&item, sizeof(item));
item.mask = LVIF_PARAM;
item.iItem = pInfo->item.iItem;
item.lParam = (LPARAM)lpTemp;
ListView_SetItem (GetDlgItem (hDlg, IDC_GPM_LIST), &item);
LocalFree (lpItem);
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, 1);
}
}
return TRUE;
case LVN_KEYDOWN:
{
LPNMLVKEYDOWN pKey = (LPNMLVKEYDOWN) lParam;
if (pKey->wVKey == VK_DELETE)
{
if (!pGPM->m_bReadOnly)
{
PostMessage (hDlg, WM_COMMAND, IDC_GPM_DELETE, 0);
}
}
if (pKey->wVKey == VK_F5)
{
PostMessage (hDlg, WM_COMMAND, IDM_GPM_REFRESH, 0);
}
if (pKey->wVKey == VK_RETURN)
{
PostMessage (hDlg, WM_COMMAND, IDM_GPM_PROPERTIES, 0);
}
if (pKey->wVKey == VK_F2)
{
HWND hLV;
int i;
LPGPOITEM lpItem;
LV_ITEM item;
//
// Allow the rename only if it is possible to rename
//
//
// Get the selected item (if any)
//
hLV = GetDlgItem (hDlg, IDC_GPM_LIST);
i = ListView_GetNextItem(GetDlgItem (hDlg, IDC_GPM_LIST), -1, LVNI_SELECTED);
if (i >= 0)
{
//
// Get the lpGPOItem structure pointer
//
ZeroMemory(&item, sizeof(item));
item.mask = LVIF_PARAM;
item.iItem = i;
ListView_GetItem(hLV, &item);
lpItem = (LPGPOITEM)item.lParam;
if ( (lpItem) && (!(lpItem->bReadOnly)) ) {
PostMessage (hDlg, WM_COMMAND, IDM_GPM_RENAME, 0);
}
}
}
}
break;
case PSN_APPLY:
{
PSHNOTIFY * pNotify = (PSHNOTIFY *) lParam;
if (!pGPM->Save(hDlg))
{
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID);
return TRUE;
}
}
// fall through...
case PSN_RESET:
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
return TRUE;
}
break;
case WM_REFRESHDISPLAY:
{
INT iIndex, iCount;
LPGPOITEM lpItem = NULL;
HWND hLV = GetDlgItem(hDlg, IDC_GPM_LIST);
LVITEM item;
pGPM = (CGroupPolicyMgr *) GetWindowLongPtr (hDlg, DWLP_USER);
iIndex = ListView_GetNextItem (hLV, -1,
LVNI_ALL | LVNI_SELECTED);
if (iIndex != -1)
{
item.mask = LVIF_PARAM;
item.iItem = iIndex;
item.iSubItem = 0;
if (!ListView_GetItem (hLV, &item))
{
break;
}
lpItem = (LPGPOITEM) item.lParam;
}
if (pGPM && (!pGPM->m_bReadOnly))
{
if (iIndex != -1)
{
EnableWindow (GetDlgItem (hDlg, IDC_GPM_DELETE), TRUE);
if (lpItem && !lpItem->bReadOnly)
{
EnableWindow (GetDlgItem (hDlg, IDC_GPM_EDIT), TRUE);
}
else
{
EnableWindow (GetDlgItem (hDlg, IDC_GPM_EDIT), FALSE);
}
EnableWindow (GetDlgItem (hDlg, IDC_GPM_OPTIONS), TRUE);
EnableWindow (GetDlgItem (hDlg, IDC_GPM_PROPERTIES), TRUE);
iCount = ListView_GetItemCount(hLV);
if (iIndex > 0)
EnableWindow (GetDlgItem (hDlg, IDC_GPM_UP), TRUE);
else
EnableWindow (GetDlgItem (hDlg, IDC_GPM_UP), FALSE);
if (iIndex < (iCount - 1))
EnableWindow (GetDlgItem (hDlg, IDC_GPM_DOWN), TRUE);
else
EnableWindow (GetDlgItem (hDlg, IDC_GPM_DOWN), FALSE);
}
else
{
EnableWindow (GetDlgItem (hDlg, IDC_GPM_DELETE), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_GPM_EDIT), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_GPM_UP), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_GPM_DOWN), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_GPM_OPTIONS), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_GPM_PROPERTIES), FALSE);
}
}
else
{
if (lpItem)
{
EnableWindow (GetDlgItem (hDlg, IDC_GPM_PROPERTIES), TRUE);
if (!lpItem->bReadOnly)
{
EnableWindow (GetDlgItem (hDlg, IDC_GPM_EDIT), TRUE);
}
else
{
EnableWindow (GetDlgItem (hDlg, IDC_GPM_EDIT), FALSE);
}
}
else
{
EnableWindow (GetDlgItem (hDlg, IDC_GPM_PROPERTIES), FALSE);
}
}
}
break;
case WM_CONTEXTMENU:
if (GetDlgItem(hDlg, IDC_GPM_LIST) == (HWND)wParam)
{
pGPM = (CGroupPolicyMgr *) GetWindowLongPtr (hDlg, DWLP_USER);
if (pGPM)
{
pGPM->OnContextMenu(hDlg, lParam);
}
}
else
{
// right mouse click
WinHelp((HWND) wParam, HELP_FILE, HELP_CONTEXTMENU,
(ULONG_PTR) (LPSTR) aGroupPolicyMgrHelpIds);
}
return TRUE;
case WM_HELP: // F1
WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, HELP_FILE, HELP_WM_HELP,
(ULONG_PTR) (LPSTR) aGroupPolicyMgrHelpIds);
break;
}
return FALSE;
}
void CGroupPolicyMgr::OnContextMenu(HWND hDlg, LPARAM lParam)
{
LPGPOITEM lpItem;
LV_ITEM item;
HMENU hPopup;
HWND hLV;
int i;
RECT rc;
POINT pt;
//
// Get the selected item (if any)
//
hLV = GetDlgItem (hDlg, IDC_GPM_LIST);
i = ListView_GetNextItem(hLV, -1, LVNI_SELECTED);
//
// Figure out where to place the context menu
//
pt.x = ((int)(short)LOWORD(lParam));
pt.y = ((int)(short)HIWORD(lParam));
GetWindowRect (hLV, &rc);
if (!PtInRect (&rc, pt))
{
if ((lParam == (LPARAM) -1) && (i >= 0))
{
rc.left = LVIR_SELECTBOUNDS;
SendMessage (hLV, LVM_GETITEMRECT, i, (LPARAM) &rc);
pt.x = rc.left + 8;
pt.y = rc.top + ((rc.bottom - rc.top) / 2);
ClientToScreen (hLV, &pt);
}
else
{
pt.x = rc.left + ((rc.right - rc.left) / 2);
pt.y = rc.top + ((rc.bottom - rc.top) / 2);
}
}
//
// Load the context menu
//
hPopup = LoadMenu(g_hInstance, MAKEINTRESOURCE(IDM_GPM_CONTEXTMENU));
if (!hPopup) {
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::OnContextMenu: LoadMenu failed with error %d"), GetLastError()));
return;
}
HMENU hSubMenu = GetSubMenu(hPopup, 0);
//
// If there is an item selected, then set the checkmarks appropriately
//
if (i >= 0)
{
//
// Get the lpGPOItem structure pointer
//
ZeroMemory(&item, sizeof(item));
item.mask = LVIF_PARAM;
item.iItem = i;
ListView_GetItem(hLV, &item);
lpItem = (LPGPOITEM)item.lParam;
if (!lpItem)
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::OnContextMenu: Failed to get lpGPOItem pointer")));
return;
}
//
// Check the menu items
//
if (lpItem->dwOptions & GPO_FLAG_DISABLE)
{
CheckMenuRadioItem(hSubMenu, IDM_GPM_DISABLED, IDM_GPM_DISABLED,
IDM_GPM_DISABLED, MF_BYCOMMAND);
}
if (lpItem->dwOptions & GPO_FLAG_FORCE)
{
CheckMenuRadioItem(hSubMenu, IDM_GPM_NOOVERRIDE, IDM_GPM_NOOVERRIDE,
IDM_GPM_NOOVERRIDE, MF_BYCOMMAND);
}
RemoveMenu(hSubMenu, 9, MF_BYPOSITION);
RemoveMenu(hSubMenu, IDM_GPM_REFRESH, MF_BYCOMMAND);
//
// Gray out Edit / Rename if read only
//
if (lpItem->bReadOnly)
{
EnableMenuItem (hSubMenu, IDM_GPM_EDIT, MF_BYCOMMAND | MF_GRAYED);
EnableMenuItem (hSubMenu, IDM_GPM_RENAME, MF_BYCOMMAND | MF_GRAYED);
}
}
else
{
//
// No item selected, remove some of the items on the
// context menu
//
RemoveMenu(hSubMenu, IDM_GPM_NOOVERRIDE, MF_BYCOMMAND);
RemoveMenu(hSubMenu, IDM_GPM_DISABLED, MF_BYCOMMAND);
RemoveMenu(hSubMenu, 0, MF_BYPOSITION);
RemoveMenu(hSubMenu, IDM_GPM_EDIT, MF_BYCOMMAND);
RemoveMenu(hSubMenu, IDM_GPM_DELETE, MF_BYCOMMAND);
RemoveMenu(hSubMenu, IDM_GPM_RENAME, MF_BYCOMMAND);
RemoveMenu(hSubMenu, IDM_GPM_PROPERTIES, MF_BYCOMMAND);
RemoveMenu(hSubMenu, (GetMenuItemCount(hSubMenu) - 1), MF_BYPOSITION);
RemoveMenu(hSubMenu, (GetMenuItemCount(hSubMenu) - 2), MF_BYPOSITION);
}
//
// Gray out some menu items in read only mode
//
if (m_bReadOnly)
{
EnableMenuItem (hSubMenu, IDM_GPM_NEW, MF_BYCOMMAND | MF_GRAYED);
EnableMenuItem (hSubMenu, IDM_GPM_ADD, MF_BYCOMMAND | MF_GRAYED);
EnableMenuItem (hSubMenu, IDM_GPM_DELETE, MF_BYCOMMAND | MF_GRAYED);
EnableMenuItem (hSubMenu, IDM_GPM_NOOVERRIDE, MF_BYCOMMAND | MF_GRAYED);
EnableMenuItem (hSubMenu, IDM_GPM_DISABLED, MF_BYCOMMAND | MF_GRAYED);
}
//
// Display the menu
//
TrackPopupMenu(hSubMenu, TPM_LEFTALIGN, pt.x, pt.y, 0, hDlg, NULL);
DestroyMenu(hPopup);
}
void CGroupPolicyMgr::OnProperties(HWND hDlg)
{
INT iIndex;
LVITEM item;
HWND hLV;
HRESULT hr;
LPGPOITEM pItem;
LPGROUPPOLICYOBJECT pGPO;
HPROPSHEETPAGE *hPages;
UINT i, uPageCount;
PROPSHEETHEADER psh;
LPTSTR lpTemp;
//
// Get the selected item
//
hLV = GetDlgItem (hDlg, IDC_GPM_LIST);
iIndex = ListView_GetNextItem(hLV, -1, LVNI_ALL | LVNI_SELECTED);
if (iIndex >= 0)
{
SetWaitCursor();
//
// Get the lpGPOItem pointer
//
ZeroMemory(&item, sizeof(item));
item.mask = LVIF_PARAM;
item.iItem = iIndex;
ListView_GetItem(hLV, &item);
pItem = (LPGPOITEM)item.lParam;
if (!pItem)
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::OnProperties: Failed to get lpGPOItem pointer")));
ClearWaitCursor();
return;
}
pItem->bLocked = TRUE;
hr = CoCreateInstance (CLSID_GroupPolicyObject, NULL,
CLSCTX_SERVER, IID_IGroupPolicyObject,
(void**)&pGPO);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::OnProperties: CoCreateInstance failed with 0x%x"), hr));
pItem->bLocked = FALSE;
ClearWaitCursor();
return;
}
lpTemp = GetFullGPOPath (pItem->lpDSPath, hDlg);
if (!lpTemp)
{
ClearWaitCursor();
pItem->bLocked = FALSE;
ReportError(hDlg, hr, IDS_FAILEDDS);
return;
}
//
// Open the requested object without mounting the registry
//
hr = pGPO->OpenDSGPO(lpTemp, pItem->bReadOnly ? GPO_OPEN_READ_ONLY : 0);
LocalFree (lpTemp);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::OnProperties: Failed to open GPO object with 0x%x"), hr));
pItem->bLocked = FALSE;
ClearWaitCursor();
ReportError(hDlg, hr, IDS_FAILEDDS);
return;
}
//
// Ask the GPO for the property sheet pages
//
hr = pGPO->GetPropertySheetPages (&hPages, &uPageCount);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::OnProperties: Failed to query property sheet pages with 0x%x."), hr));
pGPO->Release();
pItem->bLocked = FALSE;
ClearWaitCursor();
return;
}
//
// Display the property sheet
//
ZeroMemory (&psh, sizeof(psh));
psh.dwSize = sizeof(psh);
psh.dwFlags = PSH_PROPTITLE;
psh.hwndParent = hDlg;
psh.hInstance = g_hInstance;
psh.pszCaption = pItem->lpDisplayName;
psh.nPages = uPageCount;
psh.phpage = hPages;
PropertySheet (&psh);
LocalFree (hPages);
pGPO->Release();
CheckIconStatus (hLV, pItem);
pItem->bLocked = FALSE;
ClearWaitCursor();
}
}
void CGroupPolicyMgr::OnNew(HWND hDlg)
{
HRESULT hr;
HWND hLV;
INT iIndex;
LPGROUPPOLICYOBJECT pGPO = NULL;
TCHAR szName[256];
TCHAR szGPOPath[MAX_PATH];
LPOLESTR lpDomain = NULL;
HKEY hKey;
DWORD dwSize, dwType;
BOOL bDisabledLink = FALSE;
//
// Check if there is a user preference or policy that
// any new GPOs should be created with a disabled link
// by default
//
if (RegOpenKeyEx (HKEY_CURRENT_USER, GPE_KEY, 0,
KEY_READ, &hKey) == ERROR_SUCCESS)
{
dwSize = sizeof(bDisabledLink);
RegQueryValueEx (hKey, NEW_LINKS_DISABLED_VALUE, NULL, &dwType,
(LPBYTE) &bDisabledLink, &dwSize);
RegCloseKey (hKey);
}
if (RegOpenKeyEx (HKEY_CURRENT_USER, GPE_POLICIES_KEY, 0,
KEY_READ, &hKey) == ERROR_SUCCESS)
{
dwSize = sizeof(bDisabledLink);
RegQueryValueEx (hKey, NEW_LINKS_DISABLED_VALUE, NULL, &dwType,
(LPBYTE) &bDisabledLink, &dwSize);
RegCloseKey (hKey);
}
//
// Get the domain name
//
lpDomain = GetDomainFromLDAPPath(m_lpDSObject);
if (!lpDomain)
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::OnNew: Failed to get the domain name")));
goto Exit;
}
//
// Create a new GPO object to work with
//
hr = CoCreateInstance (CLSID_GroupPolicyObject, NULL,
CLSCTX_SERVER, IID_IGroupPolicyObject,
(void**)&pGPO);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::OnNew: CoCreateInstance failed with 0x%x"), hr));
goto Exit;
}
//
// Create a new GPO without mounting the registry
//
GetNewGPODisplayName (szName, ARRAYSIZE(szName));
#if FGPO_SUPPORT
hr = pGPO->New(lpDomain, szName, (m_gpHint == GPHintForest) ? GPO_OPEN_FOREST : 0);
#else
hr = pGPO->New(lpDomain, szName, 0);
#endif
if (FAILED(hr))
{
ReportError(hDlg, hr, IDS_FAILEDNEW);
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::OnNew: Failed to create GPO object with 0x%x"), hr));
goto Exit;
}
hr = pGPO->GetPath(szGPOPath, ARRAYSIZE(szGPOPath));
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::OnNew: Failed to get GPO object path with 0x%x"), hr));
pGPO->Delete();
goto Exit;
}
//
// Add the GPO to the list view
//
hLV = GetDlgItem (hDlg, IDC_GPM_LIST);
if (!AddGPOToList (hLV, szName, szGPOPath,
(bDisabledLink ? GPO_FLAG_DISABLE : 0), FALSE, FALSE, FALSE))
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::OnNew: Failed to add the GPO to the listview")));
pGPO->Delete();
goto Exit;
}
m_bDirty = TRUE;
Save(hDlg);
SendMessage (GetParent(hDlg), PSM_CANCELTOCLOSE, 0, 0);
iIndex = ListView_GetItemCount(hLV) - 1;
//
// Now trigger an edit of the entry
//
SetFocus(hLV);
ListView_EnsureVisible (hLV, iIndex, FALSE);
ListView_EditLabel(hLV, iIndex);
Exit:
if (lpDomain)
{
delete [] lpDomain;
}
if (pGPO)
{
pGPO->Release();
}
}
BOOL CGroupPolicyMgr::RefreshGPM (HWND hDlg, BOOL bInitial)
{
HRESULT hr;
BOOL bResult = FALSE;
TCHAR szHeaderName[50];
TCHAR szBuffer1[100];
TCHAR szBuffer2[MAX_FRIENDLYNAME];
HWND hLV = GetDlgItem (hDlg, IDC_GPM_LIST);
LV_COLUMN col;
RECT rc;
INT iTotal = 0, iCurrent, iMaxVisibleItems, iSize;
IADs * pADs;
VARIANT var;
BSTR bstrProperty;
//
// Prep work
//
SetWaitCursor();
SendMessage (hLV, WM_SETREDRAW, 0, 0);
ListView_DeleteAllItems(hLV);
CheckDlgButton (hDlg, IDC_GPM_BLOCK, BST_UNCHECKED);
//
// Insert Columns
//
if (bInitial)
{
GetClientRect (hLV, &rc);
LoadString(g_hInstance, IDS_GPM_NAME, szHeaderName, ARRAYSIZE(szHeaderName));
col.mask = LVCF_FMT | LVCF_TEXT | LVCF_SUBITEM | LVCF_WIDTH;
col.fmt = LVCFMT_LEFT;
iCurrent = (int)(rc.right * .65);
iTotal += iCurrent;
col.cx = iCurrent;
col.pszText = szHeaderName;
col.iSubItem = 0;
ListView_InsertColumn (hLV, 0, &col);
LoadString(g_hInstance, IDS_GPM_NOOVERRIDE, szHeaderName, ARRAYSIZE(szHeaderName));
iCurrent = (int)(rc.right * .20);
iTotal += iCurrent;
col.cx = iCurrent;
col.fmt = LVCFMT_CENTER;
col.iSubItem = 1;
ListView_InsertColumn (hLV, 1, &col);
LoadString(g_hInstance, IDS_GPM_DISABLED, szHeaderName, ARRAYSIZE(szHeaderName));
col.iSubItem = 2;
col.cx = rc.right - iTotal;
col.fmt = LVCFMT_CENTER;
ListView_InsertColumn (hLV, 2, &col);
}
//
// Set the DC name
//
if (bInitial)
{
LoadString (g_hInstance, IDS_GPM_DCNAME, szBuffer1, ARRAYSIZE(szBuffer1));
hr = StringCchPrintf (szBuffer2, ARRAYSIZE(szBuffer2), szBuffer1 , m_lpGPODCName);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::RefreshGPM:Could not copy DC name due to 0x%x"), hr));
ReportError(hDlg, hr, IDS_FAILEDGPQUERY, hr);
goto Exit;
}
SetDlgItemText (hDlg, IDC_GPM_DCNAME, szBuffer2);
}
//
// Bind to the object and get the friendly name
//
hr = OpenDSObject(m_lpDSObject, IID_IADs, (void **)&pADs);
if (FAILED(hr)) {
if (hr == HRESULT_FROM_WIN32(ERROR_DS_NO_SUCH_OBJECT))
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::RefreshGPM: %s does not exist on the server."), m_lpDSObject));
DialogBoxParam (g_hInstance, MAKEINTRESOURCE(IDD_NODSOBJECT),
hDlg, NoDSObjectDlgProc, (LPARAM) this);
}
else
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::RefreshGPM: OpenDSObject failed with 0x%x"), hr));
ReportError(hDlg, hr, IDS_FAILEDGPQUERY, hr);
}
goto Exit;
}
if (bInitial)
{
#if FGPO_SUPPORT
if (m_gpHint != GPHintForest)
{
#endif
VariantInit(&var);
bstrProperty = SysAllocString (GPM_NAME_PROPERTY);
if (!bstrProperty)
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::RefreshGPM: Failed to allocate memory with %d"), GetLastError()));
ReportError(hDlg, hr, IDS_FAILEDGPQUERY, hr);
VariantClear (&var);
pADs->Release();
goto Exit;
}
hr = pADs->Get(bstrProperty, &var);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::RefreshGPM: Failed to query for display name with 0x%x"), hr));
ReportError(hDlg, hr, IDS_FAILEDGPQUERY, hr);
SysFreeString (bstrProperty);
VariantClear (&var);
pADs->Release();
goto Exit;
}
LoadString (g_hInstance, IDS_GPM_DESCRIPTION, szBuffer1, ARRAYSIZE(szBuffer1));
hr = StringCchPrintf (szBuffer2, ARRAYSIZE(szBuffer2), szBuffer1, var.bstrVal);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::RefreshGPM: Failed to copy GPM description with 0x%x"), hr));
ReportError(hDlg, hr, IDS_FAILEDGPQUERY, hr);
SysFreeString (bstrProperty);
VariantClear (&var);
pADs->Release();
goto Exit;
}
SysFreeString (bstrProperty);
VariantClear (&var);
#if FGPO_SUPPORT
}
else
{
LoadString (g_hInstance, IDS_GPM_FORESTDESC, szBuffer2, ARRAYSIZE(szBuffer2));
}
#endif
SetDlgItemText (hDlg, IDC_GPM_TITLE, szBuffer2);
//
// Check if the user has write access to gPLink
//
hr = CheckDSWriteAccess ((LPUNKNOWN)pADs, TEXT("gPLink"));
if (FAILED(hr))
{
DebugMsg((DM_VERBOSE, TEXT("CGroupPolicyObject::RefreshGPM: User has read only access to the gPLink property.")));
m_bReadOnly = TRUE;
}
}
//
// Get the options for this DS object
//
VariantInit(&var);
bstrProperty = SysAllocString (GPM_OPTIONS_PROPERTY);
if (bstrProperty)
{
hr = pADs->Get(bstrProperty, &var);
if (SUCCEEDED(hr))
{
if (var.lVal & GPC_BLOCK_POLICY)
{
CheckDlgButton (hDlg, IDC_GPM_BLOCK, BST_CHECKED);
}
}
SysFreeString (bstrProperty);
}
VariantClear (&var);
//
// Get the GPOs linked to this object
//
VariantInit(&var);
bstrProperty = SysAllocString (GPM_LINK_PROPERTY);
if (bstrProperty)
{
hr = pADs->Get(bstrProperty, &var);
if (SUCCEEDED(hr))
{
AddGPOs (hDlg, var.bstrVal);
}
SysFreeString (bstrProperty);
}
VariantClear (&var);
pADs->Release();
//
// Get the max number of visible items and the total number
// of items in the listview
//
if (bInitial)
{
iMaxVisibleItems = ListView_GetCountPerPage (hLV);
iTotal = ListView_GetItemCount(hLV);
//
// If the number of items in the listview is greater than
// the max visible items, then we need to make the first
// column smaller by the width of a vertical scroll bar so
// that the horizontal scroll bar doesn't appear
//
if (iTotal > iMaxVisibleItems) {
iSize = ListView_GetColumnWidth (hLV, 0);
iSize -= GetSystemMetrics(SM_CYHSCROLL);
ListView_SetColumnWidth (hLV, 0, iSize);
}
}
PropSheet_UnChanged (GetParent(hDlg), hDlg);
//
// Success
//
bResult = TRUE;
Exit:
SendMessage (hLV, WM_SETREDRAW, 1, 0);
ClearWaitCursor();
return bResult;
}
BOOL CGroupPolicyMgr::OnInitDialog (HWND hDlg)
{
BOOL bResult = FALSE;
HWND hLV = GetDlgItem (hDlg, IDC_GPM_LIST);
LOGFONT lf;
HICON hIcon;
HIMAGELIST hImageList;
HRESULT hr;
LPOLESTR pszDomain;
LPTSTR lpTemp;
//
// Retreive the name of the DC DSAdmin is using
//
m_lpDSADCName = ExtractServerName (m_lpDSObject);
DebugMsg((DM_VERBOSE, TEXT("CGroupPolicyObject::OnInitDialog: DS Admin is focused on DC %s"),
m_lpDSADCName));
//
// Get the friendly domain name
//
pszDomain = GetDomainFromLDAPPath(m_lpDSObject);
if (!pszDomain)
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyObject::OnInitDialog: Failed to get domain name")));
return FALSE;
}
//
// Convert LDAP to dot (DN) style
//
hr = ConvertToDotStyle (pszDomain, &m_lpDomainName);
delete [] pszDomain;
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyObject::CreatePropertyPages: Failed to convert domain name with 0x%x"), hr));
}
//
// Get the GPO DC for this domain
//
m_lpGPODCName = GetDCName (m_lpDomainName, m_lpDSADCName, hDlg, TRUE, VALIDATE_INHERIT_DC);
if (!m_lpGPODCName)
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyObject::OnInitDialog: Failed to get DC name for %s"),
m_lpDomainName));
return FALSE;
}
//
// Switch to using the GPO domain controller for this DS object
//
lpTemp = MakeFullPath (m_lpDSObject, m_lpGPODCName);
if (!lpTemp)
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyObject::OnInitDialog: Failed to build new DS object path")));
return FALSE;
}
LocalFree (m_lpDSObject);
m_lpDSObject = lpTemp;
//
// Create the Marlett font based upon the currently selected font
//
m_hDefaultFont = (HFONT) SendMessage (hLV, WM_GETFONT, 0, 0);
GetObject (m_hDefaultFont, sizeof(lf), &lf);
lf.lfHeight += (LONG)(lf.lfHeight * .20);
lf.lfCharSet = SYMBOL_CHARSET;
lf.lfPitchAndFamily = FF_DECORATIVE | DEFAULT_PITCH;
hr = StringCchCopy (lf.lfFaceName, ARRAYSIZE(lf.lfFaceName), TEXT("Marlett"));
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::OnInitDialog: Failed to copy font name with 0x%x"), hr));
return FALSE;
}
m_hMarlettFont = CreateFontIndirect (&lf);
//
// Set extended LV styles
//
SendMessage(hLV, LVM_SETEXTENDEDLISTVIEWSTYLE, 0,
LVS_EX_FULLROWSELECT | LVS_EX_LABELTIP);
//
// Create the imagelist
//
hImageList = ImageList_Create (16, 16, ILC_MASK, 3, 3);
if (!hImageList)
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::OnInitDialog: Failed to create the image list")));
return FALSE;
}
hIcon = (HICON) LoadImage (g_hInstance, MAKEINTRESOURCE(IDI_POLICY),
IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
ImageList_AddIcon (hImageList, hIcon);
DestroyIcon (hIcon);
hIcon = (HICON) LoadImage (g_hInstance, MAKEINTRESOURCE(IDI_POLICY2),
IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
ImageList_AddIcon (hImageList, hIcon);
DestroyIcon (hIcon);
hIcon = (HICON) LoadImage (g_hInstance, MAKEINTRESOURCE(IDI_POLICY3),
IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
ImageList_AddIcon (hImageList, hIcon);
DestroyIcon (hIcon);
//
// Associate the imagelist with the listview.
// The listview will free this when the
// control is destroyed.
//
SendMessage (hLV, LVM_SETIMAGELIST, LVSIL_SMALL, (LPARAM) hImageList);
//
// Refresh GPM
//
if (!RefreshGPM(hDlg, TRUE))
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::OnInitDialog: Failed to refresh GPM")));
return FALSE;
}
return TRUE;
}
BOOL CGroupPolicyMgr::Save (HWND hDlg)
{
HRESULT hr;
HWND hLV = GetDlgItem (hDlg, IDC_GPM_LIST);
IADs * pADs;
VARIANT var;
BSTR bstrName;
LVITEM item;
LPGPOITEM lpItem;
TCHAR szOptions[12];
LPTSTR lpTemp, lpResult = NULL;
DWORD dwStrLen, dwOptions;
TCHAR szEmpty [] = TEXT(" ");
INT iIndex = -1;
if (m_bReadOnly)
{
DebugMsg((DM_VERBOSE, TEXT("CGroupPolicyMgr::Save: User only has read access, so no changes will be saved.")));
return TRUE;
}
if (!m_bDirty)
{
DebugMsg((DM_VERBOSE, TEXT("CGroupPolicyMgr::Save: Nothing has changed (dirty flag is FALSE), so no changes will be saved.")));
return TRUE;
}
//
// Enumerate through the selected items
//
while ((iIndex = ListView_GetNextItem (hLV, iIndex, LVNI_ALL)) != -1)
{
item.mask = LVIF_PARAM;
item.iItem = iIndex;
item.iSubItem = 0;
if (!ListView_GetItem (hLV, &item))
{
continue;
}
lpItem = (LPGPOITEM) item.lParam;
_itot(lpItem->dwOptions, szOptions, 10);
// [ ldap path ; options ] 0
dwStrLen = 1 + lstrlen(lpItem->lpDSPath) + 1 + lstrlen(szOptions) + 1 + 1;
if (lpResult)
{
dwStrLen += lstrlen(lpResult);
}
dwStrLen *= sizeof(TCHAR);
lpTemp = (LPTSTR) LocalAlloc (LPTR, dwStrLen);
if (!lpTemp)
{
continue;
}
ULONG ulNoChars;
ulNoChars = lstrlen(TEXT("[")) + 1;
hr = StringCchCopy (lpTemp, ulNoChars, TEXT("["));
ASSERT(SUCCEEDED(hr));
ulNoChars += lstrlen(lpItem->lpDSPath) + 1;
hr = StringCchCat (lpTemp, ulNoChars, lpItem->lpDSPath);
ASSERT(SUCCEEDED(hr));
ulNoChars += lstrlen(TEXT(";")) + 1;
hr = StringCchCat (lpTemp, ulNoChars, TEXT(";"));
ASSERT(SUCCEEDED(hr));
ulNoChars += lstrlen(szOptions) + 1;
hr = StringCchCat (lpTemp, ulNoChars, szOptions);
ASSERT(SUCCEEDED(hr));
ulNoChars += lstrlen(TEXT("]")) + 1;
hr = StringCchCat (lpTemp, ulNoChars, TEXT("]"));
ASSERT(SUCCEEDED(hr));
if (lpResult)
{
ulNoChars += lstrlen(lpResult) + 1;
hr = StringCchCat (lpTemp, ulNoChars, lpResult);
ASSERT(SUCCEEDED(hr));
}
LocalFree (lpResult);
lpResult = lpTemp;
}
if (!lpResult)
{
lpResult = szEmpty;
}
//
// Bind to the DS object
//
hr = OpenDSObject(m_lpDSObject, IID_IADs, (void **)&pADs);
if (FAILED(hr)) {
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::Save: Failed to get gpo interface with 0x%x"), hr));
ReportError(hDlg, hr, IDS_FAILEDGPINFO);
return FALSE;
}
//
// Set the link property
//
VariantInit(&var);
var.vt = VT_BSTR;
var.bstrVal = SysAllocString (lpResult);
if (!var.bstrVal)
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::Save: Failed to allocate memory with %d"), GetLastError()));
ReportError(hDlg, hr, IDS_FAILEDGPINFO);
VariantClear (&var);
pADs->Release();
return FALSE;
}
bstrName = SysAllocString (GPM_LINK_PROPERTY);
if (!bstrName)
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::Save: Failed to allocate memory with %d"), GetLastError()));
ReportError(hDlg, hr, IDS_FAILEDGPINFO);
VariantClear (&var);
pADs->Release();
return FALSE;
}
hr = pADs->Put(bstrName, var);
SysFreeString (bstrName);
VariantClear (&var);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::Save: Failed to put link property with 0x%x"), hr));
ReportError(hDlg, hr, IDS_FAILEDGPINFO);
pADs->Release();
return FALSE;
}
dwOptions = 0;
if (IsDlgButtonChecked (hDlg, IDC_GPM_BLOCK) == BST_CHECKED)
{
dwOptions |= GPC_BLOCK_POLICY;
}
//
// Set the options
//
VariantInit(&var);
var.vt = VT_I4;
var.lVal = dwOptions;
bstrName = SysAllocString (GPM_OPTIONS_PROPERTY);
if (!bstrName)
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::Save: Failed to allocate memory with %d"), GetLastError()));
ReportError(hDlg, hr, IDS_FAILEDGPINFO);
VariantClear (&var);
pADs->Release();
return FALSE;
}
hr = pADs->Put(bstrName, var);
SysFreeString (bstrName);
VariantClear (&var);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::Save: Failed to set options with 0x%x"), hr));
ReportError(hDlg, hr, IDS_FAILEDGPINFO);
pADs->Release();
return FALSE;
}
//
// Commit the changes
//
hr = pADs->SetInfo();
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::Save: Failed to commit changes with 0x%x"), hr));
ReportError(hDlg, hr, IDS_FAILEDGPINFO);
pADs->Release();
return FALSE;
}
if (lpResult != szEmpty)
{
LocalFree (lpResult);
}
pADs->Release();
m_bDirty = FALSE;
return TRUE;
}
BOOL CGroupPolicyMgr::AddGPOs (HWND hDlg, LPTSTR lpGPOList)
{
HRESULT hr;
TCHAR szGPO[512];
TCHAR szOptions[20];
TCHAR szDisplayName[MAX_PATH];
DWORD dwOptions;
LPTSTR lpTemp, lpGPO, lpNamedGPO;
HWND hLV = GetDlgItem (hDlg, IDC_GPM_LIST);
IADs * pADs;
VARIANT var;
BSTR bstrProperty;
DWORD dwDisabled;
BOOL bReadOnly;
if (!lpGPOList)
{
return TRUE;
}
lpTemp = lpGPOList;
while (TRUE)
{
szDisplayName[0] = TEXT('\0');
dwDisabled = 0;
bReadOnly = FALSE;
//
// Look for the [
//
while (*lpTemp && (*lpTemp != TEXT('[')))
lpTemp++;
if (!(*lpTemp))
goto Exit;
lpTemp++;
//
// Copy the GPO name
//
lpGPO = szGPO;
while (*lpTemp && (*lpTemp != TEXT(';')))
*lpGPO++ = *lpTemp++;
*lpGPO = TEXT('\0');
if (!(*lpTemp))
goto Exit;
lpTemp++;
//
// Get the options
//
lpGPO = szOptions;
while (*lpTemp && (*lpTemp != TEXT(']')))
*lpGPO++ = *lpTemp++;
*lpGPO = TEXT('\0');
dwOptions = _ttoi (szOptions);
if (!(*lpTemp))
goto Exit;
lpTemp++;
//
// Convert the nameless path into a named path
//
lpNamedGPO = GetFullGPOPath (szGPO, hDlg);
if (lpNamedGPO)
{
//
// Get the friendly display name and GPO options
//
hr = OpenDSObject(lpNamedGPO, IID_IADs, (void **)&pADs);
if (SUCCEEDED(hr)) {
VariantInit(&var);
bstrProperty = SysAllocString (GPO_NAME_PROPERTY);
if (bstrProperty)
{
hr = pADs->Get(bstrProperty, &var);
if (SUCCEEDED(hr))
{
lstrcpyn (szDisplayName, var.bstrVal, ARRAYSIZE(szDisplayName));
}
SysFreeString (bstrProperty);
}
VariantClear (&var);
//
// Query for the options
//
VariantInit(&var);
bstrProperty = SysAllocString (GPO_OPTIONS_PROPERTY);
if (bstrProperty)
{
hr = pADs->Get(bstrProperty, &var);
if (SUCCEEDED(hr))
{
dwDisabled = var.lVal;
}
SysFreeString (bstrProperty);
}
VariantClear (&var);
if (FAILED(CheckDSWriteAccess((LPUNKNOWN) pADs, GPO_VERSION_PROPERTY)))
{
bReadOnly = TRUE;
}
pADs->Release();
}
else
{
if (hr == HRESULT_FROM_WIN32(ERROR_DS_NO_SUCH_OBJECT))
{
DebugMsg((DM_VERBOSE, TEXT("CGroupPolicyMgr::AddGPOs: Skipping link to deleted object. %s"), lpNamedGPO));
LocalFree (lpNamedGPO);
continue;
}
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::AddGPOs: OpenDSObject failed with 0x%x"), hr));
}
LocalFree (lpNamedGPO);
}
else
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyMgr::AddGPOs: Failed to get the full domain name for %s"), szGPO));
}
if (szDisplayName[0] == TEXT('\0'))
{
LoadString (g_hInstance, IDS_GPM_NOGPONAME, szDisplayName, ARRAYSIZE(szDisplayName));
dwDisabled = (GPO_OPTION_DISABLE_USER | GPO_OPTION_DISABLE_MACHINE);
bReadOnly = TRUE;
}
AddGPOToList (hLV, szDisplayName, szGPO, dwOptions, TRUE, dwDisabled, bReadOnly);
}
Exit:
return TRUE;
}
LPGPOITEM CGroupPolicyMgr::CreateEntry (LPTSTR szName, LPTSTR szGPO, DWORD dwOptions,
DWORD dwDisabled, BOOL bReadOnly)
{
LPGPOITEM lpItem;
DWORD dwSize;
TCHAR szFormat[20];
LPTSTR lpResult, lpName = szName, lpFullName = NULL;
LPOLESTR pszDomain;
HRESULT hr;
ULONG ulNoChars;
//
// Check if the GPO is in this domain
//
pszDomain = GetDomainFromLDAPPath(szGPO);
if (pszDomain)
{
if (SUCCEEDED(ConvertToDotStyle (pszDomain, &lpResult)))
{
if (lstrcmpi(lpResult, m_lpDomainName) != 0)
{
LoadString (g_hInstance, IDS_GPM_DOMAINNAME, szFormat,
ARRAYSIZE(szFormat));
ulNoChars = lstrlen (szName) + lstrlen (szFormat) + lstrlen (lpResult);
lpFullName = (LPTSTR) LocalAlloc (LPTR, ulNoChars * sizeof(TCHAR));
if (lpFullName)
{
hr = StringCchPrintf (lpFullName, ulNoChars, szFormat, szName, lpResult);
if (FAILED(hr))
{
LocalFree(lpFullName);
delete [] pszDomain;
return NULL;
}
lpName = lpFullName;
}
}
LocalFree (lpResult);
}
delete [] pszDomain;
}
//
// Calculate the size needed and fill in the structure
//
dwSize = sizeof(GPOITEM);
dwSize += ((lstrlen(lpName) + 1) * sizeof(TCHAR));
dwSize += ((lstrlen(szName) + 1) * sizeof(TCHAR));
dwSize += ((lstrlen(szGPO) + 1) * sizeof(TCHAR));
lpItem = (LPGPOITEM) LocalAlloc (LPTR, dwSize);
if (!lpItem)
{
if (lpFullName)
{
LocalFree (lpFullName);
}
return NULL;
}
lpItem->lpDisplayName = (LPTSTR) (((LPBYTE)lpItem) + sizeof(GPOITEM));
ulNoChars = (dwSize - sizeof(GPOITEM))/sizeof(WCHAR);
hr = StringCchCopy (lpItem->lpDisplayName, ulNoChars, lpName);
if (SUCCEEDED(hr))
{
lpItem->lpGPOName = lpItem->lpDisplayName + lstrlen (lpItem->lpDisplayName) + 1;
ulNoChars = ulNoChars - (lstrlen (lpItem->lpDisplayName) + 1);
hr = StringCchCopy (lpItem->lpGPOName,
ulNoChars,
szName);
}
if (SUCCEEDED(hr))
{
lpItem->lpDSPath = lpItem->lpGPOName + lstrlen (lpItem->lpGPOName) + 1;
ulNoChars = ulNoChars - (lstrlen (lpItem->lpGPOName) + 1);
hr = StringCchCopy (lpItem->lpDSPath,
ulNoChars,
szGPO);
}
if (SUCCEEDED(hr))
{
lpItem->dwOptions = dwOptions;
lpItem->dwDisabled = dwDisabled;
lpItem->bReadOnly = bReadOnly;
lpItem->bLocked = FALSE;
DebugMsg((DM_VERBOSE, TEXT("CGroupPolicyMgr::CreateEntry: Adding %s"), lpName));
DebugMsg((DM_VERBOSE, TEXT("CGroupPolicyMgr::CreateEntry: GPO Name %s"), szName));
DebugMsg((DM_VERBOSE, TEXT("CGroupPolicyMgr::CreateEntry: DS Path %s"), szGPO));
DebugMsg((DM_VERBOSE, TEXT("CGroupPolicyMgr::CreateEntry: Options %d"), dwOptions));
DebugMsg((DM_VERBOSE, TEXT("CGroupPolicyMgr::CreateEntry: Disabled %d"), dwDisabled));
DebugMsg((DM_VERBOSE, TEXT("CGroupPolicyMgr::CreateEntry: ReadOnly %d"), bReadOnly));
}
else
{
LocalFree(lpItem);
lpItem = NULL;
}
if (lpFullName)
{
LocalFree (lpFullName);
}
return lpItem;
}
BOOL CGroupPolicyMgr::AddGPOToList (HWND hLV, LPTSTR szName, LPTSTR szGPO,
DWORD dwOptions, BOOL bHighest,
DWORD dwDisabled, BOOL bReadOnly)
{
LPGPOITEM lpItem;
LV_ITEM item;
INT iItem;
//
// Create the link list entry
//
lpItem = CreateEntry (szName, szGPO, dwOptions, dwDisabled, bReadOnly);
if (!lpItem)
{
return FALSE;
}
//
// Add the item
//
item.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
item.iItem = (bHighest ? 0 : ListView_GetItemCount(hLV));
item.iSubItem = 0;
item.pszText = LPSTR_TEXTCALLBACK;
item.lParam = (LPARAM) lpItem;
if ((dwDisabled & GPO_OPTION_DISABLE_USER) && (dwDisabled & GPO_OPTION_DISABLE_MACHINE))
{
item.iImage = 1;
}
else if (dwDisabled == 0)
{
item.iImage = 0;
}
else
{
item.iImage = 2;
}
iItem = ListView_InsertItem (hLV, &item);
//
// Select the item
//
item.mask = LVIF_STATE;
item.iItem = iItem;
item.iSubItem = 0;
item.state = LVIS_SELECTED | LVIS_FOCUSED;
item.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
SendMessage (hLV, LVM_SETITEMSTATE, 0, (LPARAM) &item);
return TRUE;
}
INT_PTR CALLBACK CGroupPolicyMgr::RemoveGPODlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_INITDIALOG:
{
LPGPOITEM lpGPO = (LPGPOITEM)lParam;
TCHAR szBuffer[200];
LPTSTR lpTitle;
HICON hIcon;
ULONG ulNoChars;
hIcon = LoadIcon (NULL, IDI_QUESTION);
if (hIcon)
{
SendDlgItemMessage (hDlg, IDC_QUESTION, STM_SETICON, (WPARAM) hIcon, 0);
}
GetDlgItemText (hDlg, IDC_REMOVE_TITLE, szBuffer, ARRAYSIZE(szBuffer));
ulNoChars = lstrlen(szBuffer) + lstrlen(lpGPO->lpDisplayName) + 1;
lpTitle = (LPTSTR) LocalAlloc (LPTR, ulNoChars * sizeof(TCHAR));
if (lpTitle)
{
(void) StringCchPrintf (lpTitle, ulNoChars, szBuffer, lpGPO->lpDisplayName);
SetDlgItemText (hDlg, IDC_REMOVE_TITLE, lpTitle);
LocalFree (lpTitle);
}
CheckDlgButton (hDlg, IDC_REMOVE_LIST, BST_CHECKED);
if (lpGPO->bReadOnly)
{
EnableWindow (GetDlgItem(hDlg, IDC_REMOVE_DS), FALSE);
}
}
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDOK:
if (IsDlgButtonChecked (hDlg, IDC_REMOVE_LIST) == BST_CHECKED)
{
EndDialog (hDlg, 1);
}
else
{
EndDialog (hDlg, 2);
}
return TRUE;
case IDCANCEL:
EndDialog (hDlg, 0);
return TRUE;
}
break;
case WM_HELP: // F1
WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, HELP_FILE, HELP_WM_HELP,
(ULONG_PTR) (LPSTR) aRemoveGPOHelpIds);
break;
case WM_CONTEXTMENU: // right mouse click
WinHelp((HWND) wParam, HELP_FILE, HELP_CONTEXTMENU,
(ULONG_PTR) (LPSTR) aRemoveGPOHelpIds);
return (TRUE);
}
return FALSE;
}
INT_PTR CALLBACK CGroupPolicyMgr::LinkOptionsDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_INITDIALOG:
{
LPGPOITEM lpItem = (LPGPOITEM) lParam;
TCHAR szBuffer[50];
LPTSTR lpTitle;
ULONG ulNoChars;
SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) lpItem);
GetWindowText (hDlg, szBuffer, ARRAYSIZE(szBuffer));
ulNoChars = lstrlen(szBuffer) + lstrlen(lpItem->lpDisplayName) + 1;
lpTitle = (LPTSTR) LocalAlloc (LPTR, (lstrlen(szBuffer) +
lstrlen(lpItem->lpDisplayName) + 1) * sizeof(TCHAR));
if (lpTitle)
{
(void) StringCchPrintf (lpTitle, ulNoChars, szBuffer, lpItem->lpDisplayName);
SetWindowText (hDlg, lpTitle);
LocalFree (lpTitle);
}
if (lpItem->dwOptions & GPO_FLAG_DISABLE)
{
CheckDlgButton (hDlg, IDC_GPM_DISABLED, BST_CHECKED);
}
if (lpItem->dwOptions & GPO_FLAG_FORCE)
{
CheckDlgButton (hDlg, IDC_GPM_NOOVERRIDE, BST_CHECKED);
}
}
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDC_GPM_DISABLED:
{
if ((HIWORD(wParam) == BN_CLICKED) &&
(IsDlgButtonChecked (hDlg, IDC_GPM_DISABLED) == BST_CHECKED))
{
TCHAR szMessage[200];
TCHAR szTitle[100];
LoadString (g_hInstance, IDS_CONFIRMDISABLE, szMessage, ARRAYSIZE(szMessage));
LoadString (g_hInstance, IDS_CONFIRMTITLE2, szTitle, ARRAYSIZE(szTitle));
if (MessageBox (hDlg, szMessage, szTitle, MB_YESNO |
MB_ICONWARNING | MB_DEFBUTTON2) == IDNO) {
CheckDlgButton (hDlg, IDC_GPM_DISABLED, BST_UNCHECKED);
}
}
}
break;
case IDOK:
{
LPGPOITEM lpItem;
DWORD dwTemp = 0;
lpItem = (LPGPOITEM) GetWindowLongPtr (hDlg, DWLP_USER);
if (IsDlgButtonChecked (hDlg, IDC_GPM_DISABLED) == BST_CHECKED)
{
dwTemp |= GPO_FLAG_DISABLE;
}
if (IsDlgButtonChecked (hDlg, IDC_GPM_NOOVERRIDE) == BST_CHECKED)
{
dwTemp |= GPO_FLAG_FORCE;
}
if (dwTemp != lpItem->dwOptions)
{
lpItem->dwOptions = dwTemp;
EndDialog (hDlg, 1);
}
else
{
EndDialog (hDlg, 0);
}
}
return TRUE;
case IDCANCEL:
EndDialog (hDlg, 0);
return TRUE;
}
break;
case WM_HELP: // F1
WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, HELP_FILE, HELP_WM_HELP,
(ULONG_PTR) (LPSTR) aLinkOptionsHelpIds);
break;
case WM_CONTEXTMENU: // right mouse click
WinHelp((HWND) wParam, HELP_FILE, HELP_CONTEXTMENU,
(ULONG_PTR) (LPSTR) aLinkOptionsHelpIds);
return (TRUE);
}
return FALSE;
}
INT_PTR CALLBACK CGroupPolicyMgr::NoDSObjectDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_INITDIALOG:
{
CGroupPolicyMgr *pGPM = (CGroupPolicyMgr *)lParam;
TCHAR szBuffer[100];
TCHAR szTitle[300];
LPTSTR lpMsg, lpMsgEx;
INT iSize;
HWND hMsg = GetDlgItem (hDlg, IDC_NODSOBJECT_TEXT);
HICON hIcon;
hIcon = LoadIcon (NULL, IDI_ERROR);
if (hIcon)
{
SendDlgItemMessage (hDlg, IDC_NODSOBJECT_ICON, STM_SETICON, (WPARAM) hIcon, 0);
}
GetWindowText (hDlg, szBuffer, ARRAYSIZE(szBuffer));
(void) StringCchPrintf (szTitle, ARRAYSIZE(szTitle), szBuffer, pGPM->m_lpGPODCName);
SetWindowText (hDlg, szTitle);
iSize = 600;
iSize += lstrlen(pGPM->m_lpGPODCName);
iSize += lstrlen(pGPM->m_lpDSADCName);
iSize++;
lpMsg = (LPTSTR) LocalAlloc(LPTR, iSize * sizeof(TCHAR));
if (lpMsg)
{
lpMsgEx = (LPTSTR) LocalAlloc(LPTR, iSize * sizeof(TCHAR));
if (lpMsgEx)
{
LoadString (g_hInstance, IDS_NODSOBJECT_MSG, lpMsg, iSize);
(void) StringCchPrintf (lpMsgEx, iSize, lpMsg, pGPM->m_lpGPODCName, pGPM->m_lpDSADCName);
SetWindowText (hMsg, lpMsgEx);
LocalFree (lpMsgEx);
}
LocalFree (lpMsg);
}
}
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDOK:
case IDCANCEL:
EndDialog (hDlg, 1);
return TRUE;
case IDHELP:
{
SHELLEXECUTEINFO ShellInfo;
WCHAR pszHelpFilePath[ MAX_PATH ];
memset( &ShellInfo, 0, sizeof( ShellInfo ) );
ExpandEnvironmentStringsW (
L"%SystemRoot%\\Help\\gpedit.chm::/sag_spTShoot.htm",
pszHelpFilePath, MAX_PATH);
ShellInfo.cbSize = sizeof( ShellInfo );
ShellInfo.fMask = SEE_MASK_FLAG_NO_UI | SEE_MASK_DOENVSUBST;
ShellInfo.lpVerb = L"open";
ShellInfo.lpFile = L"%SystemRoot%\\hh.exe";
ShellInfo.lpParameters = pszHelpFilePath;
ShellInfo.nShow = SW_SHOWNORMAL;
(void) ShellExecuteEx( &ShellInfo );
break;
}
}
break;
}
return FALSE;
}
DWORD CGroupPolicyMgr::IsGPODisabled(LPTSTR lpGPO)
{
HRESULT hr;
LPTSTR lpTemp;
DWORD dwOptions = 0;
LPGROUPPOLICYOBJECT pGPO = NULL;
//
// Create a GroupPolicyObject to work with
//
hr = CoCreateInstance (CLSID_GroupPolicyObject, NULL,
CLSCTX_SERVER, IID_IGroupPolicyObject,
(void**)&pGPO);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("IsGPODisabled: Failed to create GPO object with 0x%x."), hr));
return 0;
}
lpTemp = GetFullGPOPath (lpGPO, NULL);
if (!lpTemp)
{
pGPO->Release();
return 0;
}
//
// Open the requested object without mounting the registry
//
hr = pGPO->OpenDSGPO(lpTemp, GPO_OPEN_READ_ONLY);
LocalFree (lpTemp);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("IsGPODisabled: Failed to open GPO object with 0x%x."), hr));
pGPO->Release();
return 0;
}
//
// Get the options
//
hr = pGPO->GetOptions(&dwOptions);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("IsGPODisabled: Failed to get GPO options with 0x%x."), hr));
pGPO->Release();
return 0;
}
pGPO->Release();
return dwOptions;
}
void CGroupPolicyMgr::CheckIconStatus (HWND hLV, LPGPOITEM lpGPO)
{
LPGPOITEM lpItem;
LV_ITEM item;
INT iIndex = -1;
DWORD dwDisabled;
//
// Check if the GPO disabled
//
dwDisabled = IsGPODisabled(lpGPO->lpDSPath);
//
// If the status hasn't changed, exit now
//
if (dwDisabled == lpGPO->dwDisabled)
{
return;
}
//
// Enumerate through the items
//
while ((iIndex = ListView_GetNextItem (hLV, iIndex, LVNI_ALL)) != -1)
{
item.mask = LVIF_PARAM;
item.iItem = iIndex;
item.iSubItem = 0;
if (!ListView_GetItem (hLV, &item))
{
continue;
}
lpItem = (LPGPOITEM) item.lParam;
//
// If the item has a path to the GPO in question,
// update the icon
//
if (!lstrcmpi (lpItem->lpDSPath, lpGPO->lpDSPath))
{
//
// Update the icon if appropriate
//
item.mask = LVIF_IMAGE;
item.iItem = iIndex;
item.iSubItem = 0;
if ((dwDisabled & GPO_OPTION_DISABLE_USER) && (dwDisabled & GPO_OPTION_DISABLE_MACHINE))
{
item.iImage = 1;
}
else if (dwDisabled == 0)
{
item.iImage = 0;
}
else
{
item.iImage = 2;
}
SendMessage (hLV, LVM_SETITEM, 0, (LPARAM) &item);
ListView_RedrawItems (hLV, iIndex, iIndex);
}
}
lpGPO->dwDisabled = dwDisabled;
}
LPTSTR CGroupPolicyMgr::GetFullGPOPath (LPTSTR lpGPO, HWND hParent)
{
LPTSTR lpFullPath = NULL, lpDomainName = NULL;
LPTSTR lpGPODCName;
LPOLESTR pszDomain;
HRESULT hr;
//
// Get the friendly domain name
//
pszDomain = GetDomainFromLDAPPath(lpGPO);
if (!pszDomain)
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyObject::GetFullGPOPath: Failed to get domain name")));
return NULL;
}
//
// Convert LDAP to dot (DN) style
//
hr = ConvertToDotStyle (pszDomain, &lpDomainName);
delete [] pszDomain;
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyObject::CreatePropertyPages: Failed to convert domain name with 0x%x"), hr));
return NULL;
}
if (!lstrcmpi(lpDomainName, m_lpDomainName))
{
//
// Make the full path
//
lpFullPath = MakeFullPath (lpGPO, m_lpGPODCName);
if (!lpFullPath)
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyObject::GetFullGPOPath: Failed to build new DS object path")));
goto Exit;
}
}
else
{
//
// Get the GPO DC for this domain
//
lpGPODCName = GetDCName (lpDomainName, NULL, hParent, TRUE, 0);
if (!lpGPODCName)
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyObject::GetFullGPOPath: Failed to get DC name for %s"),
lpDomainName));
goto Exit;
}
//
// Make the full path
//
lpFullPath = MakeFullPath (lpGPO, lpGPODCName);
LocalFree (lpGPODCName);
if (!lpFullPath)
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyObject::GetFullGPOPath: Failed to build new DS object path")));
goto Exit;
}
}
Exit:
if (lpDomainName)
{
LocalFree (lpDomainName);
}
return lpFullPath;
}
BOOL CGroupPolicyMgr::StartGPE (LPTSTR lpGPO, HWND hParent)
{
LPTSTR lpDomainName;
LPOLESTR pszDomain;
HRESULT hr;
BOOL bResult;
//
// Get the friendly domain name
//
pszDomain = GetDomainFromLDAPPath(lpGPO);
if (!pszDomain)
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyObject::StartGPE: Failed to get domain name")));
return FALSE;
}
//
// Convert LDAP to dot (DN) style
//
hr = ConvertToDotStyle (pszDomain, &lpDomainName);
delete [] pszDomain;
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyObject::CreatePropertyPages: Failed to convert domain name with 0x%x"), hr));
return FALSE;
}
//
// Check if the GPO is in the same domain as GPM is focused on
//
if (!lstrcmpi(lpDomainName, m_lpDomainName))
{
bResult = SpawnGPE (lpGPO, m_gpHint, m_lpGPODCName, hParent);
}
else
{
bResult = SpawnGPE (lpGPO, m_gpHint, NULL, hParent);
}
LocalFree (lpDomainName);
return bResult;
}
///////////////////////////////////////////////////////////////////////////////
// //
// Class factory object implementation //
// //
///////////////////////////////////////////////////////////////////////////////
CGroupPolicyMgrCF::CGroupPolicyMgrCF()
{
m_cRef = 1;
InterlockedIncrement(&g_cRefThisDll);
}
CGroupPolicyMgrCF::~CGroupPolicyMgrCF()
{
InterlockedDecrement(&g_cRefThisDll);
}
///////////////////////////////////////////////////////////////////////////////
// //
// Class factory object implementation (IUnknown) //
// //
///////////////////////////////////////////////////////////////////////////////
STDMETHODIMP_(ULONG)
CGroupPolicyMgrCF::AddRef()
{
return ++m_cRef;
}
STDMETHODIMP_(ULONG)
CGroupPolicyMgrCF::Release()
{
if (--m_cRef == 0)
{
delete this;
return 0;
}
return m_cRef;
}
STDMETHODIMP
CGroupPolicyMgrCF::QueryInterface(REFIID riid, LPVOID FAR* ppv)
{
if (IsEqualIID(riid, IID_IUnknown) || IsEqualIID(riid, IID_IClassFactory))
{
*ppv = (LPCLASSFACTORY)this;
m_cRef++;
return S_OK;
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
}
///////////////////////////////////////////////////////////////////////////////
// //
// Class factory object implementation (IClassFactory) //
// //
///////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CGroupPolicyMgrCF::CreateInstance(LPUNKNOWN pUnkOuter,
REFIID riid,
LPVOID FAR* ppvObj)
{
*ppvObj = NULL;
if (pUnkOuter)
return CLASS_E_NOAGGREGATION;
CGroupPolicyMgr *pComponentData = new CGroupPolicyMgr(); // ref count == 1
if (!pComponentData)
return E_OUTOFMEMORY;
HRESULT hr = pComponentData->QueryInterface(riid, ppvObj);
pComponentData->Release(); // release initial ref
return hr;
}
STDMETHODIMP
CGroupPolicyMgrCF::LockServer(BOOL fLock)
{
return E_NOTIMPL;
}